Multi-Chain Operations

const dsa = new DSA(web3, 137) // Will throw error if Web3 is not on Polygon

const dsa = new DSA(
  web3,
  137,
  { skipChainIdValidation: true }
)

console.log('Current Chain ID:', dsa.instance.chainId)

// Get accounts on Ethereum
const ethDsa = new DSA(web3Eth, 1)
const ethAccounts = await ethDsa.getAccounts(userAddress)

// Get accounts on Polygon
const polygonDsa = new DSA(web3Polygon, 137)
const polygonAccounts = await polygonDsa.getAccounts(userAddress)

console.log('Ethereum DSAs:', ethAccounts.length)
console.log('Polygon DSAs:', polygonAccounts.length)

async function createAccountOnAllChains(userAddress) {
  const chains = [
    { id: 1, name: 'Ethereum', rpc: 'https://eth-mainnet...' },
    { id: 137, name: 'Polygon', rpc: 'https://polygon-rpc.com' },
    { id: 42161, name: 'Arbitrum', rpc: 'https://arb1.arbitrum.io/rpc' },
  ]

  for (const chain of chains) {
    const web3 = new Web3(new Web3.providers.HttpProvider(chain.rpc))
    const dsa = new DSA({ web3, mode: 'node', privateKey: PRIVATE_KEY }, chain.id)

    const accounts = await dsa.getAccounts(userAddress)

    if (accounts.length === 0) {
      console.log(`Creating DSA on ${chain.name}...`)
      await dsa.build()
      console.log(`✓ Created DSA on ${chain.name}`)
    } else {
      console.log(`✓ DSA already exists on ${chain.name}`)
    }
  }
}

// Ethereum has the most protocols
const ethDsa = new DSA(web3, 1)
const ethSpell = ethDsa.Spell()
ethSpell.add({
  connector: 'aave',
  method: 'deposit',
  args: [/* ... */]
})

// Some protocols might not be on other chains
const polygonDsa = new DSA(web3, 137)
const polygonSpell = polygonDsa.Spell()
// Always verify protocol exists on target chain
polygonSpell.add({
  connector: 'aave', // Available on Polygon
  method: 'deposit',
  args: [/* ... */]
})

class MultiChainDSA {
  constructor() {
    this.chains = {
      ethereum: { id: 1, dsa: null },
      polygon: { id: 137, dsa: null },
      arbitrum: { id: 42161, dsa: null }
    }
  }

  async initialize(web3Providers, privateKey) {
    for (const [name, config] of Object.entries(this.chains)) {
      const web3 = new Web3(web3Providers[name])
      config.dsa = new DSA(
        { web3, mode: 'node', privateKey },
        config.id
      )
    }
  }

  async getAccountsAllChains(userAddress) {
    const results = {}

    for (const [name, config] of Object.entries(this.chains)) {
      results[name] = await config.dsa.getAccounts(userAddress)
    }

    return results
  }

  async depositOnChain(chainName, amount) {
    const dsa = this.chains[chainName].dsa

    const spell = dsa.Spell()
    spell.add({
      connector: 'aave',
      method: 'deposit',
      args: ['0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee', amount, 0, 0]
    })

    return await spell.cast()
  }

  async getTotalValueAllChains(userAddress) {
    let totalValue = 0

    for (const [name, config] of Object.entries(this.chains)) {
      const accounts = await config.dsa.getAccounts(userAddress)

      for (const account of accounts) {
        // Fetch balance logic here
        const balance = await this.getAccountBalance(config.dsa, account)
        totalValue += balance
      }
    }

    return totalValue
  }

  async getAccountBalance(dsa, account) {
    // Implement balance fetching logic
    return 0
  }
}

// Usage
const multiChainDSA = new MultiChainDSA()

await multiChainDSA.initialize(
  {
    ethereum: 'https://eth-mainnet.alchemyapi.io/v2/KEY',
    polygon: 'https://polygon-rpc.com',
    arbitrum: 'https://arb1.arbitrum.io/rpc'
  },
  process.env.PRIVATE_KEY
)

const accounts = await multiChainDSA.getAccountsAllChains(userAddress)
console.log('Accounts per chain:', accounts)

// Deposit on Polygon
await multiChainDSA.depositOnChain('polygon', '1000000000000000000')

async function switchToNetwork(chainId) {
  const chainParams = {
    1: {
      chainId: '0x1',
      chainName: 'Ethereum Mainnet'
    },
    137: {
      chainId: '0x89',
      chainName: 'Polygon',
      rpcUrls: ['https://polygon-rpc.com'],
      nativeCurrency: { name: 'MATIC', symbol: 'MATIC', decimals: 18 },
      blockExplorerUrls: ['https://polygonscan.com']
    },
    42161: {
      chainId: '0xa4b1',
      chainName: 'Arbitrum One',
      rpcUrls: ['https://arb1.arbitrum.io/rpc'],
      nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
      blockExplorerUrls: ['https://arbiscan.io']
    }
  }

  try {
    await window.ethereum.request({
      method: 'wallet_switchEthereumChain',
      params: [{ chainId: chainParams[chainId].chainId }]
    })
  } catch (error) {
    // Chain not added, try to add it
    if (error.code === 4902) {
      await window.ethereum.request({
        method: 'wallet_addEthereumChain',
        params: [chainParams[chainId]]
      })
    }
  }
}

// Switch to Polygon
await switchToNetwork(137)