@pushchain/core 6.0.18 → 6.0.19

package/src/lib/universal/signer/signer.js

@@ -21,10 +21,75 @@ const bs58_1 = require("../../internal/bs58");
 /**
  * Converts viem's parsed transaction to an ethers-compatible TransactionRequest.
  * viem uses `gas` while ethers expects `gasLimit`.
+ *
+ * For EIP-7702 (type-4) transactions the `authorizationList` entries also need
+ * reshaping: viem represents the signature inline (`r`/`s`/`yParity`), whereas
+ * ethers expects a nested `signature`. Without this conversion ethers normalises
+ * the entry to a zero signature and the delegation is silently dropped.
  */
 function toEthersTxRequest(viemTx) {
-    const _a = viemTx, { gas, type } = _a, rest = tslib_1.__rest(_a, ["gas", "type"]);
-    return Object.assign(Object.assign({}, rest), { gasLimit: gas });
+    const _a = viemTx, { gas, type, authorizationList } = _a, rest = tslib_1.__rest(_a, ["gas", "type", "authorizationList"]);
+    const out = Object.assign(Object.assign({}, rest), { gasLimit: gas });
+    if (Array.isArray(authorizationList) && authorizationList.length > 0) {
+        out['type'] = 4;
+        out['authorizationList'] = authorizationList.map((a) => {
+            var _a;
+            return ({
+                address: (_a = a.address) !== null && _a !== void 0 ? _a : a.contractAddress,
+                chainId: a.chainId,
+                nonce: a.nonce,
+                signature: { r: a.r, s: a.s, yParity: a.yParity },
+            });
+        });
+    }
+    return out;
+}
+/**
+ * Builds an EIP-7702 `signAuthorization` for a viem WalletClient, but ONLY when
+ * the underlying account can sign offline (a local account). viem exposes the
+ * `signAuthorization` action on every client — including JSON-RPC accounts that
+ * cannot actually produce one — so we gate on `account.signAuthorization`
+ * (present on local accounts only). Returns `undefined` otherwise so callers
+ * fall back to non-7702 execution.
+ */
+function viemSignAuthorization(wallet, address) {
+    const account = wallet === null || wallet === void 0 ? void 0 : wallet.account;
+    if (!account || typeof account.signAuthorization !== 'function') {
+        return undefined;
+    }
+    return (_a) => tslib_1.__awaiter(this, [_a], void 0, function* ({ contractAddress, chainId, nonce, executor }) {
+        const auth = yield wallet.signAuthorization(Object.assign(Object.assign(Object.assign({ account: account || address, contractAddress }, (chainId !== undefined ? { chainId } : {})), (nonce !== undefined ? { nonce } : {})), (executor ? { executor } : {})));
+        return auth;
+    });
+}
+/**
+ * Builds an EIP-7702 `signAuthorization` for an ethers v6 signer. Presence of
+ * `authorize` is not a reliable capability signal (AbstractSigner's default
+ * throws), so callers MUST also handle a runtime failure and fall back — see
+ * `EIP7702NotSupportedError` in evm-client. Returns `undefined` when the method
+ * is entirely absent (e.g. ethers v5).
+ */
+function ethersSignAuthorization(wallet, chain) {
+    if (typeof (wallet === null || wallet === void 0 ? void 0 : wallet.authorize) !== 'function')
+        return undefined;
+    return (_a) => tslib_1.__awaiter(this, [_a], void 0, function* ({ contractAddress, chainId, nonce }) {
+        var _b, _c, _d;
+        const cid = chainId !== null && chainId !== void 0 ? chainId : Number(chain.split(':')[1]);
+        const auth = yield wallet.authorize({
+            address: contractAddress,
+            chainId: cid,
+            nonce: nonce !== null && nonce !== void 0 ? nonce : 0,
+        });
+        const sig = auth.signature;
+        return {
+            address: contractAddress,
+            chainId: Number((_b = auth.chainId) !== null && _b !== void 0 ? _b : cid),
+            nonce: Number((_d = (_c = auth.nonce) !== null && _c !== void 0 ? _c : nonce) !== null && _d !== void 0 ? _d : 0),
+            r: sig.r,
+            s: sig.s,
+            yParity: Number(sig.yParity),
+        };
+    });
 }
 /**
  * Maps an EVM numeric chainId to the corresponding CHAIN enum.
@@ -72,12 +137,13 @@ function chainIdToChain(chainId) {
  *   signAndSendTransaction: async (data) => signRawTx(data),
  * });
  */
