@dynamic-labs-wallet/node-evm 1.0.50 → 1.0.52

package/index.cjs

@@ -5,6 +5,7 @@ var node = require('@dynamic-labs-wallet/node');
 var viem = require('viem');
 var utils = require('viem/utils');
 var chains = require('viem/chains');
+var node_crypto = require('node:crypto');
 var client = require('@dynamic-labs-sdk/client');
 var core = require('@dynamic-labs-sdk/client/core');
 var viem$1 = require('@dynamic-labs-sdk/evm/viem');
@@ -95,7 +96,7 @@ const deriveAccountAddress = ({ rawPublicKey })=>{
     };
 };
 
-const logError$1 = node.createLogError('node-evm');
+const logError$2 = node.createLogError('node-evm');
 /**
  * Creates a delegated EVM wallet client for functional operations
  */ const createDelegatedEvmWalletClient = ({ environmentId, baseApiUrl, baseMPCRelayApiUrl, apiKey, debug = false })=>{
@@ -134,7 +135,7 @@ const logError$1 = node.createLogError('node-evm');
         });
         return serializeECDSASignature(signatureEcdsa);
     } catch (error) {
-        logError$1({
+        logError$2({
             message: 'Error in delegatedSignMessage',
             error: error,
             context: {
@@ -180,7 +181,7 @@ const logError$1 = node.createLogError('node-evm');
         });
         return viem.serializeTransaction(signedTx);
     } catch (error) {
-        logError$1({
+        logError$2({
             message: 'Error in delegatedSignTransaction',
             error: error,
             context: {
@@ -213,7 +214,7 @@ const logError$1 = node.createLogError('node-evm');
         });
         return serializeECDSASignature(signatureEcdsa);
     } catch (error) {
-        logError$1({
+        logError$2({
             message: 'Error in delegatedSignTypedData',
             error: error,
             context: {
@@ -248,7 +249,7 @@ const logError$1 = node.createLogError('node-evm');
         const serializedSignature = serializeECDSASignature(signatureEcdsa);
         return viem.parseSignature(serializedSignature);
     } catch (error) {
-        logError$1({
+        logError$2({
             message: 'Error in delegatedSignAuthorization',
             error: error,
             context: {
@@ -281,7 +282,7 @@ const logError$1 = node.createLogError('node-evm');
         });
         return serializeECDSASignature(signatureEcdsa);
     } catch (error) {
-        logError$1({
+        logError$2({
             message: 'Error in delegatedSignRawMessage',
             error: error,
             context: {
@@ -397,6 +398,409 @@ const createAccountAdapter = ({ evmClient, walletMetadata, password, externalSer
     });
 };
 
+/** The Fireblocks Universal Gasless Delegate (UGD) contract address used for EIP-7702 delegation. */ const DELEGATION_CONTRACT_ADDRESS = '0x0000Fb7702036ff9f76044a501ac1aA74cbab16b';
+/** Default sponsored transaction validity duration in seconds (10 minutes). */ const DEFAULT_VALID_FOR_SECONDS = 600;
+/** EIP-7702 delegation code prefix used to identify delegated accounts. */ const DELEGATION_CODE_PREFIX = '0xef0100';
+/** ERC-7579 batch call with opData and auth mode identifier. */ const BATCH_CALL_OPDATA_AUTH_MODE = '0x0100000000007821000100000000000000000000000000000000000000000000';
+/** EIP-712 typed data types for UGD AuthorizedExecutions signing. */ const AUTHORIZED_EXECUTIONS_TYPES = {
+    AuthorizedExecutions: [
+        {
+            name: 'calls',
+            type: 'Execution[]'
+        },
+        {
+            name: 'deadline',
+            type: 'uint256'
+        },
+        {
+            name: 'mode',
+            type: 'bytes32'
+        },
+        {
+            name: 'nonce',
+            type: 'uint256'
+        },
+        {
+            name: 'relayer',
+            type: 'address'
+        }
+    ],
+    Execution: [
+        {
+            name: 'target',
+            type: 'address'
+        },
+        {
+            name: 'value',
+            type: 'uint256'
+        },
+        {
+            name: 'data',
+            type: 'bytes'
+        }
+    ]
+};
+/** Minimal ABI for the UGD contract's nonce validation function. */ const UGD_ABI = [
+    {
+        inputs: [
+            {
+                name: 'nonce',
+                type: 'uint256'
+            }
+        ],
+        name: 'isNonceUsed',
+        outputs: [
+            {
+                name: '',
+                type: 'bool'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    }
+];
+/** Default polling interval for sponsored transaction status checks (milliseconds). */ const EVM_GASLESS_DEFAULT_POLL_INTERVAL_MS = 2000;
+/** Default timeout for sponsored transaction polling (milliseconds). */ const EVM_GASLESS_DEFAULT_TIMEOUT_MS = 60000;
+// Error messages
+const ERROR_GASLESS_RPC_REQUIRED_FOR_AUTO_DELEGATE = 'rpcUrl is required when autoDelegate is true and no explicit authorization is provided. ' + 'Pass rpcUrl, pass an explicit authorization, or set autoDelegate: false.';
+const ERROR_GASLESS_RELAY_FAILED = 'EVM sponsored transaction relay failed';
+const ERROR_GASLESS_TIMEOUT = 'EVM sponsored transaction timed out waiting for terminal status';
+const ERROR_GASLESS_MISSING_REQUEST_ID = 'Relay response did not include a requestId';
+const ERROR_GASLESS_MISSING_YPARITY = 'Signed authorization is missing yParity';
+const ERROR_GASLESS_RPC_REQUIRED = 'rpcUrl is required for this operation';
+
+const logError$1 = node.createLogError('node-evm');
+/**
+ * Builds a stateless gasless client for EVM sponsored transactions (Fireblocks-relayer
+ * native gasless via EIP-7702 / AuthorizedExecutions). It holds no wallet state — the
+ * signing primitives and API client are injected by the owning `DynamicEvmWalletClient`.
+ */ const createEvmGaslessClient = ({ apiClient, createViemPublicClient, signAuthorization, signTypedData })=>{
+    const viemPublicClientForChain = (chainId, rpcUrl)=>{
+        if (!rpcUrl) {
+            throw new Error(ERROR_GASLESS_RPC_REQUIRED);
+        }
+        const chain = viem.defineChain({
+            id: chainId,
+            name: `Chain ${chainId}`,
+            nativeCurrency: {
+                name: 'Ether',
+                symbol: 'ETH',
+                decimals: 18
+            },
+            rpcUrls: {
+                default: {
+                    http: [
+                        rpcUrl
+                    ]
+                }
+            }
+        });
+        return createViemPublicClient({
+            chain,
+            rpcUrl
+        });
+    };
+    const generateRandomNonce = ()=>BigInt('0x' + node_crypto.randomBytes(32).toString('hex'));
+    const generateIntentNonce = async ({ walletAddress, chainId, rpcUrl })=>{
+        let nonce = generateRandomNonce();
+        if (rpcUrl) {
+            try {
+                const publicClient = viemPublicClientForChain(chainId, rpcUrl);
+                // On a brand-new (undelegated) wallet the address has no UGD code yet,
+                // so isNonceUsed reverts — the random value is safe regardless.
+                const isUsed = await publicClient.readContract({
+                    address: walletAddress,
+                    abi: UGD_ABI,
+                    functionName: 'isNonceUsed',
+                    args: [
+                        nonce
+                    ]
+                });
+                if (isUsed) {
+                    nonce = generateRandomNonce();
+                }
+            } catch (e) {
+            // RPC failure is tolerable — 256-bit random collision is negligible
+            }
+        }
+        return nonce;
+    };
+    const is7702DelegationActive = async ({ walletAddress, chainId, rpcUrl })=>{
+        const publicClient = viemPublicClientForChain(chainId, rpcUrl);
+        const code = await publicClient.getCode({
+            address: walletAddress
+        });
+        if (!code) return false;
+        const expectedPrefix = DELEGATION_CODE_PREFIX + DELEGATION_CONTRACT_ADDRESS.slice(2).toLowerCase();
+        return code.toLowerCase().startsWith(expectedPrefix);
+    };
+    const sign7702Authorization = async ({ walletMetadata, chainId, rpcUrl, nonce, password, externalServerKeyShares })=>{
+        const address = walletMetadata.accountAddress;
+        try {
+            let eoaNonce;
+            if (nonce === undefined) {
+                if (!rpcUrl) {
+                    throw new Error(ERROR_GASLESS_RPC_REQUIRED);
+                }
+                const publicClient = viemPublicClientForChain(chainId, rpcUrl);
+                eoaNonce = Number(await publicClient.getTransactionCount({
+                    address
+                }));
+            } else {
+                eoaNonce = nonce;
+            }
+            const authorization = {
+                address: DELEGATION_CONTRACT_ADDRESS,
+                chainId,
+                nonce: eoaNonce
+            };
+            const sig = await signAuthorization({
+                authorization,
+                walletMetadata,
+                password,
+                externalServerKeyShares
+            });
+            if (sig.yParity === undefined) {
+                throw new Error(ERROR_GASLESS_MISSING_YPARITY);
+            }
+            return {
+                address: DELEGATION_CONTRACT_ADDRESS,
+                chainId,
+                nonce: eoaNonce,
+                r: sig.r,
+                s: sig.s,
+                yParity: sig.yParity
+            };
+        } catch (error) {
+            logError$1({
+                message: 'Error signing 7702 authorization',
+                error: error,
+                context: {
+                    accountAddress: address,
+                    chainId
+                }
+            });
+            throw error;
+        }
+    };
+    const getAvailableEvmGaslessRelayer = async ({ chainId, traceContext })=>{
+        const result = await apiClient.getAvailableEVMGaslessRelayer({
+            chainId,
+            traceContext
+        });
+        return {
+            relayerAddress: result.relayerAddress
+        };
+    };
+    const resolveSponsoredAuthorization = async ({ authorization, autoDelegate, walletMetadata, chainId, rpcUrl, password, externalServerKeyShares })=>{
+        if (authorization) {
+            return authorization;
+        }
+        if (!autoDelegate) {
+            return undefined;
+        }
+        // The EOA nonce and delegation status are only knowable on-chain; without
+        // an RPC we can't safely auto-sign a 7702 authorization, so fail loud
+        // instead of relaying an intent that would revert.
+        if (!rpcUrl) {
+            throw new Error(ERROR_GASLESS_RPC_REQUIRED_FOR_AUTO_DELEGATE);
+        }
+        const walletAddress = walletMetadata.accountAddress;
+        const isDelegated = await is7702DelegationActive({
+            walletAddress,
+            chainId,
+            rpcUrl
+        });
+        if (isDelegated) {
+            return undefined;
+        }
+        return sign7702Authorization({
+            walletMetadata,
+            chainId,
+            rpcUrl,
+            password,
+            externalServerKeyShares
+        });
+    };
+    const signSponsoredTransaction = async ({ walletMetadata, calls, chainId, rpcUrl, authorization, autoDelegate = true, nonce: providedNonce, validForSeconds = DEFAULT_VALID_FOR_SECONDS, password, externalServerKeyShares, traceContext })=>{
+        const walletAddress = walletMetadata.accountAddress;
+        try {
+            const resolvedAuth = await resolveSponsoredAuthorization({
+                authorization,
+                autoDelegate,
+                walletMetadata,
+                chainId,
+                rpcUrl,
+                password,
+                externalServerKeyShares
+            });
+            const nonce = providedNonce != null ? providedNonce : await generateIntentNonce({
+                walletAddress,
+                chainId,
+                rpcUrl
+            });
+            const deadline = BigInt(Math.floor(Date.now() / 1000) + validForSeconds);
+            const { relayerAddress } = await getAvailableEvmGaslessRelayer({
+                chainId,
+                traceContext
+            });
+            const signature = await signTypedData({
+                walletMetadata,
+                password,
+                externalServerKeyShares,
+                typedData: {
+                    domain: {
+                        chainId,
+                        verifyingContract: DELEGATION_CONTRACT_ADDRESS
+                    },
+                    message: {
+                        calls: calls.map((c)=>({
+                                data: c.data,
+                                target: c.target,
+                                value: c.value
+                            })),
+                        deadline,
+                        mode: BATCH_CALL_OPDATA_AUTH_MODE,
+                        nonce,
+                        relayer: relayerAddress
+                    },
+                    primaryType: 'AuthorizedExecutions',
+                    types: AUTHORIZED_EXECUTIONS_TYPES
+                }
+            });
+            return {
+                authorization: resolvedAuth,
+                calls,
+                chainId,
+                deadline: deadline.toString(),
+                nonce: nonce.toString(),
+                relayer: relayerAddress,
+                signature,
+                walletAddress
+            };
+        } catch (error) {
+            logError$1({
+                message: 'Error signing sponsored transaction',
+                error: error,
+                context: {
+                    accountAddress: walletAddress,
+                    chainId
+                }
+            });
+            throw error;
+        }
+    };
+    const getEVMSponsoredTransactionStatus = async ({ requestId, traceContext })=>{
+        const result = await apiClient.getEVMSponsoredTransactionStatus({
+            requestId,
+            traceContext
+        });
+        return result;
+    };
+    const isSignedTransactionParams = (params)=>'signedTransaction' in params;
+    const relaySponsoredTransaction = async (params)=>{
+        try {
+            const signed = isSignedTransactionParams(params) ? params.signedTransaction : await signSponsoredTransaction(params);
+            const { requestId } = await apiClient.sponsorEVMTransaction({
+                traceContext: params.traceContext,
+                request: _extends({
+                    authorization: signed.authorization,
+                    calls: signed.calls.map((c)=>({
+                            data: c.data,
+                            target: c.target,
+                            value: c.value.toString()
+                        })),
+                    chainId: signed.chainId,
+                    deadline: signed.deadline,
+                    nonce: signed.nonce,
+                    relayer: signed.relayer,
+                    signature: signed.signature,
+                    walletAddress: signed.walletAddress
+                }, params.userId ? {
+                    userId: params.userId
+                } : {})
+            });
+            if (!requestId) {
+                throw new Error(ERROR_GASLESS_MISSING_REQUEST_ID);
+            }
+            return {
+                requestId
+            };
+        } catch (error) {
+            const { accountAddress, chainId } = isSignedTransactionParams(params) ? {
+                accountAddress: params.signedTransaction.walletAddress,
+                chainId: params.signedTransaction.chainId
+            } : {
+                accountAddress: params.walletMetadata.accountAddress,
+                chainId: params.chainId
+            };
+            logError$1({
+                message: 'Error relaying sponsored transaction',
+                error: error,
+                context: {
+                    accountAddress,
+                    chainId,
+                    userId: params.userId
+                }
+            });
+            throw error;
+        }
+    };
+    const waitForSponsoredTransaction = async ({ requestId, pollInterval = EVM_GASLESS_DEFAULT_POLL_INTERVAL_MS, timeout = EVM_GASLESS_DEFAULT_TIMEOUT_MS, traceContext })=>{
+        try {
+            // A zero or negative pollInterval makes attempts Infinity and turns this into a
+            // tight loop hammering the status API, so clamp it to a sane minimum.
+            const effectivePoll = Math.max(1, pollInterval);
+            const attempts = Math.max(1, Math.floor(timeout / effectivePoll));
+            for(let i = 0; i < attempts; i++){
+                const r = await getEVMSponsoredTransactionStatus({
+                    requestId,
+                    traceContext
+                });
+                if (r.status === 'failure') {
+                    var _r_errorMessage;
+                    throw new Error(`${ERROR_GASLESS_RELAY_FAILED}: ${(_r_errorMessage = r.errorMessage) != null ? _r_errorMessage : 'unknown'}`);
+                }
+                if (r.transactionHash) {
+                    return {
+                        transactionHash: r.transactionHash
+                    };
+                }
+                if (i < attempts - 1) {
+                    await new Promise((resolve)=>setTimeout(resolve, effectivePoll));
+                }
+            }
+            throw new Error(`${ERROR_GASLESS_TIMEOUT}: ${requestId}`);
+        } catch (error) {
+            logError$1({
+                message: 'Error waiting for sponsored transaction',
+                error: error,
+                context: {
+                    requestId
+                }
+            });
+            throw error;
+        }
+    };
+    const sendSponsoredTransaction = async (params)=>{
+        const { requestId } = await relaySponsoredTransaction(params);
+        return waitForSponsoredTransaction({
+            requestId,
+            traceContext: params.traceContext
+        });
+    };
+    return {
+        getAvailableEvmGaslessRelayer,
+        getEVMSponsoredTransactionStatus,
+        is7702DelegationActive,
+        relaySponsoredTransaction,
+        sendSponsoredTransaction,
+        sign7702Authorization,
+        signSponsoredTransaction,
+        waitForSponsoredTransaction
+    };
+};
+
 const logError = node.createLogError('node-evm');
 class DynamicEvmWalletClient extends node.DynamicWalletClient {
     get jwtAuthToken() {
@@ -829,6 +1233,62 @@ class DynamicEvmWalletClient extends node.DynamicWalletClient {
         const evmWallets = wallets.filter((wallet)=>wallet.chainName === 'EVM');
         return evmWallets;
     }
+    // ---------------------------------------------------------------------------
+    // EVM gasless (Fireblocks-relayer native gasless via EIP-7702 / AuthorizedExecutions)
+    // ---------------------------------------------------------------------------
+    get evmGasless() {
+        return createEvmGaslessClient({
+            apiClient: this.apiClient,
+            createViemPublicClient: (args)=>this.createViemPublicClient(args),
+            signAuthorization: (args)=>this.signAuthorization(args),
+            signTypedData: (args)=>this.signTypedData(args)
+        });
+    }
+    /**
+   * Checks whether the given wallet address has an active EIP-7702 delegation
+   * to the Universal Gasless Delegate (UGD) contract.
+   */ async is7702DelegationActive(params) {
+        return this.evmGasless.is7702DelegationActive(params);
+    }
+    /**
+   * Signs an EIP-7702 authorization that delegates the EOA to the UGD contract.
+   * The EOA nonce is fetched from the chain unless explicitly provided.
+   */ async sign7702Authorization(params) {
+        return this.evmGasless.sign7702Authorization(params);
+    }
+    /**
+   * Fetches the available gasless relayer address for a given chain.
+   */ async getAvailableEvmGaslessRelayer(params) {
+        return this.evmGasless.getAvailableEvmGaslessRelayer(params);
+    }
+    /**
+   * Signs a sponsored transaction intent: resolves 7702 authorization, generates
+   * a bitmap nonce, fetches the relayer, and MPC-signs the EIP-712 typed data.
+   */ async signSponsoredTransaction(params) {
+        return this.evmGasless.signSponsoredTransaction(params);
+    }
+    /**
+   * Returns the current status of an EVM sponsored transaction relay request.
+   */ async getEVMSponsoredTransactionStatus(params) {
+        return this.evmGasless.getEVMSponsoredTransactionStatus(params);
+    }
+    /**
+   * Relays a sponsored transaction to the Dynamic API.
+   * Accepts either a pre-signed transaction or parameters to sign first.
+   */ async relaySponsoredTransaction(params) {
+        return this.evmGasless.relaySponsoredTransaction(params);
+    }
+    /**
+   * Relay then poll to completion. Fixed 60s/2s default (matches js-sdk).
+   * For a custom timeout, use relaySponsoredTransaction + waitForSponsoredTransaction.
+   */ async sendSponsoredTransaction(params) {
+        return this.evmGasless.sendSponsoredTransaction(params);
+    }
+    /**
+   * Polls the relay status until a terminal state (success or failure) is reached.
+   */ async waitForSponsoredTransaction(params) {
+        return this.evmGasless.waitForSponsoredTransaction(params);
+    }
     constructor({ environmentId, baseApiUrl, baseMPCRelayApiUrl, debug, enableMPCAccelerator, logger }){
         super({
             environmentId,
@@ -1024,15 +1484,29 @@ const createZerodevClient = async (evmClient)=>{
     return client;
 };
 
+exports.AUTHORIZED_EXECUTIONS_TYPES = AUTHORIZED_EXECUTIONS_TYPES;
+exports.BATCH_CALL_OPDATA_AUTH_MODE = BATCH_CALL_OPDATA_AUTH_MODE;
+exports.DEFAULT_VALID_FOR_SECONDS = DEFAULT_VALID_FOR_SECONDS;
+exports.DELEGATION_CODE_PREFIX = DELEGATION_CODE_PREFIX;
+exports.DELEGATION_CONTRACT_ADDRESS = DELEGATION_CONTRACT_ADDRESS;
 exports.DynamicEvmWalletClient = DynamicEvmWalletClient;
 exports.ERROR_ACCOUNT_ADDRESS_REQUIRED = ERROR_ACCOUNT_ADDRESS_REQUIRED;
 exports.ERROR_CREATE_WALLET_ACCOUNT = ERROR_CREATE_WALLET_ACCOUNT;
+exports.ERROR_GASLESS_MISSING_REQUEST_ID = ERROR_GASLESS_MISSING_REQUEST_ID;
+exports.ERROR_GASLESS_MISSING_YPARITY = ERROR_GASLESS_MISSING_YPARITY;
+exports.ERROR_GASLESS_RELAY_FAILED = ERROR_GASLESS_RELAY_FAILED;
+exports.ERROR_GASLESS_RPC_REQUIRED = ERROR_GASLESS_RPC_REQUIRED;
+exports.ERROR_GASLESS_RPC_REQUIRED_FOR_AUTO_DELEGATE = ERROR_GASLESS_RPC_REQUIRED_FOR_AUTO_DELEGATE;
+exports.ERROR_GASLESS_TIMEOUT = ERROR_GASLESS_TIMEOUT;
 exports.ERROR_KEYGEN_FAILED = ERROR_KEYGEN_FAILED;
 exports.ERROR_SIGN_MESSAGE = ERROR_SIGN_MESSAGE;
 exports.ERROR_SIGN_RAW_MESSAGE = ERROR_SIGN_RAW_MESSAGE;
 exports.ERROR_SIGN_TYPED_DATA = ERROR_SIGN_TYPED_DATA;
 exports.ERROR_VERIFY_MESSAGE_SIGNATURE = ERROR_VERIFY_MESSAGE_SIGNATURE;
+exports.EVM_GASLESS_DEFAULT_POLL_INTERVAL_MS = EVM_GASLESS_DEFAULT_POLL_INTERVAL_MS;
+exports.EVM_GASLESS_DEFAULT_TIMEOUT_MS = EVM_GASLESS_DEFAULT_TIMEOUT_MS;
 exports.EVM_SIGN_MESSAGE_PREFIX = EVM_SIGN_MESSAGE_PREFIX;
+exports.UGD_ABI = UGD_ABI;
 exports.createAccountAdapter = createAccountAdapter;
 exports.createDelegatedEvmWalletClient = createDelegatedEvmWalletClient;
 exports.createZerodevClient = createZerodevClient;