@pushchain/core 6.0.20 → 6.0.21

package/src/lib/vm-client/evm-client.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EvmClient = exports.EIP7702NotSupportedError = void 0;
-const tslib_1 = require("tslib");
 const viem_1 = require("viem");
 /**
  * ABI of the ERC-7821 `execute(bytes32 mode, bytes executionData)` entrypoint —
@@ -40,6 +39,7 @@ const ERC7821_EXECUTION_TUPLE = {
  * safely fall back to a non-7702 path without risk of double execution.
  */
 class EIP7702NotSupportedError extends Error {
+    reason;
     constructor(reason) {
         super('Signer cannot produce an EIP-7702 authorization');
         this.name = 'EIP7702NotSupportedError';
@@ -57,6 +57,7 @@ exports.EIP7702NotSupportedError = EIP7702NotSupportedError;
  * });
  */
 class EvmClient {
+    publicClient;
     constructor({ rpcUrls, chain }) {
         // retryCount/retryDelay make reads (incl. contract reads + Push status
         // queries via PushClient) resilient to transient RPC 5xx (e.g. 502s under
@@ -86,10 +87,8 @@ class EvmClient {
      *   console.log('Address has no funds');
      * }
      */
-    getBalance(address) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return this.publicClient.getBalance({ address });
-        });
+    async getBalance(address) {
+        return this.publicClient.getBalance({ address });
     }
     /**
      * Performs a read-only call to a smart contract.
@@ -115,14 +114,12 @@ class EvmClient {
      *   args: ['0xUserAddress'],
      * });
      */
