@ardrive/turbo-sdk 1.33.1 → 1.34.0-alpha.2

package/lib/cjs/utils/common.js

@@ -7,6 +7,12 @@ exports.createTurboSigner = createTurboSigner;
 exports.signerFromKyvePrivateKey = signerFromKyvePrivateKey;
 exports.signerFromKyveMnemonic = signerFromKyveMnemonic;
 exports.isBlob = isBlob;
+exports.isValidArweaveBase64URL = isValidArweaveBase64URL;
+exports.isValidSolanaAddress = isValidSolanaAddress;
+exports.isValidECDSAAddress = isValidECDSAAddress;
+exports.isValidKyveAddress = isValidKyveAddress;
+exports.isValidUserAddress = isValidUserAddress;
+exports.isAnyValidUserAddress = isAnyValidUserAddress;
 /**
  * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
  *
@@ -28,6 +34,7 @@ const encoding_1 = require("@cosmjs/encoding");
 const arbundles_1 = require("@dha-team/arbundles");
 const bytes_1 = require("@ethersproject/bytes");
 const signing_key_1 = require("@ethersproject/signing-key");
+const web3_js_1 = require("@solana/web3.js");
 const ethers_1 = require("ethers");
 const types_js_1 = require("../types.js");
 function sleep(ms) {
@@ -36,15 +43,21 @@ function sleep(ms) {
 function isWeb() {
     return typeof window !== 'undefined';
 }
+const ethTestnetRpc = 'https://eth-sepolia.public.blastapi.io';
+const baseTestnetRpc = 'https://sepolia.base.org';
+const polygonTestnetRpc = 'https://rpc-amoy.polygon.technology';
 exports.tokenToDevGatewayMap = {
     arweave: 'https://arweave.net', // No arweave test net
     ario: 'https://arweave.net', // No arweave test net
     solana: 'https://api.devnet.solana.com',
-    ethereum: 'https://ethereum-holesky-rpc.publicnode.com',
-    'base-eth': 'https://sepolia.base.org',
+    ethereum: ethTestnetRpc,
+    'base-eth': baseTestnetRpc,
     kyve: 'https://api.korellia.kyve.network',
-    matic: 'https://rpc-amoy.polygon.technology',
-    pol: 'https://rpc-amoy.polygon.technology',
+    matic: polygonTestnetRpc,
+    pol: polygonTestnetRpc,
+    usdc: ethTestnetRpc,
+    'base-usdc': baseTestnetRpc,
+    'polygon-usdc': polygonTestnetRpc,
 };
 exports.tokenToDevAoConfigMap = {
     ario: {
@@ -61,6 +74,9 @@ exports.defaultProdGatewayUrls = {
     kyve: 'https://api.kyve.network/',
     matic: 'https://polygon-rpc.com/',
     pol: 'https://polygon-rpc.com/',
+    usdc: 'https://cloudflare-eth.com/',
+    'base-usdc': 'https://mainnet.base.org',
+    'polygon-usdc': 'https://polygon-rpc.com/',
 };
 exports.defaultProdAoConfigs = {
     ario: {
@@ -92,6 +108,9 @@ function createTurboSigner({ signer: clientProvidedSigner, privateKey: clientPro
         case 'pol':
         case 'matic':
         case 'base-eth':
+        case 'usdc':
+        case 'base-usdc':
+        case 'polygon-usdc':
             if (!(0, types_js_1.isEthPrivateKey)(clientProvidedPrivateKey)) {
                 throw new Error('A valid Ethereum private key must be provided for EthereumSigner.');
             }
@@ -123,3 +142,51 @@ async function signerFromKyveMnemonic(mnemonic) {
 function isBlob(val) {
     return typeof Blob !== 'undefined' && val instanceof Blob;
 }
+// check if it is a valid arweave base64url for a wallet public address, transaction id or smartweave contract
+function isValidArweaveBase64URL(base64URL) {
+    const base64URLRegex = new RegExp('^[a-zA-Z0-9_-]{43}$');
+    return base64URLRegex.test(base64URL);
+}
+function isValidSolanaAddress(address) {
+    try {
+        return web3_js_1.PublicKey.isOnCurve(address);
+    }
+    catch {
+        return false;
+    }
+}
+function isValidECDSAAddress(address) {
+    const ethAddressRegex = new RegExp('^0x[a-fA-F0-9]{40}$');
+    return ethAddressRegex.test(address);
+}
+function isValidKyveAddress(address) {
+    const kyveAddressRegex = new RegExp('^kyve[a-zA-Z0-9]{39}$');
+    return kyveAddressRegex.test(address);
+}
+function isValidUserAddress(address, type) {
+    switch (type) {
+        case 'arweave':
+        case 'ario':
+            return isValidArweaveBase64URL(address);
+        case 'solana':
+            return isValidSolanaAddress(address);
+        case 'ethereum':
+        case 'base-eth':
+        case 'matic':
+        case 'pol':
+        case 'base-usdc':
+        case 'usdc':
+        case 'polygon-usdc':
+            return isValidECDSAAddress(address);
+        case 'kyve':
+            return isValidKyveAddress(address);
+    }
+}
+function isAnyValidUserAddress(address) {
+    for (const type of types_js_1.tokenTypes) {
+        if (isValidUserAddress(address, type)) {
+            return type;
+        }
+    }
+    return false;
+}

package/lib/cjs/version.js

@@ -17,4 +17,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // AUTOMATICALLY GENERATED FILE - DO NOT TOUCH
-exports.version = '1.33.1';
+exports.version = '1.34.0-alpha.2';

package/lib/esm/cli/cli.js

@@ -39,7 +39,7 @@ applyOptions(program.command('balance').description('Get balance of a Turbo addr
 applyOptions(program.command('top-up').description('Top up a Turbo address with Fiat'), [...walletOptions, optionMap.address, optionMap.value, optionMap.currency]).action(async (_commandOptions, command) => {
     await runCommand(command, topUp);
 });
-applyOptions(program.command('crypto-fund').description('Top up a wallet with crypto'), [...walletOptions, optionMap.value, optionMap.txId]).action(async (_commandOptions, command) => {
+applyOptions(program.command('crypto-fund').description('Top up a wallet with crypto'), [...walletOptions, optionMap.value, optionMap.txId, optionMap.address]).action(async (_commandOptions, command) => {
     await runCommand(command, cryptoFund);
 });
 applyOptions(program.command('upload-folder').description('Upload a folder using Turbo'), uploadFolderOptions).action(async (_commandOptions, command) => {

package/lib/esm/cli/commands/cryptoFund.js

@@ -22,6 +22,7 @@ import { configFromOptions, tokenFromOptions, turboFromOptions, } from '../utils
 export async function cryptoFund(options) {
     const value = options.value;
     const txId = options.txId;
+    const address = options.address;
     if (txId !== undefined) {
         const turbo = TurboFactory.unauthenticated(configFromOptions(options));
         const result = await turbo.submitFundTransaction({ txId: txId });
@@ -41,7 +42,7 @@ export async function cryptoFund(options) {
         const { confirm } = await prompts({
             type: 'confirm',
             name: 'confirm',
-            message: `\nTransaction details:\n\n  Amount: ${value} ${token}\n  Target: ${targetWallet}\n  Est Credits to receive: ${credits}\n  Credit recipient: ${await turbo.signer.getNativeAddress()}\n  Note: Network Dependent Gas Fees May Apply\n\nThis payment is non-refundable.  Proceed with transaction?`,
+            message: `\nTransaction details:\n\n  Amount: ${value} ${token}\n  Target: ${targetWallet}\n  Est Credits to receive: ${credits}\n  Credit recipient: ${address ?? (await turbo.signer.getNativeAddress())}\n  Note: Network Dependent Gas Fees May Apply\n\nThis payment is non-refundable.  Proceed with transaction?`,
             initial: true,
         });
         if (!confirm) {
@@ -51,6 +52,7 @@ export async function cryptoFund(options) {
     }
     const result = await turbo.topUpWithTokens({
         tokenAmount,
+        turboCreditDestinationAddress: address,
     });
     console.log('Sent crypto fund transaction: \n', JSON.stringify(result, null, 2));
 }

package/lib/esm/common/payment.js

@@ -15,6 +15,7 @@
  */
 import { BigNumber } from 'bignumber.js';
 import { defaultRetryConfig } from '../utils/axiosClient.js';
