Cross-Chain Checkout

Implementation Steps

1. Setup Prerequisites

   Ensure you have the following installed:

   • Node.js (v16 or higher)
   • TypeScript and ts-node
   • Environment variables configured
2. Initialize Project

   Create and set up a new Node.js project:

   mkdir contract-call-example
   cd contract-call-example
   npm init -y
   
3. Install Dependencies

   Install the required packages:

   npm install ethers dotenv @aarc-xyz/core-viem
   npm install --save-dev typescript ts-node
   
4. Configure TypeScript

   Create a tsconfig.json file:

   {
     "compilerOptions": {
       "target": "ES2020",
       "module": "CommonJS",
       "strict": true,
       "esModuleInterop": true
     }
   }
   
5. Setup Environment Variables

   Create a .env file in the root directory:

   API_KEY=your_aarc_api_key
   PRIVATE_KEY=your_private_key
   RPC_URL=your_rpc_url
   

   Ensure dotenv is loaded in your script to access these variables.

6. Create Implementation File

   Create a new file contract-call-example.ts with the following components:

   Load Environment

   import { config } from 'dotenv';
   import { ethers } from 'ethers';
   import { AarcCore } from '@aarc-xyz/core-viem';
   
   config();
   const API_KEY = process.env.API_KEY!;
   const PRIVATE_KEY = process.env.PRIVATE_KEY!;
   const RPC_URL = process.env.RPC_URL!;
   

   Initialize SDK

   const aarcCoreSDK = new AarcCore(API_KEY);
   const walletProvider = ethers.getDefaultProvider(RPC_URL);
   const wallet = new ethers.Wallet(PRIVATE_KEY, walletProvider);
   

   Configure Destination

   const destinationWalletAddress = "0x45c0470ef627a30efe30c06b13d883669b8fd3a8";
   const destinationToken = {
     decimals: 6,
     chainId: 8453,
     address: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
   };
   

   Fetch Balances

   async function getMultichainBalance(address: string) {
     return await aarcCoreSDK.fetchMultiChainBalances(address, {
       tokenAddress: destinationToken.address,
       tokenChainId: destinationToken.chainId,
       tokenAmount: requestedAmount,
     });
   }
   const balances = await getMultichainBalance(wallet.address);
   console.log('Balances:', balances);
   

   Generate Call Data

   function generateCheckoutCallData(
     token: string,
     toAddress: string,
     amount: string
   ): string {
     const simpleDappInterface = new ethers.Interface([
       "function mint(address token, address to, uint256 amount) external",
     ]);
   
     return simpleDappInterface.encodeFunctionData("mint", [
       token,
       toAddress,
       amount,
     ]);
   }
   
   const contractPayload = generateCheckoutCallData(
     destinationToken.address,
     destinationWalletAddress,
     "10000"
   );
   

   Get Deposit Address

   async function getDepositAddress(contractPayload, fromToken, fromAmount) {
     const transferType = TransferType.WALLET;
     const provider = undefined;
   
     const payload: any = {
       userOpHash: "",
       transferType,
       destinationChainId: destinationToken.chainId?.toString() ?? "",
       destinationTokenAddress: destinationToken.address ?? "",
       toAmount: baseToAmount,
       destinationRecipient: destinationWalletAddress ?? "",
       targetCalldata: contractPayload,
       fromAmount,
       fromChainId,
       fromTokenAddress,
       fromAddress
     };
     
     return aarcCoreSDK.getDepositAddress(payload);
   }
   
   const depositData = await getDepositAddress({
     contractPayload: callData,
     fromToken: { decimals: 18, chainId: 1, address: 'fromTokenAddress' },
     fromTokenAmount: '0.01',
   });
   

   Execute Transaction

   const tx = {
     to: depositData.depositAddress,
     value: ethers.utils.parseEther('0.01'),
     data: depositData.txData,
   };
   const txResponse = await wallet.sendTransaction(tx);
   console.log('Transaction Hash:', txResponse.hash);
   
   await aarcCoreSDK.postExecuteToAddress({
     depositData,
     trxHash: txResponse.hash,
   });
   

   Monitor Status

   async function pollRequestStatus(requestId: string) {
     let status;
     do {
       status = await aarcCoreSDK.getRequestStatus(requestId);
       console.log('Polling status:', status);
   
       if (status.pollStatus === 'success') {
         break;
       }
   
       await new Promise(resolve => setTimeout(resolve, 10000));
     } while (status.pollStatus !== 'success');
   }
   
   pollRequestStatus(depositData.requestId);
   
7. Run Implementation

   Execute the script:

   npx ts-node contract-call-example.ts
   
8. Handle Output

   Monitor the following outputs:

   • Wallet balances
   • Generated call data
   • Deposit address
   • Transaction hash
   • Polling status updates until completion
9. Error Handling

   Implement proper error handling:

   • Use try...catch blocks for API errors
   • Validate input parameters
   • Check for insufficient balances
   • Handle unavailable routes
   • Log descriptive error messages

For a more comprehensive implementation of polling, refer to our polling example.

Now you can checkout to a cross-chain contract call with different payment methods. :tada: