@atxp/worldchain 0.6.4

package/dist/index.js

@@ -0,0 +1,869 @@
+import { WORLD_CHAIN_MAINNET, USDC_CONTRACT_ADDRESS_WORLD_MAINNET, getWorldChainMainnetWithRPC } from '@atxp/client';
+import { ConsoleLogger, constructEIP1271Message, createEIP1271AuthData, createEIP1271JWT, JsonCache, BrowserCache } from '@atxp/common';
+export { BrowserCache, MemoryCache } from '@atxp/common';
+import { createWalletClient, custom, encodeFunctionData, parseEther, createPublicClient, http, parseUnits } from 'viem';
+import { privateKeyToAccount, generatePrivateKey } from 'viem/accounts';
+import { toCoinbaseSmartAccount, createBundlerClient } from 'viem/account-abstraction';
+
+/*
+This shim replaces spend permission functionality with ERC20 approvals for World Chain.
+This approach will work with any World Chain wallet/connector that supports ERC20 approvals.
+
+The implementation is based on the Base shim but adapted for World Chain networks.
+*/
+// Minimal ERC20 ABI for approve and transferFrom functions
+const ERC20_ABI$2 = [
+    {
+        "constant": false,
+        "inputs": [
+            {
+                "name": "_spender",
+                "type": "address"
+            },
+            {
+                "name": "_value",
+                "type": "uint256"
+            }
+        ],
+        "name": "approve",
+        "outputs": [
+            {
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "constant": false,
+        "inputs": [
+            {
+                "name": "_from",
+                "type": "address"
+            },
+            {
+                "name": "_to",
+                "type": "address"
+            },
+            {
+                "name": "_value",
+                "type": "uint256"
+            }
+        ],
+        "name": "transferFrom",
+        "outputs": [
+            {
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "nonpayable",
+        "type": "function"
+    }
+];
+async function requestSpendPermission(params) {
+    // Support World Chain mainnet only
+    if (params.chainId !== WORLD_CHAIN_MAINNET.id) {
+        throw new Error(`Chain ID ${params.chainId} is not supported. Only World Chain mainnet (${WORLD_CHAIN_MAINNET.id}) is supported.`);
+    }
+    // Use World Chain mainnet config
+    const chainConfig = WORLD_CHAIN_MAINNET;
+    const client = createWalletClient({
+        chain: chainConfig,
+        transport: custom(params.provider)
+    });
+    // Send ERC20 approve transaction
+    const hash = await client.sendTransaction({
+        account: params.account,
+        to: params.token,
+        data: encodeFunctionData({
+            abi: ERC20_ABI$2,
+            functionName: "approve",
+            args: [params.spender, params.allowance]
+        })
+    });
+    return {
+        permission: {
+            account: params.account,
+            spender: params.spender,
+            token: params.token,
+            allowance: params.allowance.toString(),
+            period: params.periodInDays * 24 * 60 * 60,
+            start: Math.floor(Date.now() / 1000),
+            end: Math.floor(Date.now() / 1000) + params.periodInDays * 24 * 60 * 60,
+            salt: '0x0',
+            extraData: '0x0'
+        },
+        signature: hash
+    };
+}
+async function prepareSpendCallData(params) {
+    // Creates transferFrom call data to move tokens from user wallet to ephemeral wallet
+    return [
+        {
+            to: params.permission.permission.token,
+            data: encodeFunctionData({
+                abi: ERC20_ABI$2,
+                functionName: 'transferFrom',
+                args: [
+                    params.permission.permission.account,
+                    params.permission.permission.spender,
+                    params.amount
+                ]
+            }),
+            value: BigInt(0)
+        }
+    ];
+}
+
+const USDC_DECIMALS$1 = 6;
+// Minimal ERC20 ABI for transfer function
+const ERC20_ABI$1 = [
+    {
+        inputs: [
+            { name: 'to', type: 'address' },
+            { name: 'amount', type: 'uint256' }
+        ],
+        name: 'transfer',
+        outputs: [{ name: '', type: 'bool' }],
+        stateMutability: 'nonpayable',
+        type: 'function'
+    }
+];
+/**
+ * Validates confirmation delays configuration
+ */
+function validateConfirmationDelays(delays) {
+    if (delays.networkPropagationMs < 0) {
+        throw new Error('networkPropagationMs must be non-negative');
+    }
+    if (delays.confirmationFailedMs < 0) {
+        throw new Error('confirmationFailedMs must be non-negative');
+    }
+}
+const DEFAULT_CONFIRMATION_DELAYS = {
+    networkPropagationMs: 5000, // 5 seconds for production
+    confirmationFailedMs: 15000 // 15 seconds for production
+};
+/**
+ * Gets default confirmation delays based on environment
+ */
+const getDefaultConfirmationDelays = () => {
+    if (process.env.NODE_ENV === 'test') {
+        return { networkPropagationMs: 10, confirmationFailedMs: 20 };
+    }
+    return DEFAULT_CONFIRMATION_DELAYS;
+};
+async function waitForTransactionConfirmations(smartWallet, txHash, confirmations, logger, delays = DEFAULT_CONFIRMATION_DELAYS) {
+    try {
+        const publicClient = smartWallet.client.account?.client;
+        if (publicClient && 'waitForTransactionReceipt' in publicClient) {
+            logger.info(`Waiting for ${confirmations} confirmations...`);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            await publicClient.waitForTransactionReceipt({
+                hash: txHash,
+                confirmations: 1, // Reduce confirmations to speed up
+                timeout: 60000 // 60 second timeout
+            });
+            logger.info(`Transaction confirmed with 1 confirmation`);
+            // Add extra delay for network propagation
+            logger.info(`Adding ${delays.networkPropagationMs}ms delay for network propagation...`);
+            await new Promise(resolve => setTimeout(resolve, delays.networkPropagationMs));
+        }
+        else {
+            logger.warn('Unable to wait for confirmations: client does not support waitForTransactionReceipt');
+        }
+    }
+    catch (error) {
+        logger.warn(`Could not wait for additional confirmations: ${error}`);
+        // Add longer delay if confirmation failed
+        logger.info(`Confirmation failed, adding ${delays.confirmationFailedMs}ms delay for transaction to propagate...`);
+        await new Promise(resolve => setTimeout(resolve, delays.confirmationFailedMs));
+    }
+}
+/**
+ * Payment maker for World Chain transactions using smart wallets and spend permissions
+ *
+ * @example
+ * ```typescript
+ * // For production use (default delays)
+ * const paymentMaker = new WorldchainPaymentMaker(permission, wallet);
+ *
+ * // For testing (fast delays)
+ * const paymentMaker = new WorldchainPaymentMaker(permission, wallet, {
+ *   confirmationDelays: { networkPropagationMs: 10, confirmationFailedMs: 20 }
+ * });
+ *
+ * // With custom configuration
+ * const paymentMaker = new WorldchainPaymentMaker(permission, wallet, {
+ *   chainId: 480, // World Chain Mainnet
+ *   customRpcUrl: 'https://my-rpc.com',
+ *   logger: myLogger
+ * });
+ * ```
+ */
+class WorldchainPaymentMaker {
+    /**
+     * Creates a new WorldchainPaymentMaker instance
+     *
+     * @param spendPermission - The spend permission for transactions
+     * @param smartWallet - The smart wallet instance to use
+     * @param options - Optional configuration
+     */
+    constructor(spendPermission, smartWallet, options = {}) {
+        if (!spendPermission) {
+            throw new Error('Spend permission is required');
+        }
+        if (!smartWallet) {
+            throw new Error('Smart wallet is required');
+        }
+        // Extract and validate options
+        const { logger, chainId = WORLD_CHAIN_MAINNET.id, customRpcUrl, confirmationDelays } = options;
+        const finalDelays = confirmationDelays ?? getDefaultConfirmationDelays();
+        validateConfirmationDelays(finalDelays);
+        this.logger = logger ?? new ConsoleLogger();
+        this.spendPermission = spendPermission;
+        this.smartWallet = smartWallet;
+        this.chainId = chainId;
+        this.customRpcUrl = customRpcUrl;
+        this.confirmationDelays = finalDelays;
+    }
+    async generateJWT({ paymentRequestId, codeChallenge }) {
+        // Generate EIP-1271 auth data for smart wallet authentication
+        const timestamp = Math.floor(Date.now() / 1000);
+        const message = constructEIP1271Message({
+            walletAddress: this.smartWallet.account.address,
+            timestamp,
+            codeChallenge,
+            paymentRequestId
+        });
+        // Sign the message - this will return an ABI-encoded signature from the smart wallet
+        const signature = await this.smartWallet.account.signMessage({
+            message: message
+        });
+        const authData = createEIP1271AuthData({
+            walletAddress: this.smartWallet.account.address,
+            message,
+            signature,
+            timestamp,
+            codeChallenge,
+            paymentRequestId
+        });
+        return createEIP1271JWT(authData);
+    }
+    async makePayment(amount, currency, receiver, memo) {
+        if (currency !== 'USDC') {
+            throw new Error('Only usdc currency is supported; received ' + currency);
+        }
+        // Use World Chain Mainnet configuration
+        const usdcAddress = USDC_CONTRACT_ADDRESS_WORLD_MAINNET;
+        // Convert amount to USDC units (6 decimals) as BigInt for spendPermission
+        const amountInUSDCUnits = BigInt(amount.multipliedBy(10 ** USDC_DECIMALS$1).toFixed(0));
+        const spendCalls = await prepareSpendCallData({ permission: this.spendPermission, amount: amountInUSDCUnits });
+        // Add a second call to transfer USDC from the smart wallet to the receiver
+        let transferCallData = encodeFunctionData({
+            abi: ERC20_ABI$1,
+            functionName: "transfer",
+            args: [receiver, amountInUSDCUnits],
+        });
+        // Append memo to transfer call data if present
+        // This works because the EVM ignores extra calldata beyond what a function expects.
+        // The ERC20 transfer() function only reads the first 68 bytes (4-byte selector + 32-byte address + 32-byte amount).
+        // Any additional data appended after those 68 bytes is safely ignored by the USDC contract
+        // but remains accessible in the transaction data for payment verification.
+        // This is a well-established pattern used by OpenSea, Uniswap, and other major protocols.
+        if (memo && memo.trim()) {
+            const memoHex = Buffer.from(memo.trim(), 'utf8').toString('hex');
+            transferCallData = (transferCallData + memoHex);
+            this.logger.info(`Added memo "${memo.trim()}" to transfer call`);
+        }
+        const transferCall = {
+            to: usdcAddress,
+            data: transferCallData,
+            value: '0x0'
+        };
+        // Combine spend permission calls with the transfer call
+        const allCalls = [...spendCalls, transferCall];
+        this.logger.info(`Executing ${allCalls.length} calls (${spendCalls.length} spend permission + 1 transfer)`);
+        const hash = await this.smartWallet.client.sendUserOperation({
+            account: this.smartWallet.account,
+            calls: allCalls.map(call => {
+                return {
+                    to: call.to,
+                    data: call.data,
+                    value: BigInt(call.value || '0x0')
+                };
+            }),
+            maxPriorityFeePerGas: parseEther('0.000000001')
+        });
+        const receipt = await this.smartWallet.client.waitForUserOperationReceipt({ hash });
+        if (!receipt) {
+            throw new Error('User operation failed');
+        }
+        // The receipt contains the actual transaction hash that was mined on chain
+        const txHash = receipt.receipt.transactionHash;
+        if (!txHash) {
+            throw new Error('User operation was executed but no transaction hash was returned. This should not happen.');
+        }
+        this.logger.info(`Spend permission executed successfully. UserOp: ${receipt.userOpHash}, TxHash: ${txHash}`);
+        // Wait for additional confirmations to ensure the transaction is well-propagated
+        // This helps avoid the "Transaction receipt could not be found" error
+        await waitForTransactionConfirmations(this.smartWallet, txHash, 2, this.logger, this.confirmationDelays);
+        // Return the actual transaction hash, not the user operation hash
+        // The payment verification system needs the on-chain transaction hash
+        return txHash;
+    }
+}
+
+const USDC_DECIMALS = 6;
+// Minimal ERC20 ABI for transfer function
+const ERC20_ABI = [
+    {
+        inputs: [
+            { name: 'to', type: 'address' },
+            { name: 'amount', type: 'uint256' }
+        ],
+        name: 'transfer',
+        outputs: [{ name: '', type: 'bool' }],
+        stateMutability: 'nonpayable',
+        type: 'function'
+    }
+];
+class MainWalletPaymentMaker {
+    constructor(walletAddress, provider, logger, chainId = WORLD_CHAIN_MAINNET.id, customRpcUrl) {
+        this.walletAddress = walletAddress;
+        this.provider = provider;
+        this.logger = logger ?? new ConsoleLogger();
+        this.chainId = chainId;
+        this.customRpcUrl = customRpcUrl;
+    }
+    async generateJWT({ paymentRequestId, codeChallenge }) {
+        const timestamp = Math.floor(Date.now() / 1000);
+        // Create proper JWT header and payload for ES256K
+        const header = {
+            alg: 'ES256K',
+            typ: 'JWT'
+        };
+        const payload = {
+            sub: this.walletAddress,
+            iss: 'accounts.atxp.ai',
+            aud: 'https://auth.atxp.ai',
+            iat: timestamp,
+            exp: timestamp + 3600, // 1 hour expiration
+            payment_request_id: paymentRequestId,
+            code_challenge: codeChallenge,
+            chain_id: this.chainId
+        };
+        // Encode header and payload to base64url
+        const encodedHeader = Buffer.from(JSON.stringify(header)).toString('base64url');
+        const encodedPayload = Buffer.from(JSON.stringify(payload)).toString('base64url');
+        // Create the message that ES256K should actually sign (header.payload)
+        const messageToSign = `${encodedHeader}.${encodedPayload}`;
+        // Sign the actual JWT header.payload string using personal_sign
+        const signature = await this.provider.request({
+            method: 'personal_sign',
+            params: [messageToSign, this.walletAddress]
+        });
+        // Use the legacy format (base64url of hex string with 0x prefix)
+        // This matches what the ES256K verification expects
+        const encodedSignature = Buffer.from(signature).toString('base64url');
+        const jwt = `${encodedHeader}.${encodedPayload}.${encodedSignature}`;
+        this.logger.info(`Generated ES256K JWT for main wallet: ${this.walletAddress}`);
+        return jwt;
+    }
+    async makePayment(amount, currency, receiver, memo) {
+        if (currency !== 'USDC') {
+            throw new Error('Only USDC currency is supported; received ' + currency);
+        }
+        // Use World Chain Mainnet configuration
+        const usdcAddress = USDC_CONTRACT_ADDRESS_WORLD_MAINNET;
+        const chainConfig = this.customRpcUrl
+            ? getWorldChainMainnetWithRPC(this.customRpcUrl)
+            : WORLD_CHAIN_MAINNET;
+        const chainName = chainConfig.name;
+        this.logger.info(`Making direct wallet payment of ${amount} ${currency} to ${receiver} on ${chainName} with memo: ${memo}`);
+        // Convert amount to USDC units (6 decimals)
+        const amountInUSDCUnits = BigInt(amount.multipliedBy(10 ** USDC_DECIMALS).toFixed(0));
+        // Prepare transfer call data
+        let transferCallData = encodeFunctionData({
+            abi: ERC20_ABI,
+            functionName: 'transfer',
+            args: [receiver, amountInUSDCUnits]
+        });
+        // Append memo to call data if present
+        if (memo && memo.trim()) {
+            const memoHex = Buffer.from(memo.trim(), 'utf8').toString('hex');
+            transferCallData = (transferCallData + memoHex);
+            this.logger.info(`Added memo "${memo.trim()}" to transfer call`);
+        }
+        // Create wallet client
+        const walletClient = createWalletClient({
+            chain: chainConfig,
+            transport: custom(this.provider)
+        });
+        // Send transaction directly from main wallet
+        const txHash = await walletClient.sendTransaction({
+            account: this.walletAddress,
+            to: usdcAddress,
+            data: transferCallData,
+            value: 0n,
+            chain: chainConfig
+        });
+        this.logger.info(`Payment sent successfully. TxHash: ${txHash}`);
+        this.logger.info(`Transaction URL: https://worldscan.org/tx/${txHash}`);
+        // Wait for transaction confirmation to ensure it's mined
+        // This prevents "Transaction receipt could not be found" errors
+        try {
+            this.logger.info(`Waiting for transaction confirmation...`);
+            // Create a public client to wait for the transaction receipt
+            // Use custom RPC URL if provided for better consistency with auth server
+            const rpcUrl = this.customRpcUrl || chainConfig.rpcUrls.default.http[0];
+            const publicClient = createPublicClient({
+                chain: chainConfig,
+                transport: http(rpcUrl, {
+                    timeout: 30000, // 30 second timeout for individual RPC calls
+                    retryCount: 3, // Retry failed requests
+                    retryDelay: 1000 // 1 second delay between retries
+                })
+            });
+            await publicClient.waitForTransactionReceipt({
+                hash: txHash,
+                confirmations: 1, // Reduce to 1 confirmation to speed up
+                timeout: 120000 // 2 minute timeout - World Chain can be slow
+            });
+            this.logger.info(`Transaction confirmed with 1 confirmation`);
+            // Add extra delay to ensure the transaction is well propagated across network
+            await new Promise(resolve => setTimeout(resolve, 5000));
+        }
+        catch (error) {
+            this.logger.warn(`Could not wait for confirmations: ${error}`);
+            // Add a much longer delay if confirmation failed - World Chain can be slow
+            this.logger.info('Confirmation failed, adding delay for transaction to propagate...');
+            await new Promise(resolve => setTimeout(resolve, 30000));
+        }
+        return txHash;
+    }
+}
+
+/**
+ * Type-safe cache wrapper for permission data
+ */
+class IntermediaryCache extends JsonCache {
+}
+
+// For now, we'll use a generic approach for World Chain
+// This may need to be updated when World Chain provides specific infrastructure
+const DEFAULT_WORLD_CHAIN_RPC = 'https://worldchain-mainnet.g.alchemy.com/public';
+/**
+ * Creates an ephemeral smart wallet for World Chain
+ * Note: This implementation uses Coinbase's smart wallet infrastructure
+ * adapted for World Chain. This may need updates when World Chain
+ * provides their own account abstraction infrastructure.
+ */
+async function toEphemeralSmartWallet(privateKey, rpcUrl) {
+    const signer = privateKeyToAccount(privateKey);
+    const publicClient = createPublicClient({
+        chain: WORLD_CHAIN_MAINNET,
+        transport: http(DEFAULT_WORLD_CHAIN_RPC)
+    });
+    // Create the smart wallet using Coinbase's smart account SDK
+    // This will need to be adapted when World Chain provides their own solution
+    const account = await toCoinbaseSmartAccount({
+        client: publicClient,
+        owners: [signer],
+        version: '1'
+    });
+    // Create bundler client
+    // Note: World Chain may not have paymaster support initially
+    const bundlerClient = createBundlerClient({
+        account,
+        client: publicClient,
+        transport: http(DEFAULT_WORLD_CHAIN_RPC),
+        chain: WORLD_CHAIN_MAINNET
+        // Paymaster omitted - World Chain infrastructure may not support it yet
+    });
+    return {
+        address: account.address,
+        client: bundlerClient,
+        account,
+        signer,
+    };
+}
+
+const DEFAULT_ALLOWANCE = 10n;
+const DEFAULT_PERIOD_IN_DAYS = 7;
+class WorldchainAccount {
+    static toCacheKey(userWalletAddress) {
+        return `atxp-world-permission-${userWalletAddress}`;
+    }
+    static async initialize(config) {
+        const logger = config.logger || new ConsoleLogger();
+        const useEphemeralWallet = config.useEphemeralWallet ?? true;
+        const chainId = config.chainId || WORLD_CHAIN_MAINNET.id;
+        // Use World Chain Mainnet USDC address
+        const usdcAddress = USDC_CONTRACT_ADDRESS_WORLD_MAINNET;
+        // Some wallets don't support wallet_connect, so
+        // will just continue if it fails
+        try {
+            await config.provider.request({ method: 'wallet_connect' });
+        }
+        catch (error) {
+            logger.warn(`wallet_connect not supported, continuing with initialization. ${error}`);
+        }
+        // If using main wallet mode, return early with main wallet payment maker
+        if (!useEphemeralWallet) {
+            logger.info(`Using main wallet mode for address: ${config.walletAddress}`);
+            return new WorldchainAccount(null, // No spend permission in main wallet mode
+            null, // No ephemeral wallet in main wallet mode
+            logger, config.walletAddress, config.provider, chainId, config.customRpcUrl);
+        }
+        // Initialize cache
+        const baseCache = config?.cache || new BrowserCache();
+        const cache = new IntermediaryCache(baseCache);
+        const cacheKey = this.toCacheKey(config.walletAddress);
+        // Try to load existing permission
+        const existingData = this.loadSavedWalletAndPermission(cache, cacheKey);
+        if (existingData) {
+            const ephemeralSmartWallet = await toEphemeralSmartWallet(existingData.privateKey);
+            return new WorldchainAccount(existingData.permission, ephemeralSmartWallet, logger, undefined, undefined, chainId, config.customRpcUrl);
+        }
+        const privateKey = generatePrivateKey();
+        const smartWallet = await toEphemeralSmartWallet(privateKey);
+        logger.info(`Generated ephemeral wallet: ${smartWallet.address}`);
+        await this.deploySmartWallet(smartWallet);
+        logger.info(`Deployed smart wallet: ${smartWallet.address}`);
+        const permission = await requestSpendPermission({
+            account: config.walletAddress,
+            spender: smartWallet.address,
+            token: usdcAddress,
+            chainId: chainId,
+            allowance: config?.allowance ?? DEFAULT_ALLOWANCE,
+            periodInDays: config?.periodInDays ?? DEFAULT_PERIOD_IN_DAYS,
+            provider: config.provider,
+        });
+        // Save wallet and permission
+        cache.set(cacheKey, { privateKey, permission });
+        return new WorldchainAccount(permission, smartWallet, logger, undefined, undefined, chainId, config.customRpcUrl);
+    }
+    static loadSavedWalletAndPermission(permissionCache, cacheKey) {
+        const cachedData = permissionCache.get(cacheKey);
+        if (!cachedData)
+            return null;
+        // Check if permission is not expired
+        const now = Math.floor(Date.now() / 1000);
+        const permissionEnd = parseInt(cachedData.permission.permission.end.toString());
+        if (permissionEnd <= now) {
+            permissionCache.delete(cacheKey);
+            return null;
+        }
+        return cachedData;
+    }
+    static async deploySmartWallet(smartWallet) {
+        const deployTx = await smartWallet.client.sendUserOperation({
+            calls: [{
+                    to: smartWallet.address,
+                    value: 0n,
+                    data: '0x'
+                }]
+            // Note: World Chain may not have paymaster support initially
+            // paymaster omitted
+        });
+        const receipt = await smartWallet.client.waitForUserOperationReceipt({
+            hash: deployTx
+        });
+        if (!receipt.success) {
+            throw new Error(`Smart wallet deployment failed. Receipt: ${JSON.stringify(receipt)}`);
+        }
+    }
+    constructor(spendPermission, ephemeralSmartWallet, logger, mainWalletAddress, provider, chainId = WORLD_CHAIN_MAINNET.id, customRpcUrl) {
+        if (ephemeralSmartWallet) {
+            // Ephemeral wallet mode
+            if (!spendPermission) {
+                throw new Error('Spend permission is required for ephemeral wallet mode');
+            }
+            this.accountId = ephemeralSmartWallet.address;
+            this.paymentMakers = {
+                'world': new WorldchainPaymentMaker(spendPermission, ephemeralSmartWallet, {
+                    logger,
+                    chainId,
+                    customRpcUrl
+                }),
+            };
+        }
+        else {
+            // Main wallet mode
+            if (!mainWalletAddress || !provider) {
+                throw new Error('Main wallet address and provider are required for main wallet mode');
+            }
+            this.accountId = mainWalletAddress;
+            this.paymentMakers = {
+                'world': new MainWalletPaymentMaker(mainWalletAddress, provider, logger, chainId, customRpcUrl),
+            };
+        }
+    }
+    static clearAllCachedData(userWalletAddress, cache) {
+        // In non-browser environments, require an explicit cache parameter
+        if (!cache) {
+            const browserCache = new BrowserCache();
+            // Check if BrowserCache would work (i.e., we're in a browser)
+            if (typeof window === 'undefined') {
+                throw new Error('clearAllCachedData requires a cache to be provided outside of browser environments');
+            }
+            cache = browserCache;
+        }
+        cache.delete(this.toCacheKey(userWalletAddress));
+    }
+}
+
+/**
+ * Loads and initializes a Worldchain account with MiniKit integration
+ *
+ * This function creates a Worldchain account that can interact with the World Chain network
+ * using MiniKit for transaction signing and wallet operations. It sets up a custom provider
+ * that handles various Ethereum JSON-RPC methods through MiniKit's interface.
+ *
+ * @param walletAddress - The wallet address to use for the account
+ * @param logger - Optional logger instance for debugging and monitoring
+ * @param customRpcUrl - Optional custom RPC URL for Worldchain. If not provided, uses the public RPC endpoint
+ * @param miniKit - The MiniKit instance to use for transactions and signing
+ * @returns Promise that resolves to an initialized WorldchainAccount instance
+ *
+ * @example
+ * ```typescript
+ * // Using public RPC endpoint
+ * const account = await createMiniKitWorldchainAccount({
+ *   walletAddress: "0x1234...",
+ *   logger: new ConsoleLogger(),
+ *   miniKit: MiniKit
+ * });
+ *
+ * // Using custom RPC endpoint
+ * const account = await createMiniKitWorldchainAccount({
+ *   walletAddress: "0x1234...",
+ *   logger: new ConsoleLogger(),
+ *   customRpcUrl: "https://your-custom-rpc-endpoint.com",
+ *   miniKit: MiniKit
+ * });
+ * ```
+ *
+ * @remarks
+ * The function creates a custom provider that supports:
+ * - `eth_accounts`: Returns the wallet address
+ * - `eth_chainId`: Returns Worldchain chain ID (0x1e0 / 480)
+ * - `eth_requestAccounts`: Returns the wallet address
+ * - `eth_sendTransaction`: Handles USDC transfers and other transactions via MiniKit
+ * - `personal_sign`: Signs messages using MiniKit
+ *
+ * The account is configured with:
+ * - 10 USDC allowance
+ * - 30-day period for permissions
+ * - Worldchain mainnet RPC endpoint (public or custom)
+ * - Regular wallet mode (no ephemeral wallet)
+ *
+ * @throws {Error} When MiniKit operations fail or unsupported transaction types are encountered
+ */
+const createMiniKitWorldchainAccount = async ({ walletAddress, logger: loggerParam, customRpcUrl, miniKit }) => {
+    const logger = loggerParam || new ConsoleLogger();
+    // If no connector client from wagmi, create a simple MiniKit provider
+    const provider = {
+        request: async (args) => {
+            const { method, params } = args;
+            switch (method) {
+                case 'eth_accounts':
+                    return [walletAddress];
+                case 'eth_chainId':
+                    return '0x1e0'; // Worldchain chain ID (480)
+                case 'eth_requestAccounts':
+                    return [walletAddress];
+                case 'eth_sendTransaction':
+                    return await handleSendTransaction(params, logger, miniKit);
+                case 'personal_sign':
+                    return await signMessageWithMiniKit(params, miniKit);
+                default:
+                    throw new Error(`Method ${method} not supported in MiniKit context`);
+            }
+        },
+    };
+    const worldchainAccount = await WorldchainAccount.initialize({
+        walletAddress,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        provider: provider, // Type cast needed for client compatibility
+        allowance: parseUnits("10", 6), // 10 USDC
+        useEphemeralWallet: false, // Regular wallet mode (smart wallet infrastructure not available on World Chain)
+        periodInDays: 30,
+        customRpcUrl: customRpcUrl || DEFAULT_WORLD_CHAIN_RPC // Public RPC URL as default
+    });
+    return worldchainAccount;
+};
+/**
+ * Handles eth_sendTransaction requests by processing different transaction types
+ * @param params Array containing the transaction object
+ * @param logger Logger instance for debugging
+ * @returns Transaction hash or throws error
+ */
+async function handleSendTransaction(params, logger, miniKit) {
+    const transaction = params[0];
+    // Handle USDC transfer (ERC20 transfer function)
+    if (transaction.data && transaction.data.startsWith('0xa9059cbb')) {
+        // This is a transfer(address,uint256) call - decode the parameters
+        const data = transaction.data.slice(10); // Remove function selector
+        // Extract recipient address (first 32 bytes, last 20 bytes are the address)
+        const recipientHex = '0x' + data.slice(24, 64);
+        // Extract amount (next 32 bytes)
+        const amountHex = '0x' + data.slice(64, 128);
+        const amount = BigInt(amountHex).toString();
+        // Validate transaction parameter
+        // Check for memo data (any data after the standard 128 characters)
+        let memo = '';
+        if (data.length > 128) {
+            const memoHex = data.slice(128);
+            try {
+                memo = Buffer.from(memoHex, 'hex').toString('utf8');
+            }
+            catch (e) {
+                logger.warn(`[MiniKit] Failed to decode memo data: ${e}`);
+            }
+        }
+        // ERC20 ABI for transfer function
+        const ERC20_ABI = [
+            {
+                inputs: [
+                    { name: 'to', type: 'address' },
+                    { name: 'amount', type: 'uint256' }
+                ],
+                name: 'transfer',
+                outputs: [{ name: '', type: 'bool' }],
+                stateMutability: 'nonpayable',
+                type: 'function'
+            }
+        ];
+        const input = {
+            transaction: [
+                {
+                    address: transaction.to, // USDC contract address
+                    abi: ERC20_ABI,
+                    functionName: 'transfer',
+                    args: [recipientHex, amount],
+                    value: transaction.value || "0"
+                }
+            ]
+        };
+        // TODO: MiniKit doesn't have a standard way to include memo data in ERC20 transfers
+        // The memo is extracted and logged but not included in the transaction
+        if (memo) {
+            logger.debug(`[MiniKit] Memo "${memo}" will be lost in MiniKit transaction - consider alternative approach`);
+        }
+        const sentResult = await miniKit.commandsAsync.sendTransaction(input);
+        if (sentResult.finalPayload?.status === 'success') {
+            const transactionId = sentResult.finalPayload.transaction_id;
+            // Wait for the transaction to be confirmed and get the actual transaction hash
+            const confirmed = await waitForTransactionConfirmation(transactionId, logger, 120000); // 2 minute timeout
+            if (confirmed && confirmed.transactionHash) {
+                logger.debug(`[MiniKit] Transaction confirmed with hash: ${confirmed.transactionHash}`);
+                return confirmed.transactionHash; // Return the actual blockchain transaction hash
+            }
+            else {
+                logger.error(`[MiniKit] Transaction confirmation failed for ID: ${transactionId}`);
+                throw new Error(`Transaction confirmation failed. Transaction may still be pending.`);
+            }
+        }
+        // Enhanced error logging for debugging
+        const errorCode = sentResult.finalPayload?.error_code;
+        const simulationError = sentResult.finalPayload?.details?.simulationError;
+        logger.error(`[MiniKit] Transaction failed: ${JSON.stringify({
+            errorCode,
+            simulationError,
+            fullPayload: sentResult.finalPayload
+        })}`);
+        // Provide more user-friendly error messages
+        let userFriendlyError = `MiniKit sendTransaction failed: ${errorCode}`;
+        if (simulationError?.includes('transfer amount exceeds balance')) {
+            const amountUSDC = (Number(amount) / 1000000).toFixed(6);
+            userFriendlyError = `💳 Insufficient USDC Balance\n\n` +
+                `You're trying to send ${amountUSDC} USDC, but your wallet doesn't have enough funds.\n\n` +
+                `To complete this payment:\n` +
+                `• Add USDC to your World App wallet\n` +
+                `• Bridge USDC from another chain\n` +
+                `• Buy USDC directly in World App\n\n` +
+                `Wallet: ${transaction.from?.slice(0, 6)}...${transaction.from?.slice(-4)}`;
+        }
+        else if (simulationError) {
+            userFriendlyError += ` - ${simulationError}`;
+        }
+        throw new Error(userFriendlyError);
+    }
+    // Handle simple ETH transfers (no data or empty data)
+    if (!transaction.data || transaction.data === '0x') {
+        // For ETH transfers, you'd need to use the Forward contract
+        throw new Error('ETH transfers require Forward contract - not implemented yet');
+    }
+    // For other transaction types
+    throw new Error(`Unsupported transaction type. Data: ${transaction.data.slice(0, 10)}`);
+}
+/**
+ * Signs a message using MiniKit
+ * @param params Array containing the message to sign
+ * @returns The signature string
+ * @throws Error if signing fails
+ */
+async function signMessageWithMiniKit(params, miniKit) {
+    const [message] = params;
+    const signResult = await miniKit.commandsAsync.signMessage({ message: message });
+    if (signResult?.finalPayload?.status === 'success') {
+        return signResult.finalPayload.signature;
+    }
+    throw new Error(`MiniKit signing failed: ${signResult?.finalPayload?.error_code}`);
+}
+/**
+ * Resolves a MiniKit transaction ID to the actual blockchain transaction hash
+ * using the World API
+ */
+async function resolveTransactionHash(transactionId, logger) {
+    try {
+        const response = await fetch('/api/resolve-transaction', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ transactionId })
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            logger.error(`[WorldTransaction] API error: ${response.status} ${error}`);
+            return null;
+        }
+        const transaction = await response.json();
+        return {
+            transactionHash: transaction.transactionHash,
+            status: transaction.transactionStatus
+        };
+    }
+    catch (error) {
+        logger.error(`[WorldTransaction] Error resolving transaction: ${error}`);
+        return null;
+    }
+}
+/**
+ * Waits for a MiniKit transaction to be confirmed and returns the transaction hash
+ * Polls the World API until the transaction is confirmed or times out
+ */
+async function waitForTransactionConfirmation(transactionId, logger, timeoutMs = 120000, // 2 minutes
+pollIntervalMs = 2000) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+        const result = await resolveTransactionHash(transactionId, logger);
+        if (result && result.transactionHash && result.status !== 'pending') {
+            return result;
+        }
+        // Wait before next poll
+        await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
+    }
+    logger.warn(`[WorldTransaction] Timeout waiting for transaction confirmation: ${transactionId}`);
+    return null;
+}
+
+export { MainWalletPaymentMaker, IntermediaryCache as PermissionCache, WorldchainAccount, WorldchainPaymentMaker, createMiniKitWorldchainAccount };
+//# sourceMappingURL=index.js.map