Example of Token Cross-Chain (JS)

1. EVM to ENDLESS

​
`First===>: Estimated gas`
//Gas Estimation Method
const getGasPrice = async (chain: ChainData) => {
    const provider = getProvider(chain.rpc_url)
    const feeData = await provider.getFeeData()
    return feeData.gasPrice?.toString() || '0'
}
​
const contract = await getContract(tokenAddress, IBridgePoolAbi, toChain.rpc_url)
const maxFeePerGasWei = await getGasPrice(toChain) //Get gas through 1559
const arg1 = {
    msg_header: _msgHead,
    msg_body: `0x${msg_body}`,
}
​
const amount = await contract.getLpFeeAndFinalAmount(
    combainChain(chain).toString(),
    sourceToken,
    BigInt(toChainNumber(bridgeData.amount, toToken.decimals)).toString(),
    ) //Get the payment amount by calling the contract
    useTokenStore.getState().updateReceiveAmount([...amount][1])
​
const gaslimit = await contract.processMsg.estimateGas(arg1, [], {
    from: '0x0000000000000000000000000000000000000001',
    })  //Get gasLimit
​
const estimatedGasCost = BigNumber(maxFeePerGasWei)
    .times(gaslimit.toString())
    .div(10 ** toChain.token_decimal)
    .toFixed()
​
`Second===>: Cross-chain`
​
//Cross-chain method
const bridgeTo = async () => {
​
  const gasFee = useBridgeStore.getState().gasFee
  let addr_bridge_token = toChain.addr_bridge_token
​
  const chain_type = getChainType(toChain.id)
  const chain_id = toChain.id.split('-')[1]
  const chain = new Uint8Array(9)
  chain.set(numberToU8(chain_type), 0)
  chain.set(numberToU64(Number(chain_id)), 1)
​
  const config = new EndlessConfig({
    network: EndlessNetwork,
  })
  const endless = new Endless(config)
 let feeAuto = BigInt(BigNumber(toChainNumber(gasFee, fromChain.token_decimal)).toFixed() || 0)
​
const functionArguments = [
    AccountAddress.fromBs58String(fromToken.address),
    chain,
    stringToBytes32(addr_bridge_token),
    stringToBytes32(receiveAddress),
    BigInt(toChainNumber(bridgeData.amount, fromToken.decimals)),
    feeAuto,
  ]
​
  const transferData: EndlessSignAndSubmitTransactionInput = {
    payload: {
      function: `${getBytes32Address(fromChain.id, fromChain.addr_bridge_token)}::execute::bridge_proposal`,
      functionArguments: functionArguments,
      typeArguments: [],
    },
  }
  const transactionRes = await useEndlessStore.getState()?.jssdk?.signAndSubmitTransaction(transferData)
  useTokenStore.getState().updateProgress(1)
  if (transactionRes?.status === UserResponseStatus.APPROVED) {
    const result = await endless.waitForTransaction({ transactionHash: transactionRes.args.hash })
    if (result.success) {
      return {
        txhash: transactionRes.args.hash,
        bridgeData: {},
      }
    } else {
      throw transactionRes
    }
    } else {
    throw transactionRes
   }
 }

2、ENDLESS to EVM