-function createUniversalSigner({ account, signMessage, signAndSendTransaction, signTypedData, }) {
+function createUniversalSigner({ account, signMessage, signAndSendTransaction, signTypedData, signAuthorization, }) {
     return {
         account,
         signMessage,
         signAndSendTransaction,
         signTypedData,
+        signAuthorization,
     };
 }
 /**
@@ -93,6 +159,10 @@ function toUniversalFromKeypair(clientOrAccount_1, _a) {
         let signMessage;
         let signAndSendTransaction;
         let signTypedData;
+        // Optional: only set for EVM wallets that support EIP-7702 authorization
+        // signing. Left undefined for Solana and wallets without 7702 support, in
+        // which case callers fall back to a non-7702 path.
+        let signAuthorization;
         // Check if signer has UID='custom', then we take signMessage, signAndSendTransaction, signTypedData, chain and address from the CustomUniversalSigner.
         // If ViemSigner, convert ViemSigner to UniversalSigner.
         switch (library) {
@@ -129,6 +199,9 @@ function toUniversalFromKeypair(clientOrAccount_1, _a) {
                     const sigHex = yield wallet.signTypedData(domain, types, message);
                     return (0, viem_1.hexToBytes)(sigHex);
                 });
+                // EIP-7702 authorization signing (ethers v6). Backed by a runtime
+                // fallback in evm-client since `authorize` presence isn't a guarantee.
+                signAuthorization = ethersSignAuthorization(wallet, chain);
                 break;
             }
             case enums_1.LIBRARY.ETHEREUM_VIEM: {
@@ -157,6 +230,9 @@ function toUniversalFromKeypair(clientOrAccount_1, _a) {
                     });
                     return (0, viem_1.hexToBytes)(hexSig);
                 });
+                // EIP-7702 authorization signing — only for local viem accounts that can
+                // sign offline (gated inside the helper); JSON-RPC accounts fall back.
+                signAuthorization = viemSignAuthorization(wallet, address);
                 break;
             }
             case enums_1.LIBRARY.SOLANA_WEB3JS: {
@@ -225,6 +301,7 @@ function toUniversalFromKeypair(clientOrAccount_1, _a) {
             signMessage,
             signAndSendTransaction,
             signTypedData,
+            signAuthorization,
         };
         return createUniversalSigner(universalSigner);
     });
@@ -320,6 +397,7 @@ function generateSkeletonFromEthersV6(signer) {
                 const sigHex = yield signer.signTypedData(domain, types, message);
                 return (0, viem_1.hexToBytes)(sigHex);
             }),
+            signAuthorization: ethersSignAuthorization(signer, chain),
         };
     });
 }
@@ -369,6 +447,8 @@ function generateSkeletonFromViem(signer) {
                 });
                 return (0, viem_1.hexToBytes)(hexSig);
             }),
+            // Gated on a local account inside the helper (JSON-RPC accounts → undefined).
+            signAuthorization: viemSignAuthorization(signer, address),
         };
     });
 }

package/src/lib/universal/universal.types.d.ts

@@ -48,6 +48,35 @@ export interface EthersV6SignerType {
     signTypedData: (domain: TypedDataDomain, types: Record<string, Array<any>>, value: Record<string, any>) => Promise<string>;
     provider?: any;
 }
+/**
+ * Parameters for signing an EIP-7702 authorization (delegating an EOA's code to
+ * `contractAddress`).
+ */
+export type SignAuthorizationParams = {
+    /** Address of the contract to delegate the EOA's code to. */
+    contractAddress: `0x${string}`;
+    /** Chain id for the delegation. Defaults to the signer's chain. */
+    chainId?: number;
+    /** Authorization nonce. Omit to let the wallet fill it. */
+    nonce?: number;
+    /**
+     * Set `'self'` when the signing EOA also submits the type-4 transaction; the
+     * wallet then bumps the authorization nonce by one. Prefer passing an explicit
+     * `nonce` for deterministic self-execution.
+     */
+    executor?: 'self';
+};
+/** A signed EIP-7702 authorization (viem-compatible shape). */
+export type SignedAuthorization = {
+    /** Address of the contract the EOA's code is delegated to. */
+    address: `0x${string}`;
+    chainId: number;
+    nonce: number;
+    r: `0x${string}`;
+    s: `0x${string}`;
+    yParity: number;
+    v?: bigint;
+};
 /**
  * A signer capable of signing messages for a specific chain.
  * Used to abstract away signing across multiple VM types.
@@ -84,12 +113,20 @@ export interface UniversalSigner {
      * Used for sending on-chain transactions.
      */
     signAndSendTransaction: (unsignedTx: Uint8Array) => Promise<Uint8Array>;
+    /**
+     * Signs an EIP-7702 authorization, delegating the EOA's code to
+     * `contractAddress`. Optional — only EVM signers whose underlying wallet
+     * supports EIP-7702 implement it. When absent, callers must fall back to a
+     * non-7702 path (e.g. sequential single calls).
+     */
+    signAuthorization?: (params: SignAuthorizationParams) => Promise<SignedAuthorization>;
 }
 export interface UniversalSignerSkeleton {
     signerId: string;
     account: UniversalAccount;
     signMessage: (data: Uint8Array) => Promise<Uint8Array>;
     signAndSendTransaction: (unsignedTx: Uint8Array) => Promise<Uint8Array>;
+    signAuthorization?: (params: SignAuthorizationParams) => Promise<SignedAuthorization>;
     signTypedData?: ({ domain, types, primaryType, message, }: {
         domain: TypedDataDomain;
         types: TypedData;

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

@@ -1,6 +1,25 @@
 import { UniversalSigner } from '../universal/universal.types';
 import { ClientOptions, ReadContractParams, TxResponse, WriteContractParams } from './vm-client.types';
 import { PublicClient, Hex } from 'viem';
+/** A single call in a 7702 batch. */
+export type BatchCall = {
+    to: `0x${string}`;
+    value: bigint;
+    data: `0x${string}`;
+};
+/**
+ * Thrown by {@link EvmClient.sendBatch7702} when the signer cannot actually
+ * produce an EIP-7702 authorization — either the capability is absent, or the
+ * wallet exposes a `signAuthorization`/`authorize` method that throws at call
+ * time (e.g. viem JSON-RPC accounts, ethers' default `AbstractSigner.authorize`).
+ *
+ * It is raised strictly BEFORE any transaction is broadcast, so callers may
+ * safely fall back to a non-7702 path without risk of double execution.
+ */
+export declare class EIP7702NotSupportedError extends Error {
+    readonly reason?: unknown;
+    constructor(reason?: unknown);
+}
 /**
  * EVM client for reading and writing to Ethereum-compatible chains
  *
@@ -126,6 +145,30 @@ export declare class EvmClient {
         nonce?: number;
         gas?: bigint;
     }): Promise<Hex>;
+    /**
+     * Executes a batch of calls atomically from a native EOA using EIP-7702.
+     *
+     * The EOA signs an authorization delegating its code to `executor`
+     * (`PushBatchExecutor`, an ERC-7821 executor) and submits a single type-4
+     * transaction calling `execute(mode, executionData)` on itself. Because the
+     * authority equals the transaction sender, ERC-7821's self-call check
+     * authorizes the batch — no per-call signature is needed. All calls succeed
+     * or the whole tx reverts.
+     *
+     * Requires `signer.signAuthorization` (EIP-7702 capable wallet). Callers
+     * should check for it and fall back to sequential execution when absent.
+     *
+     * Rejects a zero `to` address: ERC-7579/7821 reinterprets `target == 0` as
+     * `address(this)`, which would silently differ from the sequential fallback
+     * (which sends to the zero address). Disallow it so behaviour is consistent.
+     *
+     * @returns The transaction hash.
+     */
+    sendBatch7702({ executor, calls, signer, }: {
+        executor: `0x${string}`;
+        calls: BatchCall[];
+        signer: UniversalSigner;
+    }): Promise<Hex>;
     /**
      * Estimates the gas required for a transaction.
      *

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

@@ -1,8 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EvmClient = void 0;
+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 —
+ * invoked by a native Push EOA on itself after it delegates its code to the
+ * executor (`PushBatchExecutor is ERC7821`) via EIP-7702. ERC-7821's default
+ * authorization (`caller == address(this)`) is exactly that self-call.
+ */
+const PUSH_BATCH_EXECUTOR_ABI = (0, viem_1.parseAbi)([
+    'function execute(bytes32 mode, bytes executionData) payable',
+]);
+/**
+ * ERC-7821 single-batch execution mode: callType `0x01` (batch) in the top byte,
+ * default exec type and zero mode-selector — i.e. `0x01` followed by 31 zero
+ * bytes. This is the only mode the executor supports.
+ */
+const ERC7821_BATCH_MODE = '0x0100000000000000000000000000000000000000000000000000000000000000';
+/**
+ * ABI tuple for an ERC-7821 / ERC-7579 `Execution`. `executionData` for a batch
+ * is `abi.encode(Execution[])`.
+ */
+const ERC7821_EXECUTION_TUPLE = {
+    type: 'tuple[]',
+    components: [
+        { name: 'target', type: 'address' },
+        { name: 'value', type: 'uint256' },
+        { name: 'callData', type: 'bytes' },
+    ],
+};
+/**
+ * Thrown by {@link EvmClient.sendBatch7702} when the signer cannot actually
+ * produce an EIP-7702 authorization — either the capability is absent, or the
+ * wallet exposes a `signAuthorization`/`authorize` method that throws at call
+ * time (e.g. viem JSON-RPC accounts, ethers' default `AbstractSigner.authorize`).
+ *
+ * It is raised strictly BEFORE any transaction is broadcast, so callers may
+ * safely fall back to a non-7702 path without risk of double execution.
+ */
+class EIP7702NotSupportedError extends Error {
+    constructor(reason) {
+        super('Signer cannot produce an EIP-7702 authorization');
+        this.name = 'EIP7702NotSupportedError';
+        this.reason = reason;
+    }
+}
+exports.EIP7702NotSupportedError = EIP7702NotSupportedError;
 /**
  * EVM client for reading and writing to Ethereum-compatible chains
  *
@@ -203,6 +247,115 @@ class EvmClient {
             return (0, viem_1.bytesToHex)(txHashBytes);
         });
     }
+    /**
+     * Executes a batch of calls atomically from a native EOA using EIP-7702.
+     *
+     * The EOA signs an authorization delegating its code to `executor`
+     * (`PushBatchExecutor`, an ERC-7821 executor) and submits a single type-4
+     * transaction calling `execute(mode, executionData)` on itself. Because the
+     * authority equals the transaction sender, ERC-7821's self-call check
+     * authorizes the batch — no per-call signature is needed. All calls succeed
+     * or the whole tx reverts.
+     *
+     * Requires `signer.signAuthorization` (EIP-7702 capable wallet). Callers
+     * should check for it and fall back to sequential execution when absent.
+     *
+     * Rejects a zero `to` address: ERC-7579/7821 reinterprets `target == 0` as
+     * `address(this)`, which would silently differ from the sequential fallback
+     * (which sends to the zero address). Disallow it so behaviour is consistent.
+     *
+     * @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)({
+                chainId,
+                type: 'eip7702',
+                to: account,
+                data,
+                gas,
+                nonce,
+                maxFeePerGas: feePerGas.maxFeePerGas,
+                maxPriorityFeePerGas: feePerGas.maxPriorityFeePerGas,
+                value: BigInt(0),
+                authorizationList: [authorization],
+            });
+            const txHashBytes = yield signer.signAndSendTransaction((0, viem_1.hexToBytes)(unsignedTx));
+            return (0, viem_1.bytesToHex)(txHashBytes);
+        });
+    }
     /**
      * Estimates the gas required for a transaction.
      *