-    readContract(_a) {
-        return tslib_1.__awaiter(this, arguments, void 0, function* ({ abi, address, functionName, args = [], }) {
-            return this.publicClient.readContract({
-                abi: abi,
-                address: address,
-                functionName,
-                args,
-            });
+    async readContract({ abi, address, functionName, args = [], }) {
+        return this.publicClient.readContract({
+            abi: abi,
+            address: address,
+            functionName,
+            args,
         });
     }
     /**
@@ -131,17 +128,15 @@ class EvmClient {
      * This is a convenience wrapper around readContract using the minimal
      * ERC-20 ABI: balanceOf(address) -> uint256.
      */
-    getErc20Balance(_a) {
-        return tslib_1.__awaiter(this, arguments, void 0, function* ({ tokenAddress, ownerAddress, }) {
-            const erc20Abi = (0, viem_1.parseAbi)([
-                'function balanceOf(address) view returns (uint256)',
-            ]);
-            return this.readContract({
-                abi: erc20Abi,
-                address: tokenAddress,
-                functionName: 'balanceOf',
-                args: [ownerAddress],
-            });
+    async getErc20Balance({ tokenAddress, ownerAddress, }) {
+        const erc20Abi = (0, viem_1.parseAbi)([
+            'function balanceOf(address) view returns (uint256)',
+        ]);
+        return this.readContract({
+            abi: erc20Abi,
+            address: tokenAddress,
+            functionName: 'balanceOf',
+            args: [ownerAddress],
         });
     }
     /**
@@ -173,19 +168,17 @@ class EvmClient {
      *   signer: universalSigner,
      * });
      */
-    writeContract(_a) {
-        return tslib_1.__awaiter(this, arguments, void 0, function* ({ abi, address, functionName, args = [], value = BigInt(0), signer, }) {
-            const data = (0, viem_1.encodeFunctionData)({
-                abi: abi,
-                functionName,
-                args,
-            });
-            return this.sendTransaction({
-                to: address,
-                data,
-                value,
-                signer,
-            });
+    async writeContract({ abi, address, functionName, args = [], value = BigInt(0), signer, }) {
+        const data = (0, viem_1.encodeFunctionData)({
+            abi: abi,
+            functionName,
+            args,
+        });
+        return this.sendTransaction({
+            to: address,
+            data,
+            value,
+            signer,
         });
     }
     /**
@@ -208,44 +201,42 @@ class EvmClient {
      * });
      * console.log(`ETH transfer sent: ${txHash}`);
      */
-    sendTransaction(_a) {
-        return tslib_1.__awaiter(this, arguments, void 0, function* ({ to, data, value = BigInt(0), signer, nonce: explicitNonce, gas: explicitGas, }) {
-            // Estimate gas and fees first (can run in parallel)
-            const [gas, feePerGas, chainId] = yield Promise.all([
-                explicitGas
-                    ? Promise.resolve(explicitGas)
-                    : data === '0x'
-                        ? Promise.resolve(BigInt(21000))
-                        : this.publicClient.estimateGas({
-                            account: signer.account.address,
-                            to,
-                            data,
-                            value,
-                        }),
-                this.publicClient.estimateFeesPerGas(),
-                this.publicClient.getChainId(),
-            ]);
-            const nonce = explicitNonce !== null && explicitNonce !== void 0 ? explicitNonce : yield this.publicClient.getTransactionCount({
-                address: signer.account.address,
-                blockTag: 'pending',
-            });
-            const unsignedTx = (0, viem_1.serializeTransaction)({
-                chainId,
-                type: 'eip1559',
-                to,
-                data,
-                gas,
-                nonce,
-                maxFeePerGas: feePerGas.maxFeePerGas,
-                maxPriorityFeePerGas: feePerGas.maxPriorityFeePerGas,
-                value,
-            });
-            if (!signer.signAndSendTransaction) {
-                throw new Error('signer.signAndSendTransaction is undefined');
-            }
-            const txHashBytes = yield signer.signAndSendTransaction((0, viem_1.hexToBytes)(unsignedTx));
-            return (0, viem_1.bytesToHex)(txHashBytes);
+    async sendTransaction({ to, data, value = BigInt(0), signer, nonce: explicitNonce, gas: explicitGas, }) {
+        // Estimate gas and fees first (can run in parallel)
+        const [gas, feePerGas, chainId] = await Promise.all([
+            explicitGas
+                ? Promise.resolve(explicitGas)
+                : data === '0x'
+                    ? Promise.resolve(BigInt(21000))
+                    : this.publicClient.estimateGas({
+                        account: signer.account.address,
+                        to,
+                        data,
+                        value,
+                    }),
+            this.publicClient.estimateFeesPerGas(),
+            this.publicClient.getChainId(),
+        ]);
+        const nonce = explicitNonce ?? await this.publicClient.getTransactionCount({
+            address: signer.account.address,
+            blockTag: 'pending',
+        });
+        const unsignedTx = (0, viem_1.serializeTransaction)({
+            chainId,
+            type: 'eip1559',
+            to,
+            data,
+            gas,
+            nonce,
+            maxFeePerGas: feePerGas.maxFeePerGas,
+            maxPriorityFeePerGas: feePerGas.maxPriorityFeePerGas,
+            value,
         });
+        if (!signer.signAndSendTransaction) {
+            throw new Error('signer.signAndSendTransaction is undefined');
+        }
+        const txHashBytes = await signer.signAndSendTransaction((0, viem_1.hexToBytes)(unsignedTx));
+        return (0, viem_1.bytesToHex)(txHashBytes);
     }
     /**
      * Executes a batch of calls atomically from a native EOA using EIP-7702.
@@ -266,95 +257,93 @@ class EvmClient {
      *
      * @returns The transaction hash.
      */
-    sendBatch7702(_a) {
-        return tslib_1.__awaiter(this, arguments, void 0, function* ({ executor, calls, signer, }) {
-            if (!signer.signAuthorization) {
-                // No capability at all → safe pre-broadcast signal to fall back.
-                throw new EIP7702NotSupportedError();
-            }
-            if (!signer.signAndSendTransaction) {
-                throw new Error('signer.signAndSendTransaction is undefined');
-            }
-            const account = signer.account.address;
-            // ERC-7821 maps target == address(0) to address(this); reject it so a batch
-            // can't silently behave differently here vs. the sequential fallback.
-            if (calls.some((c) => /^0x0{40}$/i.test(c.to) || c.to.toLowerCase() === '0x0')) {
-                throw new Error('sendBatch7702: a call has a zero `to` address, which ERC-7821 reinterprets ' +
-                    'as the account itself. Use an explicit target.');
-            }
-            // ERC-7821: execute(mode, executionData) where executionData = abi.encode(Execution[]).
-            const executionData = (0, viem_1.encodeAbiParameters)([ERC7821_EXECUTION_TUPLE], [
-                calls.map((c) => ({ target: c.to, value: c.value, callData: c.data })),
-            ]);
-            const data = (0, viem_1.encodeFunctionData)({
-                abi: PUSH_BATCH_EXECUTOR_ABI,
-                functionName: 'execute',
-                args: [ERC7821_BATCH_MODE, executionData],
-            });
-            const [feePerGas, chainId, nonce] = yield Promise.all([
-                this.publicClient.estimateFeesPerGas(),
-                this.publicClient.getChainId(),
-                this.publicClient.getTransactionCount({
-                    address: account,
-                    blockTag: 'pending',
-                }),
-            ]);
-            // EIP-7702 self-execution: the transaction consumes `nonce`, so the
-            // authorization (validated after the sender's nonce is bumped) must carry
-            // `nonce + 1`. This is the only step that can reveal the wallet truly can't
-            // sign a 7702 authorization (presence of the method is not a guarantee), so
-            // a failure here is surfaced as EIP7702NotSupportedError — pre-broadcast,
-            // hence safe for the caller to fall back on.
-            let authorization;
-            try {
-                authorization = yield signer.signAuthorization({
-                    contractAddress: executor,
-                    chainId,
-                    nonce: nonce + 1,
-                });
-            }
-            catch (err) {
-                throw new EIP7702NotSupportedError(err);
-            }
-            // Estimate gas against the delegated account: override the EOA's code with
-            // the 7702 delegation designator (0xef0100 || executor) so estimation runs
-            // the executor. Fall back to a safe ceiling if the node rejects overrides.
-            let gas;
-            try {
-                gas = yield this.publicClient.estimateGas({
-                    account,
-                    to: account,
-                    data,
-                    stateOverride: [
-                        {
-                            address: account,
-                            code: ('0xef0100' + executor.slice(2)),
-                        },
-                    ],
-                });
-                gas = (gas * BigInt(120)) / BigInt(100); // headroom for delegation + auth
-            }
-            catch (_b) {
-                // Estimation unavailable (e.g. node rejects state overrides). Scale the
-                // ceiling with the batch size so large batches don't OOG — the legacy
-                // per-call loop budgeted ~500k gas per call; mirror that plus overhead.
-                gas = BigInt(500000) * BigInt(calls.length) + BigInt(100000);
-            }
-            const unsignedTx = (0, viem_1.serializeTransaction)({
+    async sendBatch7702({ executor, calls, signer, }) {
+        if (!signer.signAuthorization) {
+            // No capability at all → safe pre-broadcast signal to fall back.
+            throw new EIP7702NotSupportedError();
+        }
+        if (!signer.signAndSendTransaction) {
+            throw new Error('signer.signAndSendTransaction is undefined');
+        }
+        const account = signer.account.address;
+        // ERC-7821 maps target == address(0) to address(this); reject it so a batch
+        // can't silently behave differently here vs. the sequential fallback.
+        if (calls.some((c) => /^0x0{40}$/i.test(c.to) || c.to.toLowerCase() === '0x0')) {
+            throw new Error('sendBatch7702: a call has a zero `to` address, which ERC-7821 reinterprets ' +
+                'as the account itself. Use an explicit target.');
+        }
+        // ERC-7821: execute(mode, executionData) where executionData = abi.encode(Execution[]).
+        const executionData = (0, viem_1.encodeAbiParameters)([ERC7821_EXECUTION_TUPLE], [
+            calls.map((c) => ({ target: c.to, value: c.value, callData: c.data })),
+        ]);
+        const data = (0, viem_1.encodeFunctionData)({
+            abi: PUSH_BATCH_EXECUTOR_ABI,
+            functionName: 'execute',
+            args: [ERC7821_BATCH_MODE, executionData],
+        });
+        const [feePerGas, chainId, nonce] = await Promise.all([
+            this.publicClient.estimateFeesPerGas(),
+            this.publicClient.getChainId(),
+            this.publicClient.getTransactionCount({
+                address: account,
+                blockTag: 'pending',
+            }),
+        ]);
+        // EIP-7702 self-execution: the transaction consumes `nonce`, so the
+        // authorization (validated after the sender's nonce is bumped) must carry
+        // `nonce + 1`. This is the only step that can reveal the wallet truly can't
+        // sign a 7702 authorization (presence of the method is not a guarantee), so
+        // a failure here is surfaced as EIP7702NotSupportedError — pre-broadcast,
+        // hence safe for the caller to fall back on.
+        let authorization;
+        try {
+            authorization = await signer.signAuthorization({
+                contractAddress: executor,
                 chainId,
-                type: 'eip7702',
+                nonce: nonce + 1,
+            });
+        }
+        catch (err) {
+            throw new EIP7702NotSupportedError(err);
+        }
+        // Estimate gas against the delegated account: override the EOA's code with
+        // the 7702 delegation designator (0xef0100 || executor) so estimation runs
+        // the executor. Fall back to a safe ceiling if the node rejects overrides.
+        let gas;
+        try {
+            gas = await this.publicClient.estimateGas({
+                account,
                 to: account,
                 data,
-                gas,
-                nonce,
-                maxFeePerGas: feePerGas.maxFeePerGas,
-                maxPriorityFeePerGas: feePerGas.maxPriorityFeePerGas,
-                value: BigInt(0),
-                authorizationList: [authorization],
+                stateOverride: [
+                    {
+                        address: account,
+                        code: ('0xef0100' + executor.slice(2)),
+                    },
+                ],
             });
-            const txHashBytes = yield signer.signAndSendTransaction((0, viem_1.hexToBytes)(unsignedTx));
-            return (0, viem_1.bytesToHex)(txHashBytes);
+            gas = (gas * BigInt(120)) / BigInt(100); // headroom for delegation + auth
+        }
+        catch {
+            // Estimation unavailable (e.g. node rejects state overrides). Scale the
+            // ceiling with the batch size so large batches don't OOG — the legacy
+            // per-call loop budgeted ~500k gas per call; mirror that plus overhead.
+            gas = BigInt(500_000) * BigInt(calls.length) + BigInt(100_000);
+        }
+        const unsignedTx = (0, viem_1.serializeTransaction)({
+            chainId,
+            type: 'eip7702',
+            to: account,
+            data,
+            gas,
+            nonce,
+            maxFeePerGas: feePerGas.maxFeePerGas,
+            maxPriorityFeePerGas: feePerGas.maxPriorityFeePerGas,
+            value: BigInt(0),
+            authorizationList: [authorization],
         });
+        const txHashBytes = await signer.signAndSendTransaction((0, viem_1.hexToBytes)(unsignedTx));
+        return (0, viem_1.bytesToHex)(txHashBytes);
     }
     /**
      * Estimates the gas required for a transaction.
@@ -386,14 +375,12 @@ class EvmClient {
      *   value: BigInt(0),
      * });
      */
-    estimateGas(_a) {
-        return tslib_1.__awaiter(this, arguments, void 0, function* ({ from, to, value, data, }) {
-            return this.publicClient.estimateGas({
-                account: from || undefined,
-                to,
-                value,
-                data,
-            });
+    async estimateGas({ from, to, value, data, }) {
+        return this.publicClient.estimateGas({
+            account: from || undefined,
+            to,
+            value,
+            data,
         });
     }
     /**
@@ -415,10 +402,8 @@ class EvmClient {
      * const totalCost = gasPrice * gasEstimate;
      * console.log(`Estimated transaction cost: ${totalCost} wei`);
      */
-    getGasPrice() {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return this.publicClient.getGasPrice();
-        });
+    async getGasPrice() {
+        return this.publicClient.getGasPrice();
     }
     /**
      * Fetches the full transaction response by hash.
@@ -430,20 +415,21 @@ class EvmClient {
      * const tx = await evmClient.getTransaction('0xabc...');
      * console.log(tx?.from, tx?.to, tx?.value);
      */
-    getTransaction(txHash) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const tx = yield this.publicClient.getTransaction({ hash: txHash });
-            if (!tx)
-                throw new Error('No transaction found!');
-            const wait = (...args_1) => tslib_1.__awaiter(this, [...args_1], void 0, function* (confirmations = 1) {
-                const receipt = yield this.publicClient.waitForTransactionReceipt({
-                    hash: txHash,
-                    confirmations,
-                });
-                return receipt;
+    async getTransaction(txHash) {
+        const tx = await this.publicClient.getTransaction({ hash: txHash });
+        if (!tx)
+            throw new Error('No transaction found!');
+        const wait = async (confirmations = 1) => {
+            const receipt = await this.publicClient.waitForTransactionReceipt({
+                hash: txHash,
+                confirmations,
             });
-            return Object.assign(Object.assign({}, tx), { wait });
-        });
+            return receipt;
+        };
+        return {
+            ...tx,
+            wait,
+        };
     }
     /**
      * Waits for a transaction to achieve the desired number of confirmations.
@@ -453,26 +439,24 @@ class EvmClient {
      * @param pollIntervalMs - How often to check (default: 1000 ms)
      * @param timeoutMs      - Maximum time to wait before error (default: 60000 ms)
      */
-    waitForConfirmations(_a) {
-        return tslib_1.__awaiter(this, arguments, void 0, function* ({ txHash, confirmations = 3, pollIntervalMs = 1000, timeoutMs = 30000, }) {
-            const receipt = yield this.publicClient.waitForTransactionReceipt({
-                hash: txHash,
-            });
-            const targetBlock = receipt.blockNumber + BigInt(confirmations);
-            const startTime = Date.now();
-            // eslint-disable-next-line no-constant-condition
-            while (true) {
-                const currentBlock = yield this.publicClient.getBlockNumber();
-                if (currentBlock >= targetBlock) {
-                    return;
-                }
-                if (Date.now() - startTime > timeoutMs) {
-                    throw new Error(`Timeout: transaction ${txHash} not confirmed with ${confirmations} confirmations ` +
-                        `within ${timeoutMs} ms`);
-                }
-                yield new Promise((r) => setTimeout(r, pollIntervalMs));
-            }
+    async waitForConfirmations({ txHash, confirmations = 3, pollIntervalMs = 1000, timeoutMs = 30000, }) {
+        const receipt = await this.publicClient.waitForTransactionReceipt({
+            hash: txHash,
         });
+        const targetBlock = receipt.blockNumber + BigInt(confirmations);
+        const startTime = Date.now();
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const currentBlock = await this.publicClient.getBlockNumber();
+            if (currentBlock >= targetBlock) {
+                return;
+            }
+            if (Date.now() - startTime > timeoutMs) {
+                throw new Error(`Timeout: transaction ${txHash} not confirmed with ${confirmations} confirmations ` +
+                    `within ${timeoutMs} ms`);
+            }
+            await new Promise((r) => setTimeout(r, pollIntervalMs));
+        }
     }
 }
 exports.EvmClient = EvmClient;

package/src/lib/vm-client/svm-client.d.ts

@@ -26,7 +26,7 @@ export declare class SvmClient {
     /**
      * Sends a Solana transaction using a smart contract instruction.
      */
-    writeContract({ abi, signer, functionName, args, accounts, extraSigners, }: WriteContractParams): Promise<string>;
+    writeContract({ abi, signer, functionName, args, accounts, extraSigners, remainingAccounts, }: WriteContractParams): Promise<string>;
     /**
      * Sends a set of instructions as a manually-signed Solana transaction.
      */