+import { isAnyValidUserAddress } from '../utils/common.js';
 import { TurboHTTPService } from './http.js';
 import { TurboWinstonLogger } from './logger.js';
 import { exponentMap, tokenToBaseMap } from './token/index.js';
@@ -148,31 +149,37 @@ export class TurboUnauthenticatedPaymentService {
             return {
                 id: response.creditedTransaction.transactionId,
                 quantity: response.creditedTransaction.transactionQuantity,
-                owner: response.creditedTransaction.destinationAddress,
+                owner: response.creditedTransaction.transactionSenderAddress ??
+                    response.creditedTransaction.destinationAddress,
                 winc: response.creditedTransaction.winstonCreditAmount,
                 token: response.creditedTransaction.tokenType,
                 status: 'confirmed',
                 block: response.creditedTransaction.blockHeight,
+                recipient: response.creditedTransaction.destinationAddress,
             };
         }
         else if ('pendingTransaction' in response) {
             return {
                 id: response.pendingTransaction.transactionId,
                 quantity: response.pendingTransaction.transactionQuantity,
-                owner: response.pendingTransaction.destinationAddress,
+                owner: response.pendingTransaction.transactionSenderAddress ??
+                    response.pendingTransaction.destinationAddress,
                 winc: response.pendingTransaction.winstonCreditAmount,
                 token: response.pendingTransaction.tokenType,
                 status: 'pending',
+                recipient: response.pendingTransaction.destinationAddress,
             };
         }
         else if ('failedTransaction' in response) {
             return {
                 id: response.failedTransaction.transactionId,
                 quantity: response.failedTransaction.transactionQuantity,
-                owner: response.failedTransaction.destinationAddress,
+                owner: response.failedTransaction.transactionSenderAddress ??
+                    response.failedTransaction.destinationAddress,
                 winc: response.failedTransaction.winstonCreditAmount,
                 token: response.failedTransaction.tokenType,
                 status: 'failed',
+                recipient: response.failedTransaction.destinationAddress,
             };
         }
         throw new Error('Unknown response from payment service: ' + response);
