Mint an NFT on Arbitrum

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!;

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

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

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);

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"
);

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',
});

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,
});

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);