## EDS to ETH
​
`First===>: Estimated gas`
​
// This method can get the message body and message head required for cross-chain
const getBodyAndHead = (params: IBodyAndHead) => {
const { bridgeData, nonceMap, fromChain, toChain, fromToken, sourceToken, fromWho, toWho } = params
const gas = new BN(bridgeData.feeAuto)
const gasByte = gas.toArray('le', 16)
​
const nonce = new BN(BigNumber(nonceMap).plus(1).toString())
const nonceByte = nonce.toArray('le', 8)
​
const msgType = new BN(0)
const msgTypeByte = msgType.toArray('be', 1)
​
const from_chain_type = new BN(getChainType(fromChain.id))
const from_chain_typeByte = from_chain_type.toArray('be', 1)
​
const allAmountBN = new BN(BigInt(toChainNumber(bridgeData.amount, fromToken.decimals)).toString())
​
const allAmountByte = allAmountBN.toArray('be', 16)
​
const to_chain_type = new BN(getChainType(toChain.id))
const to_chain_typeByte = to_chain_type.toArray('be', 1)
​
const to_chain_id = new BN(toChain.id.split('-')[1])
const to_chain_idByte = to_chain_id.toArray('le', 8)
​
const from_chain_id = new BN(fromChain.id.split('-')[1])
const from_chain_idByte = from_chain_id.toArray('le', 8)
​
const head = msgTypeByte.concat(
    Array.from(nonceByte),
    Array.from(from_chain_typeByte),
    Array.from(from_chain_idByte),
    hexToArray(
    getBytes32Address(
        fromChain.id,
        getChainType(fromChain.id) === ChainType.TRX
        ? base58ToHex(fromChain.addr_bridge_token)
        : fromChain.addr_bridge_token,
    ),
    ),
    Array.from(to_chain_typeByte),
    Array.from(to_chain_idByte),
    hexToArray(
    getBytes32Address(
        toChain.id,
        getChainType(toChain.id) === ChainType.TRX ? base58ToHex(toChain.addr_bridge_token) : toChain.addr_bridge_token,
    ),
    ),
    Array.from(gasByte),
)
​
const body = hexToArray(cusHex(sourceToken)).concat(
    Array.from(allAmountByte),
    hexToArray(cusHex(fromWho)),
    hexToArray(cusHex(toWho)),
)
​
return { body, head }
}
​
const { body, head } = getBodyAndHead({
        bridgeData: bridgeData,
        nonceMap: res,
        fromChain: fromChain,
        toChain: toChain,
        fromToken: fromToken,
        sourceToken: sourceToken,
        fromWho: fromWho,
        toWho: toWho,
    })
​
getEstimateGas(head, body)
​
// Get gas from to chain
const getEstimateGas = async (mesHead: number[], mesBody: number[]) => {
​
const txn = await endless.transaction.build.simple({
    sender: ENDLESS_SIMULATE_SENDER,
    data: {
    function: `${ENDLESS_CONTRACT}::execute::bridge_finish_estimate_gas`,
    functionArguments: [mesHead, mesBody, [], []],
    },
})
​
const account = new Ed25519PublicKey(ENDLESS_SIMULATE_PUBLICKEY)
​
const transactionRes = await endless.transaction.simulate.simple({
    signerPublicKey: account,
    transaction: txn,
    feePayerPublicKey: account,
})
​
const gasFee = BigNumber(transactionRes[0].gas_used || 0)
.times(transactionRes[0].gas_unit_price)
.div(10 ** 8)
.toFixed()
}
​
`Second===>: Cross-chain`
//Cross-chain method
const bridgeTo = async () => {
   await approveErc20({
      token: fromToken.address,
      spender: fromChain.addr_bridge_token,
      decimal: fromToken.decimals,
      payAmount: bridgeData.amount,
      rpc: fromChain.rpc_url,
      nativeToken: fromChain.native_token,
      approveAmount: bridgeData.amount,
    })
​
    let value = BigNumber(0)
​
    value = value.plus(BigNumber(toChainNumber(gasFee, fromChain.token_decimal) || 0))
​
    if (bridgeData.feeFrom) {
      value = value.plus(bridgeData.feeFrom || 0)
    }
    if (fromToken.address.toLocaleLowerCase() === fromChain.native_token.toLocaleLowerCase()) {
      value = value.plus(toChainNumber(bridgeData.amount, fromChain.token_decimal))
    }
​
    if (collFee) {
      value = value.plus(collFee.toString())
    }
// value is composed of gas + platform fee + amount + collect fee
     const _bridgeData = [
      getBytes32Address(fromChain.id, fromToken.address),
      {
        chain_type: getChainType(toChain.id),
        chain_id: toChain.id.split('-')[1],
      },
      getBytes32Address(toChain.id, receiveAddress),
      getBytes32Address(toChain.id, toChain.addr_bridge_token),
      BigInt(toChainNumber(bridgeData.amount, fromToken.decimals)),
      BigInt(BigNumber(toChainNumber(gasFee, fromChain.token_decimal)).toFixed()),
    ]
​
    const params = {
      from: address,
      to: fromChain.addr_bridge_token,
      value: numberToHexString(value.toString()),
      data: new ethers.Interface(IBridgePoolAbi).encodeFunctionData('bridgeToken', _bridgeData),
    }
    await estimateGas({ params, rpc: fromChain.rpc_url })
    const txhash = (await sendTransaction([params])) || ''
} 
​