@@ -267,10 +274,15 @@ export class TurboAuthenticatedPaymentService extends TurboUnauthenticatedPaymen
         }
         return walletAddress;
     }
-    async topUpWithTokens({ feeMultiplier = 1, tokenAmount: tokenAmountV, }) {
+    async topUpWithTokens({ feeMultiplier = 1, tokenAmount: tokenAmountV, turboCreditDestinationAddress, }) {
         if (!this.tokenTools) {
             throw new Error(`Token type not supported for crypto fund ${this.token}`);
         }
+        if (turboCreditDestinationAddress !== undefined) {
+            if (isAnyValidUserAddress(turboCreditDestinationAddress) === false) {
+                throw new Error(`Invalid turboCreditDestinationAddress provided: ${turboCreditDestinationAddress}`);
+            }
+        }
         const tokenAmount = new BigNumber(tokenAmountV);
         const target = await this.getTargetWalletForFund();
         this.logger.debug('Funding account...', {
@@ -283,6 +295,7 @@ export class TurboAuthenticatedPaymentService extends TurboUnauthenticatedPaymen
             tokenAmount,
             feeMultiplier,
             signer: this.signer,
+            turboCreditDestinationAddress,
         });
         const txId = fundTx.id;
         try {

package/lib/esm/common/signer.js

@@ -18,7 +18,7 @@ import { Secp256k1 } from '@cosmjs/crypto';
 import { toBase64 } from '@cosmjs/encoding';
 import { EthereumSigner, HexSolanaSigner } from '@dha-team/arbundles';
 import { computePublicKey } from '@ethersproject/signing-key';
-import { Connection, PublicKey, SystemProgram, Transaction, } from '@solana/web3.js';
+import { Connection, PublicKey, SystemProgram, Transaction, TransactionInstruction, } from '@solana/web3.js';
 import { BigNumber } from 'bignumber.js';
 import bs58 from 'bs58';
 import { randomBytes } from 'crypto';
@@ -28,6 +28,8 @@ import nacl from 'tweetnacl';
 import { isEthereumWalletAdapter, isSolanaWalletAdapter, } from '../types.js';
 import { fromB64Url, ownerToAddress as ownerToB64Address, toB64Url, } from '../utils/base64.js';
 import { TurboWinstonLogger } from './logger.js';
+import { ethDataFromTurboCreditDestinationAddress } from './token/ethereum.js';
+import { memoProgramId } from './token/solana.js';
 /**
  * Abstract class for signing TurboDataItems.
  */
@@ -46,6 +48,9 @@ export class TurboDataItemAbstractSigner {
             case 'matic':
             case 'pol':
             case 'base-eth':
+            case 'usdc':
+            case 'base-usdc':
+            case 'polygon-usdc':
                 return computeAddress(computePublicKey(fromB64Url(owner)));
             case 'kyve':
                 return pubkeyToAddress({
@@ -75,7 +80,7 @@ export class TurboDataItemAbstractSigner {
         return this.ownerToNativeAddress(toB64Url(await this.getPublicKey()), this.token);
     }
     /** Let the signer handle sending tx for better compat with cross chain libraries/web wallets */
-    async sendTransaction({ target, amount, gatewayUrl, }) {
+    async sendTransaction({ target, amount, gatewayUrl, turboCreditDestinationAddress, }) {
         if (this.walletAdapter) {
             if (isSolanaWalletAdapter(this.walletAdapter)) {
                 const connection = new Connection(gatewayUrl, 'confirmed');
@@ -89,6 +94,14 @@ export class TurboDataItemAbstractSigner {
                     toPubkey: new PublicKey(target),
                     lamports: +new BigNumber(amount),
                 }));
+                if (turboCreditDestinationAddress !== undefined) {
+                    tx.add(new TransactionInstruction({
+                        programId: new PublicKey(memoProgramId),
+                        keys: [],
+                        data: Buffer.from('turboCreditDestinationAddress=' +
+                            turboCreditDestinationAddress),
+                    }));
+                }
                 const signedTx = await this.walletAdapter.signTransaction(tx);
                 const id = await connection.sendRawTransaction(signedTx.serialize());
                 return id;
@@ -103,6 +116,7 @@ export class TurboDataItemAbstractSigner {
             const { hash } = await signer.sendTransaction({
                 to: target,
                 value: parseEther(amount.toFixed(18)),
+                data: ethDataFromTurboCreditDestinationAddress(turboCreditDestinationAddress),
             });
             return hash;
         }
@@ -115,6 +129,7 @@ export class TurboDataItemAbstractSigner {
         const tx = await ethWalletAndProvider.sendTransaction({
             to: target,
             value: parseEther(amount.toFixed(18)),
+            data: ethDataFromTurboCreditDestinationAddress(turboCreditDestinationAddress),
         });
         this.logger.debug('Sent transaction', { tx });
         return tx.hash;

package/lib/esm/common/token/ario.js

@@ -32,34 +32,42 @@ export class ARIOToken {
         this.pollingOptions = pollingOptions;
         this.logger = logger;
     }
-    async createAndSubmitTx({ target, signer: { signer }, tokenAmount, }) {
+    async createAndSubmitTx({ target, signer: { signer }, tokenAmount, turboCreditDestinationAddress, }) {
+        const tags = [
+            {
+                name: 'Action',
+                value: 'Transfer',
+            },
+            {
+                name: 'Recipient',
+                value: target,
+            },
+            {
+                name: 'Quantity',
+                value: tokenAmount.toString(),
+            },
+            {
+                name: 'Turbo-SDK',
+                value: version,
+            },
+        ];
+        if (turboCreditDestinationAddress !== undefined) {
+            tags.push({
+                name: 'Turbo-Credit-Destination-Address',
+                value: turboCreditDestinationAddress,
+            });
+        }
         const txId = await this.ao.message({
             signer: createAoSigner(signer),
             process: this.processId,
-            tags: [
-                {
-                    name: 'Action',
-                    value: 'Transfer',
-                },
-                {
-                    name: 'Recipient',
-                    value: target,
-                },
-                {
-                    name: 'Quantity',
-                    value: tokenAmount.toString(),
-                },
-                {
-                    name: 'Turbo-SDK',
-                    value: version,
-                },
-            ],
+            tags,
         });
         this.logger.debug('Submitted Transfer message to ARIO process...', {
             id: txId,
             target,
             tokenAmount,
             processId: this.processId,
+            tags,
         });
         return { id: txId, target, reward: '0' };
     }

package/lib/esm/common/token/arweave.js

@@ -40,7 +40,7 @@ export class ArweaveToken {
         this.mintU = mintU;
         this.pollingOptions = pollingOptions;
     }
-    async createAndSubmitTx({ feeMultiplier, target, tokenAmount, signer, }) {
+    async createAndSubmitTx({ feeMultiplier, target, tokenAmount, signer, turboCreditDestinationAddress, }) {
         const tx = await this.arweave.createTransaction({
             target,
             quantity: tokenAmount.toString(),
@@ -57,6 +57,9 @@ export class ArweaveToken {
             tx.addTag('Contract', 'KTzTXT_ANmF84fWEKHzWURD1LWd9QaFR9yfYUwH2Lxw'); // cspell:enable
             tx.addTag('Input', JSON.stringify({ function: 'mint' }));
         }
+        if (turboCreditDestinationAddress !== undefined) {
+            tx.addTag('Turbo-Credit-Destination-Address', turboCreditDestinationAddress);
+        }
         const publicKeyB64Url = toB64Url(await signer.getPublicKey());
         tx.setOwner(publicKeyB64Url);
         const dataToSign = await tx.getSignatureData();

package/lib/esm/common/token/baseEth.js

@@ -1,11 +1,12 @@
 import { defaultProdGatewayUrls } from '../../utils/common.js';
 import { EthereumToken } from './ethereum.js';
+export const defaultBaseNetworkPollingOptions = {
+    initialBackoffMs: 2_500,
+    maxAttempts: 10,
+    pollingIntervalMs: 750,
+};
 export class BaseEthToken extends EthereumToken {
-    constructor({ logger, gatewayUrl = defaultProdGatewayUrls['base-eth'], pollingOptions = {
-        initialBackoffMs: 2_500,
-        maxAttempts: 10,
-        pollingIntervalMs: 2_500,
-    }, } = {}) {
+    constructor({ logger, gatewayUrl = defaultProdGatewayUrls['base-eth'], pollingOptions = defaultBaseNetworkPollingOptions, } = {}) {
         super({
             logger,
             gatewayUrl,

package/lib/esm/common/token/erc20.js

@@ -0,0 +1,87 @@
+/**
+ * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { EthereumSigner } from '@dha-team/arbundles';
+import { Wallet as EthereumWallet, JsonRpcProvider, ethers } from 'ethers';
+import { isEthereumWalletAdapter, } from '../../types.js';
+import { defaultProdGatewayUrls } from '../../utils/common.js';
+import { TurboWinstonLogger } from '../logger.js';
+import { EthereumToken, ethDataFromTurboCreditDestinationAddress, } from './ethereum.js';
+export class ERC20Token extends EthereumToken {
+    constructor({ tokenContractAddress, logger = TurboWinstonLogger.default, gatewayUrl = defaultProdGatewayUrls.ethereum, pollingOptions, }) {
+        super({ logger, gatewayUrl, pollingOptions });
+        this.tokenContract = new ethers.Contract(tokenContractAddress, [
+            'function decimals() view returns (uint8)',
+            'function balanceOf(address) view returns (uint256)',
+            'function transfer(address to, uint256 value) returns (bool)',
+        ], this.rpcProvider);
+    }
+    async createAndSubmitTx({ target, tokenAmount, signer, turboCreditDestinationAddress, }) {
+        try {
+            let connected;
+            let walletOrSigner;
+            if (signer.signer instanceof EthereumSigner) {
+                const provider = new JsonRpcProvider(this.gatewayUrl);
+                // 🧩 CLI / Node path
+                const keyHex = Buffer.from(signer.signer.key).toString('hex');
+                walletOrSigner = new EthereumWallet(keyHex, provider);
+                connected = this.tokenContract.connect(walletOrSigner);
+            }
+            else if (signer.walletAdapter !== undefined &&
+                isEthereumWalletAdapter(signer.walletAdapter)) {
+                walletOrSigner = signer.walletAdapter.getSigner();
+                connected = this.tokenContract.connect(walletOrSigner);
+            }
+            else {
+                throw new Error('Unsupported signer -- must be EthereumSigner or have a walletAdapter implementing getSigner');
+            }
+            // Encode transfer data
+            const baseTransferData = connected.interface.encodeFunctionData('transfer', [target, tokenAmount.toString()]);
+            let finalData = baseTransferData;
+            // Append optional memo data with turbo credit destination address
+            const memoData = ethDataFromTurboCreditDestinationAddress(turboCreditDestinationAddress);
+            if (memoData !== undefined) {
+                // remove the "0x" prefix and append
+                finalData += memoData.slice(2);
+            }
+            const txRequest = {
+                to: await connected.getAddress(),
+                data: finalData,
+            };
+            this.logger.debug('Submitting ERC20 transfer', {
+                target,
+                tokenAmount: tokenAmount.toString(),
+                rpcEndpoint: this.gatewayUrl,
+                txRequest,
+            });
+            const tx = await walletOrSigner.sendTransaction(txRequest);
+            this.logger.debug('ERC20 transfer submitted', {
+                txHash: tx.hash,
+                target,
+                tx,
+            });
+            return { id: tx.hash, target };
+        }
+        catch (e) {
+            this.logger.error('Error creating/submitting ERC20 tx', {
+                error: e instanceof Error ? e.message : e,
+                target,
+                tokenAmount,
+                rpcEndpoint: this.gatewayUrl,
+            });
+            throw e;
+        }
+    }
+}

package/lib/esm/common/token/ethereum.js

@@ -14,34 +14,47 @@
  * limitations under the License.
  */
 import { BigNumber } from 'bignumber.js';
-import { ethers } from 'ethers';
+import { ethers, hexlify, toUtf8Bytes } from 'ethers';
 import { defaultProdGatewayUrls } from '../../utils/common.js';
 import { TurboWinstonLogger } from '../logger.js';
 export const weiToTokenAmount = (wei) => wei;
 export const ETHToTokenAmount = (eth) => new BigNumber(eth).times(1e18).valueOf();
+export const defaultEthereumPollingOptions = {
+    initialBackoffMs: 25_000,
+    maxAttempts: 10,
+    pollingIntervalMs: 1_500,
+};
 export class EthereumToken {
-    constructor({ logger = TurboWinstonLogger.default, gatewayUrl = defaultProdGatewayUrls.ethereum, pollingOptions = {
-        maxAttempts: 10,
-        pollingIntervalMs: 4_000,
-        initialBackoffMs: 10_000,
-    }, } = {}) {
+    constructor({ logger = TurboWinstonLogger.default, gatewayUrl = defaultProdGatewayUrls.ethereum, pollingOptions = defaultEthereumPollingOptions, } = {}) {
         this.logger = logger;
         this.gatewayUrl = gatewayUrl;
         this.pollingOptions = pollingOptions;
         this.rpcProvider = new ethers.JsonRpcProvider(gatewayUrl);
     }
-    async createAndSubmitTx({ target, tokenAmount, signer, }) {
-        // convert wei to eth
-        const eth = tokenAmount.shiftedBy(-18);
-        const txId = await signer.sendTransaction({
-            target,
-            amount: eth,
-            gatewayUrl: this.gatewayUrl,
-        });
-        return {
-            id: txId,
-            target,
-        };
+    async createAndSubmitTx({ target, tokenAmount, signer, turboCreditDestinationAddress, }) {
+        try {
+            // convert wei to eth
+            const eth = tokenAmount.shiftedBy(-18);
+            const txId = await signer.sendTransaction({
+                target,
+                amount: eth,
+                gatewayUrl: this.gatewayUrl,
+                turboCreditDestinationAddress,
+            });
+            return {
+                id: txId,
+                target,
+            };
+        }
+        catch (e) {
+            this.logger.error('Error creating and submitting Ethereum tx', {
+                error: e instanceof Error ? e.message : e,
+                target,
+                tokenAmount,
+                rpcEndpoint: this.gatewayUrl,
+            });
+            throw e;
+        }
     }
     async getTxAvailability(txId) {
         const tx = await this.rpcProvider.getTransaction(txId);
@@ -71,3 +84,9 @@ export class EthereumToken {
         throw new Error(`Transaction ${txId} not found after polling!`);
     }
 }
+export function ethDataFromTurboCreditDestinationAddress(turboCreditDestinationAddress) {
+    if (turboCreditDestinationAddress !== undefined) {
+        return hexlify(toUtf8Bytes('turboCreditDestinationAddress=' + turboCreditDestinationAddress));
+    }
+    return undefined;
+}

package/lib/esm/common/token/index.js

@@ -6,6 +6,7 @@ import { ETHToTokenAmount, EthereumToken } from './ethereum.js';
 import { KYVEToTokenAmount, KyveToken } from './kyve.js';
 import { POLToTokenAmount, PolygonToken } from './polygon.js';
 import { SOLToTokenAmount, SolanaToken } from './solana.js';
+import { USDCToTokenAmount, USDCToken } from './usdc.js';
 export const defaultTokenMap = {
     arweave: (config) => new ArweaveToken(config),
     ario: (config) => new ARIOToken(config),
@@ -15,8 +16,12 @@ export const defaultTokenMap = {
     kyve: (config) => new KyveToken(config),
     matic: (config) => new PolygonToken(config),
     pol: (config) => new PolygonToken(config),
+    usdc: (config) => new USDCToken({ network: 'ethereum', ...config }),
+    'base-usdc': (config) => new USDCToken({ network: 'base', ...config }),
+    'polygon-usdc': (config) => new USDCToken({ network: 'polygon', ...config }),
 };
 const ethExponent = 18;
+const usdcExponent = 6;
 export const exponentMap = {
     arweave: 12,
     ario: 6,
@@ -26,6 +31,9 @@ export const exponentMap = {
     kyve: 6,
     matic: ethExponent,
     pol: ethExponent,
+    usdc: usdcExponent,
+    'base-usdc': usdcExponent,
+    'polygon-usdc': usdcExponent,
 };
 export const tokenToBaseMap = {
     arweave: (a) => ARToTokenAmount(a),
@@ -36,6 +44,9 @@ export const tokenToBaseMap = {
     kyve: (a) => KYVEToTokenAmount(a),
     matic: (a) => POLToTokenAmount(a),
     pol: (a) => POLToTokenAmount(a),
+    usdc: (a) => USDCToTokenAmount(a),
+    'base-usdc': (a) => USDCToTokenAmount(a),
+    'polygon-usdc': (a) => USDCToTokenAmount(a),
 };
 export function isTokenType(token) {
     return tokenTypes.includes(token);

package/lib/esm/common/token/polygon.js

@@ -2,12 +2,13 @@ import { defaultProdGatewayUrls } from '../../utils/common.js';
 import { TurboWinstonLogger } from '../logger.js';
 import { ETHToTokenAmount, EthereumToken } from './ethereum.js';
 export const POLToTokenAmount = ETHToTokenAmount;
+export const defaultPolygonPollingOptions = {
+    maxAttempts: 10,
+    initialBackoffMs: 5_000,
+    pollingIntervalMs: 1_000,
+};
 export class PolygonToken extends EthereumToken {
-    constructor({ logger = TurboWinstonLogger.default, gatewayUrl = defaultProdGatewayUrls.pol, pollingOptions = {
-        maxAttempts: 10,
-        pollingIntervalMs: 4_000,
-        initialBackoffMs: 5_000,
-    }, } = {}) {
+    constructor({ logger = TurboWinstonLogger.default, gatewayUrl = defaultProdGatewayUrls.pol, pollingOptions = defaultPolygonPollingOptions, } = {}) {
         super({ logger, gatewayUrl, pollingOptions });
     }
 }