@tonappchain/sdk 0.7.3-rc8 → 0.8.0-aa-alpha-test

package/dist/artifacts/testnet/ton/internal/wrappers/Settings.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Settings = exports.SettingsErrors = exports.SettingsOpCodes = void 0;
 exports.settingsConfigToCell = settingsConfigToCell;
+exports.createSettingsSetValueBody = createSettingsSetValueBody;
 const core_1 = require("@ton/core");
 const GasUtils_1 = require("./utils/GasUtils");
 exports.SettingsOpCodes = {
@@ -29,6 +30,14 @@ function settingsConfigToCell(config) {
         .storeDict(config.settings)
         .endCell();
 }
+function createSettingsSetValueBody(params) {
+    return (0, core_1.beginCell)()
+        .storeUint(exports.SettingsOpCodes.admin_setValue, 32)
+        .storeUint(params.queryId ?? 0, 64)
+        .storeUint(params.key, 256)
+        .storeRef(params.value)
+        .endCell();
+}
 class Settings {
     constructor(address, init, configuration) {
         this.address = address;
@@ -54,12 +63,7 @@ class Settings {
         await provider.internal(via, {
             value,
             sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
-            body: (0, core_1.beginCell)()
-                .storeUint(exports.SettingsOpCodes.admin_setValue, 32)
-                .storeUint(params.queryId ?? 0, 64)
-                .storeUint(params.key, 256)
-                .storeRef(params.value)
-                .endCell(),
+            body: createSettingsSetValueBody(params),
         });
     }
     async sendGetValue(provider, via, value, params) {
@@ -148,6 +152,6 @@ class Settings {
     }
 }
 exports.Settings = Settings;
-Settings.storageStats = new GasUtils_1.StorageStats(39375n, 118n);
+Settings.storageStats = new GasUtils_1.StorageStats(39175n, 118n);
 Settings.minStorageDuration = 10 * 365 * 24 * 3600; // 10 years
 Settings.minStorageStats = new GasUtils_1.StorageStats(29557n, 104n);

package/dist/src/accountAbstraction/BaseAccountAPI.d.ts

@@ -0,0 +1,62 @@
+import { BigNumberish, Contract, Provider } from 'ethers';
+import { FactoryParams, UserOperation } from './internal/userOp';
+import { PaymasterAPI } from './PaymasterAPI';
+import { TransactionDetailsForUserOp } from './TransactionDetailsForUserOp';
+export interface BaseApiParams {
+    provider: Provider;
+    entryPointAddress: string;
+    accountAddress?: string;
+    paymasterAPI?: PaymasterAPI;
+}
+export interface UserOpResult {
+    transactionHash: string;
+    success: boolean;
+}
+/**
+ * Base class for ERC-4337 v0.8 account clients. A subclass implements the account-specific
+ * bits (initCode, nonce, execute encoding, signing); this class assembles + signs UserOps.
+ */
+export declare abstract class BaseAccountAPI {
+    private senderAddress?;
+    private isPhantom;
+    protected readonly entryPointView: Contract;
+    provider: Provider;
+    entryPointAddress: string;
+    accountAddress?: string;
+    paymasterAPI?: PaymasterAPI;
+    protected constructor(params: BaseApiParams);
+    init(): Promise<this>;
+    /** initCode `factory` + `factoryData` when the account is not yet deployed. */
+    abstract getFactoryData(): Promise<FactoryParams | null>;
+    /** Current account nonce. */
+    abstract getNonce(): Promise<bigint>;
+    /** Encode the call from EntryPoint through the account to the target contract. */
+    abstract encodeExecute(target: string, value: BigNumberish, data: string): Promise<string>;
+    /** Sign a userOpHash. */
+    abstract signUserOpHash(userOpHash: string): Promise<string>;
+    /** Whether the account contract is not yet deployed. */
+    checkAccountPhantom(): Promise<boolean>;
+    /** Compute the account address before deployment (via EntryPoint.getSenderAddress). */
+    getCounterFactualAddress(): Promise<string>;
+    /** initCode for the UserOp (factory + factoryData), or null if already deployed. */
+    getRequiredFactoryData(): Promise<FactoryParams | null>;
+    /** Maximum gas used for verification (creation cost is added on top when phantom). */
+    getVerificationGasLimit(): Promise<BigNumberish>;
+    /** Return userOpHash for signing — computed on-chain to match EntryPoint exactly. */
+    getUserOpHash(op: UserOperation): Promise<string>;
+    /** Account address (valid even before deployment). */
+    getAccountAddress(): Promise<string>;
+    encodeUserOpCallDataAndGasLimit(detailsForUserOp: TransactionDetailsForUserOp): Promise<{
+        callData: string;
+        callGasLimit: bigint;
+    }>;
+    estimateCreationGas(factoryParams: FactoryParams | null): Promise<bigint>;
+    /**
+     * Create an unsigned UserOperation with all fields filled (signature empty).
+     */
+    createUnsignedUserOp(info: TransactionDetailsForUserOp): Promise<UserOperation>;
+    /** Sign a filled userOp. */
+    signUserOp(userOp: UserOperation): Promise<UserOperation>;
+    /** Create and sign a UserOperation. */
+    createSignedUserOp(info: TransactionDetailsForUserOp): Promise<UserOperation>;
+}

package/dist/src/accountAbstraction/BaseAccountAPI.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAccountAPI = void 0;
+const ethers_1 = require("ethers");
+const entryPointAbi_1 = require("./internal/entryPointAbi");
+const userOp_1 = require("./internal/userOp");
+/**
+ * Base class for ERC-4337 v0.8 account clients. A subclass implements the account-specific
+ * bits (initCode, nonce, execute encoding, signing); this class assembles + signs UserOps.
+ */
+class BaseAccountAPI {
+    constructor(params) {
+        this.isPhantom = true;
+        this.provider = params.provider;
+        this.entryPointAddress = params.entryPointAddress;
+        this.accountAddress = params.accountAddress;
+        this.paymasterAPI = params.paymasterAPI;
+        this.entryPointView = new ethers_1.Contract(params.entryPointAddress, entryPointAbi_1.IEntryPointABI, params.provider);
+    }
+    async init() {
+        if ((await this.provider.getCode(this.entryPointAddress)) === '0x') {
+            throw new Error(`entryPoint not deployed at ${this.entryPointAddress}`);
+        }
+        await this.getAccountAddress();
+        return this;
+    }
+    /** Whether the account contract is not yet deployed. */
+    async checkAccountPhantom() {
+        if (!this.isPhantom) {
+            return this.isPhantom;
+        }
+        const senderAddressCode = await this.provider.getCode(await this.getAccountAddress());
+        if (senderAddressCode.length > 2) {
+            this.isPhantom = false;
+        }
+        return this.isPhantom;
+    }
+    /** Compute the account address before deployment (via EntryPoint.getSenderAddress). */
+    async getCounterFactualAddress() {
+        const { factory, factoryData } = (await this.getFactoryData()) ?? {};
+        if (factory == null) {
+            throw new Error('no counterfactual address without a factory');
+        }
+        const initCode = (0, ethers_1.concat)([factory, (0, userOp_1.toHexBytes)(factoryData)]);
+        try {
+            await this.entryPointView.getSenderAddress.staticCall(initCode);
+        }
+        catch (e) {
+            // getSenderAddress always reverts with SenderAddressResult(sender)
+            const err = e;
+            if (err.revert?.name === 'SenderAddressResult') {
+                return err.revert.args?.[0];
+            }
+            if (err.data != null) {
+                return this.entryPointView.interface.decodeErrorResult('SenderAddressResult', err.data)[0];
+            }
+            throw e;
+        }
+        throw new Error('getSenderAddress did not revert as expected');
+    }
+    /** initCode for the UserOp (factory + factoryData), or null if already deployed. */
+    async getRequiredFactoryData() {
+        if (await this.checkAccountPhantom()) {
+            return await this.getFactoryData();
+        }
+        return null;
+    }
+    /** Maximum gas used for verification (creation cost is added on top when phantom). */
+    async getVerificationGasLimit() {
+        return 100000;
+    }
+    /** Return userOpHash for signing — computed on-chain to match EntryPoint exactly. */
+    async getUserOpHash(op) {
+        return await this.entryPointView.getUserOpHash.staticCall((0, userOp_1.packUserOp)(op));
+    }
+    /** Account address (valid even before deployment). */
+    async getAccountAddress() {
+        if (this.senderAddress == null) {
+            this.senderAddress = this.accountAddress ?? (await this.getCounterFactualAddress());
+        }
+        return this.senderAddress;
+    }
+    async encodeUserOpCallDataAndGasLimit(detailsForUserOp) {
+        const value = detailsForUserOp.value != null && detailsForUserOp.value !== '' ? BigInt(detailsForUserOp.value) : 0n;
+        const callData = await this.encodeExecute(detailsForUserOp.target, value, detailsForUserOp.data);
+        const callGasLimit = detailsForUserOp.gasLimit != null && detailsForUserOp.gasLimit !== ''
+            ? BigInt(detailsForUserOp.gasLimit)
+            : await this.provider.estimateGas({
+                from: this.entryPointAddress,
+                to: await this.getAccountAddress(),
+                data: callData,
+            });
+        return { callData, callGasLimit };
+    }
+    async estimateCreationGas(factoryParams) {
+        if (factoryParams == null) {
+            return 0n;
+        }
+        const senderCreator = await this.entryPointView.senderCreator();
+        return await this.provider.estimateGas({
+            from: senderCreator,
+            to: factoryParams.factory,
+            data: (0, userOp_1.toHexBytes)(factoryParams.factoryData),
+        });
+    }
+    /**
+     * Create an unsigned UserOperation with all fields filled (signature empty).
+     */
+    async createUnsignedUserOp(info) {
+        const { callData, callGasLimit } = await this.encodeUserOpCallDataAndGasLimit(info);
+        const factoryParams = await this.getRequiredFactoryData();
+        const initGas = await this.estimateCreationGas(factoryParams);
+        const verificationGasLimit = BigInt(await this.getVerificationGasLimit()) + initGas;
+        let maxFeePerGas = info.maxFeePerGas;
+        let maxPriorityFeePerGas = info.maxPriorityFeePerGas;
+        if (maxFeePerGas == null || maxPriorityFeePerGas == null) {
+            const feeData = await this.provider.getFeeData();
+            maxFeePerGas ?? (maxFeePerGas = feeData.maxFeePerGas ?? undefined);
+            maxPriorityFeePerGas ?? (maxPriorityFeePerGas = feeData.maxPriorityFeePerGas ?? undefined);
+        }
+        if (maxFeePerGas == null || maxPriorityFeePerGas == null) {
+            throw new Error('could not resolve gas fees from provider; pass maxFeePerGas/maxPriorityFeePerGas explicitly');
+        }
+        let partialUserOp = {
+            sender: await this.getAccountAddress(),
+            nonce: info.nonce ?? (await this.getNonce()),
+            factory: factoryParams?.factory,
+            factoryData: factoryParams?.factoryData,
+            callData,
+            callGasLimit,
+            verificationGasLimit,
+            maxFeePerGas,
+            maxPriorityFeePerGas,
+            preVerificationGas: 60000,
+            signature: '',
+            authorizationList: [],
+        };
+        if (this.paymasterAPI != null) {
+            const pmFields = await this.paymasterAPI.getTemporaryPaymasterData();
+            if (pmFields != null) {
+                partialUserOp = {
+                    ...partialUserOp,
+                    paymaster: pmFields.paymaster,
+                    paymasterPostOpGasLimit: pmFields.paymasterPostOpGasLimit,
+                    paymasterVerificationGasLimit: pmFields.paymasterVerificationGasLimit,
+                    paymasterData: pmFields.paymasterData,
+                };
+            }
+        }
+        return partialUserOp;
+    }
+    /** Sign a filled userOp. */
+    async signUserOp(userOp) {
+        const userOpHash = await this.getUserOpHash(userOp);
+        const signature = await this.signUserOpHash(userOpHash);
+        return { ...userOp, signature };
+    }
+    /** Create and sign a UserOperation. */
+    async createSignedUserOp(info) {
+        return await this.signUserOp(await this.createUnsignedUserOp(info));
+    }
+}
+exports.BaseAccountAPI = BaseAccountAPI;

package/dist/src/accountAbstraction/Ed25519.d.ts

@@ -0,0 +1,47 @@
+import { BytesLike } from 'ethers';
+/** Raw Ed25519 signature components; both `r` and `s` are 32-byte 0x-hex strings. */
+export interface Ed25519Signature {
+    r: string;
+    s: string;
+}
+/** Async callback producing an Ed25519 signature over a 32-byte message (0x-hex). */
+export type Ed25519Signer = (message: string) => Promise<Ed25519Signature>;
+/** Pack an Ed25519 signature into the 64-byte format (abi.encode(bytes32[2])). */
+export declare function packRawEd25519Signature(sig: Ed25519Signature): string;
+/** Pack a Permit2-bound userOp signature: `r ‖ s ‖ permitHash` (96 bytes). */
+export declare function packPermitBoundUserOpSignature(sig: Ed25519Signature, permitHash: BytesLike): string;
+/** Pack a Permit2 inner signature (inside paymasterData): `r ‖ s ‖ userOpHash` (96 bytes). */
+export declare function packPermit2InnerSignature(sig: Ed25519Signature, userOpHash: BytesLike): string;
+/** Build the 64-byte binding `userOpHash ‖ permitHash` for the signer to sign. */
+export declare function buildPermitBinding(userOpHash: BytesLike, permitHash: BytesLike): string;
+/** Components a TonConnect wallet returns when it signs a binary payload. */
+export interface TonConnectSignedParts {
+    r: string;
+    s: string;
+    timestamp: number;
+    domain: string;
+    workchain: number;
+    addrHash: string;
+}
+/** Async signer that drives a TonConnect wallet; receives the 64-byte binding. */
+export type TonConnectSigner = (binding: string) => Promise<TonConnectSignedParts>;
+/**
+ * Pack `userOp.signature` for the TonConnect-wrapped variant:
+ *   abi.encode(r, s, timestamp, domain, workchain, addrHash, permitHash)
+ */
+export declare function packTonConnectUserOpSignature(parts: TonConnectSignedParts, permitHash?: BytesLike): string;
+/**
+ * Pack the Permit2 inner signature for the TonConnect-wrapped variant:
+ *   abi.encode(r, s, timestamp, domain, workchain, addrHash, userOpHash)
+ */
+export declare function packTonConnectPermit2InnerSignature(parts: TonConnectSignedParts, userOpHash: BytesLike): string;
+/**
+ * Build an {@link Ed25519Signer} from a raw 64-byte secret key + an Ed25519 impl.
+ * The SDK bundles no Ed25519 library; pass e.g. `@ton/crypto`'s `sign`:
+ *
+ * ```ts
+ * import { sign } from '@ton/crypto';
+ * const signer = ed25519SignerFromSecretKey(secretKey, (m, sk) => sign(Buffer.from(m), Buffer.from(sk)));
+ * ```
+ */
+export declare function ed25519SignerFromSecretKey(secretKey: Uint8Array, ed25519Sign: (message: Uint8Array, secretKey: Uint8Array) => Uint8Array): Ed25519Signer;

package/dist/src/accountAbstraction/Ed25519.js

@@ -0,0 +1,100 @@
+"use strict";
+// Ed25519 signature packers for TAC accounts. The on-chain account
+// (TacBaseAccount._validateUserOp) accepts THREE signature formats discriminated by length:
+//
+//   1. 64 bytes — abi.encode(bytes32[2]) = r||s. Verified directly over userOpHash.
+//   2. 96 bytes — r ++ s ++ permitHash. Verified over `userOpHash || permitHash`.
+//      One Ed25519 signature authorises both the UserOp and a Permit2 transfer.
+//   3. else — abi.encode(r, s, ts, domain, wc, addrHash, permitHash) (TonConnect envelope).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packRawEd25519Signature = packRawEd25519Signature;
+exports.packPermitBoundUserOpSignature = packPermitBoundUserOpSignature;
+exports.packPermit2InnerSignature = packPermit2InnerSignature;
+exports.buildPermitBinding = buildPermitBinding;
+exports.packTonConnectUserOpSignature = packTonConnectUserOpSignature;
+exports.packTonConnectPermit2InnerSignature = packTonConnectPermit2InnerSignature;
+exports.ed25519SignerFromSecretKey = ed25519SignerFromSecretKey;
+const ethers_1 = require("ethers");
+const abiCoder = ethers_1.AbiCoder.defaultAbiCoder();
+/** Pack an Ed25519 signature into the 64-byte format (abi.encode(bytes32[2])). */
+function packRawEd25519Signature(sig) {
+    return abiCoder.encode(['bytes32[2]'], [[(0, ethers_1.zeroPadValue)((0, ethers_1.hexlify)(sig.r), 32), (0, ethers_1.zeroPadValue)((0, ethers_1.hexlify)(sig.s), 32)]]);
+}
+/** Pack a Permit2-bound userOp signature: `r ‖ s ‖ permitHash` (96 bytes). */
+function packPermitBoundUserOpSignature(sig, permitHash) {
+    return (0, ethers_1.concat)([(0, ethers_1.zeroPadValue)((0, ethers_1.hexlify)(sig.r), 32), (0, ethers_1.zeroPadValue)((0, ethers_1.hexlify)(sig.s), 32), (0, ethers_1.zeroPadValue)((0, ethers_1.hexlify)(permitHash), 32)]);
+}
+/** Pack a Permit2 inner signature (inside paymasterData): `r ‖ s ‖ userOpHash` (96 bytes). */
+function packPermit2InnerSignature(sig, userOpHash) {
+    return (0, ethers_1.concat)([(0, ethers_1.zeroPadValue)((0, ethers_1.hexlify)(sig.r), 32), (0, ethers_1.zeroPadValue)((0, ethers_1.hexlify)(sig.s), 32), (0, ethers_1.zeroPadValue)((0, ethers_1.hexlify)(userOpHash), 32)]);
+}
+/** Build the 64-byte binding `userOpHash ‖ permitHash` for the signer to sign. */
+function buildPermitBinding(userOpHash, permitHash) {
+    return (0, ethers_1.concat)([(0, ethers_1.zeroPadValue)((0, ethers_1.hexlify)(userOpHash), 32), (0, ethers_1.zeroPadValue)((0, ethers_1.hexlify)(permitHash), 32)]);
+}
+const ZERO_HASH = '0x' + '00'.repeat(32);
+/**
+ * Pack `userOp.signature` for the TonConnect-wrapped variant:
+ *   abi.encode(r, s, timestamp, domain, workchain, addrHash, permitHash)
+ */
+function packTonConnectUserOpSignature(parts, permitHash = ZERO_HASH) {
+    return abiCoder.encode(['bytes32', 'bytes32', 'uint64', 'string', 'int32', 'bytes32', 'bytes32'], [
+        (0, ethers_1.zeroPadValue)((0, ethers_1.hexlify)(parts.r), 32),
+        (0, ethers_1.zeroPadValue)((0, ethers_1.hexlify)(parts.s), 32),
+        parts.timestamp,
+        parts.domain,
+        parts.workchain,
+        (0, ethers_1.zeroPadValue)((0, ethers_1.hexlify)(parts.addrHash), 32),
+        (0, ethers_1.zeroPadValue)((0, ethers_1.hexlify)(permitHash), 32),
+    ]);
+}
+/**
+ * Pack the Permit2 inner signature for the TonConnect-wrapped variant:
+ *   abi.encode(r, s, timestamp, domain, workchain, addrHash, userOpHash)
+ */
+function packTonConnectPermit2InnerSignature(parts, userOpHash) {
+    return abiCoder.encode(['bytes32', 'bytes32', 'uint64', 'string', 'int32', 'bytes32', 'bytes32'], [
+        (0, ethers_1.zeroPadValue)((0, ethers_1.hexlify)(parts.r), 32),
+        (0, ethers_1.zeroPadValue)((0, ethers_1.hexlify)(parts.s), 32),
+        parts.timestamp,
+        parts.domain,
+        parts.workchain,
+        (0, ethers_1.zeroPadValue)((0, ethers_1.hexlify)(parts.addrHash), 32),
+        (0, ethers_1.zeroPadValue)((0, ethers_1.hexlify)(userOpHash), 32),
+    ]);
+}
+/**
+ * Build an {@link Ed25519Signer} from a raw 64-byte secret key + an Ed25519 impl.
+ * The SDK bundles no Ed25519 library; pass e.g. `@ton/crypto`'s `sign`:
+ *
+ * ```ts
+ * import { sign } from '@ton/crypto';
+ * const signer = ed25519SignerFromSecretKey(secretKey, (m, sk) => sign(Buffer.from(m), Buffer.from(sk)));
+ * ```
+ */
+function ed25519SignerFromSecretKey(secretKey, ed25519Sign) {
+    return async (message) => {
+        const msgBytes = hexToBytes(message);
+        const sig = ed25519Sign(msgBytes, secretKey);
+        if (sig.length !== 64) {
+            throw new Error(`expected 64-byte Ed25519 signature, got ${sig.length}`);
+        }
+        return {
+            r: '0x' + bytesToHex(sig.slice(0, 32)),
+            s: '0x' + bytesToHex(sig.slice(32, 64)),
+        };
+    };
+}
+function hexToBytes(hex) {
+    const clean = hex.startsWith('0x') ? hex.slice(2) : hex;
+    const out = new Uint8Array(clean.length / 2);
+    for (let i = 0; i < out.length; i++)
+        out[i] = parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+    return out;
+}
+function bytesToHex(bytes) {
+    let s = '';
+    for (let i = 0; i < bytes.length; i++)
+        s += bytes[i].toString(16).padStart(2, '0');
+    return s;
+}

package/dist/src/accountAbstraction/HttpRpcClient.d.ts

@@ -0,0 +1,26 @@
+import { UserOperation } from './internal/userOp';
+/** Thin client for an ERC-4337 bundler's JSON-RPC endpoints. */
+export declare class HttpRpcClient {
+    readonly bundlerUrl: string;
+    readonly entryPointAddress: string;
+    readonly chainId: number;
+    private readonly userOpJsonRpcProvider;
+    initializing: Promise<void>;
+    constructor(bundlerUrl: string, entryPointAddress: string, chainId: number);
+    validateChainId(): Promise<void>;
+    /**
+     * Send a UserOperation to the bundler.
+     * @returns the userOpHash (id of this operation).
+     */
+    sendUserOpToBundler(userOp: UserOperation): Promise<string>;
+    /**
+     * Ask the bundler to estimate gas for a UserOperation.
+     */
+    estimateUserOpGas(userOp: Partial<UserOperation>): Promise<{
+        callGasLimit: number;
+        preVerificationGas: number;
+        verificationGasLimit: number;
+    }>;
+    /** Fetch the bundler's receipt for a UserOperation, or null if not yet mined. */
+    getUserOperationReceipt(userOpHash: string): Promise<unknown | null>;
+}

package/dist/src/accountAbstraction/HttpRpcClient.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpRpcClient = void 0;
+const ethers_1 = require("ethers");
+const userOp_1 = require("./internal/userOp");
+/** Thin client for an ERC-4337 bundler's JSON-RPC endpoints. */
+class HttpRpcClient {
+    constructor(bundlerUrl, entryPointAddress, chainId) {
+        this.bundlerUrl = bundlerUrl;
+        this.entryPointAddress = entryPointAddress;
+        this.chainId = chainId;
+        this.userOpJsonRpcProvider = new ethers_1.JsonRpcProvider(this.bundlerUrl);
+        this.initializing = this.validateChainId();
+    }
+    async validateChainId() {
+        const chain = await this.userOpJsonRpcProvider.send('eth_chainId', []);
+        const bundlerChain = parseInt(chain);
+        if (bundlerChain !== this.chainId) {
+            throw new Error(`bundler ${this.bundlerUrl} is on chainId ${bundlerChain}, but the client expects ${this.chainId}`);
+        }
+    }
+    /**
+     * Send a UserOperation to the bundler.
+     * @returns the userOpHash (id of this operation).
+     */
+    async sendUserOpToBundler(userOp) {
+        await this.initializing;
+        const hexifiedUserOp = (0, userOp_1.deepHexlify)(await (0, ethers_1.resolveProperties)(userOp));
+        return await this.userOpJsonRpcProvider.send('eth_sendUserOperation', [hexifiedUserOp, this.entryPointAddress]);
+    }
+    /**
+     * Ask the bundler to estimate gas for a UserOperation.
+     */
+    async estimateUserOpGas(userOp) {
+        await this.initializing;
+        const hexifiedUserOp = (0, userOp_1.deepHexlify)(userOp);
+        return await this.userOpJsonRpcProvider.send('eth_estimateUserOperationGas', [hexifiedUserOp, this.entryPointAddress]);
+    }
+    /** Fetch the bundler's receipt for a UserOperation, or null if not yet mined. */
+    async getUserOperationReceipt(userOpHash) {
+        await this.initializing;
+        return await this.userOpJsonRpcProvider.send('eth_getUserOperationReceipt', [userOpHash]);
+    }
+}
+exports.HttpRpcClient = HttpRpcClient;

package/dist/src/accountAbstraction/PaymasterAPI.d.ts

@@ -0,0 +1,21 @@
+import { BigNumberish, BytesLike } from 'ethers';
+/**
+ * Returned paymaster parameters. If a paymaster is specified, the gas limits must be
+ * specified too (even if postOp is not called, paymasterPostOpGasLimit must be set).
+ */
+export interface PaymasterParams {
+    paymaster: string;
+    paymasterData?: BytesLike;
+    paymasterVerificationGasLimit: BigNumberish;
+    paymasterPostOpGasLimit: BigNumberish;
+}
+/**
+ * An API to fill a UserOperation with paymaster info. Subclass and override to implement a
+ * specific paymaster (see {@link TacERC20PaymasterAPI}).
+ */
+export declare class PaymasterAPI {
+    /** Temporary values to put into the paymaster fields (used for gas estimation). */
+    getTemporaryPaymasterData(): Promise<PaymasterParams | null>;
+    /** Final paymaster parameters (after gas estimation). */
+    getPaymasterData(): Promise<PaymasterParams | null>;
+}

package/dist/src/accountAbstraction/PaymasterAPI.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymasterAPI = void 0;
+/**
+ * An API to fill a UserOperation with paymaster info. Subclass and override to implement a
+ * specific paymaster (see {@link TacERC20PaymasterAPI}).
+ */
+class PaymasterAPI {
+    /** Temporary values to put into the paymaster fields (used for gas estimation). */
+    async getTemporaryPaymasterData() {
+        return await this.getPaymasterData();
+    }
+    /** Final paymaster parameters (after gas estimation). */
+    async getPaymasterData() {
+        return null;
+    }
+}
+exports.PaymasterAPI = PaymasterAPI;

package/dist/src/accountAbstraction/Permit2.d.ts

@@ -0,0 +1,37 @@
+import { BigNumberish } from 'ethers';
+export interface Permit2TokenPermission {
+    token: string;
+    amount: BigNumberish;
+}
+export interface PermitBatchTransferFromInput {
+    permitted: Permit2TokenPermission[];
+    /** Unique per-permit nonce (Permit2 replay protection). */
+    nonce: BigNumberish;
+    /** Deadline in unix seconds. Use `ethers.MaxUint256` for no expiry. */
+    deadline: BigNumberish;
+    /** Chain id this permit is bound to. */
+    chainId: BigNumberish;
+    /** Address of the deployed `TacPermit2` (the verifyingContract). */
+    verifyingContract: string;
+}
+/** Internal packed representation matching the contract's tuple layout. */
+export type PermitBatchTransferFromTuple = [
+    Array<[string, BigNumberish]>,
+    BigNumberish,
+    BigNumberish,
+    BigNumberish,
+    string
+];
+/** Build the TAC `PermitBatchTransferFrom` tuple, its abi-encoded message, and hash. */
+export declare function buildPermitMessage(input: PermitBatchTransferFromInput): {
+    permit: PermitBatchTransferFromTuple;
+    messageHex: string;
+    permitHash: string;
+};
+/**
+ * Wrap a permit tuple + signature blob into the `(permit, signature)` abi-encoded payload
+ * that `TacERC20Paymaster._parsePermitData` consumes.
+ */
+export declare function packPermitData(permit: PermitBatchTransferFromTuple, signatureBlob: string): string;
+/** Convenience: full `paymasterData` for Mode 1 = `0x01 ‖ abi.encode(permit, signatureBlob)`. */
+export declare function packPermitPaymasterData(permit: PermitBatchTransferFromTuple, signatureBlob: string): string;

package/dist/src/accountAbstraction/Permit2.js

@@ -0,0 +1,41 @@
+"use strict";
+// Permit2 helpers — build TAC's `PermitBatchTransferFrom` struct, compute its hash,
+// and pack it into paymasterData.
+//
+// TAC's PermitBatchTransferFrom is a tuple matching ISignatureTransfer, with two extra
+// TAC fields (chainId, verifyingContract=TacPermit2):
+//   tuple(tuple(address token,uint256 amount)[], uint256 nonce, uint256 deadline, uint256 chainId, address verifyingContract)
+//
+// permitHash = keccak256(abi.encode(permit)) — the same value `keccak256(message)` equals
+// when TacPermit2 calls account.isValidSignature(message, signature).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPermitMessage = buildPermitMessage;
+exports.packPermitData = packPermitData;
+exports.packPermitPaymasterData = packPermitPaymasterData;
+const ethers_1 = require("ethers");
+const abiCoder = ethers_1.AbiCoder.defaultAbiCoder();
+const PERMIT_TUPLE_TYPE = 'tuple(tuple(address,uint256)[],uint256,uint256,uint256,address)';
+/** Build the TAC `PermitBatchTransferFrom` tuple, its abi-encoded message, and hash. */
+function buildPermitMessage(input) {
+    const permit = [
+        input.permitted.map((p) => [p.token, p.amount]),
+        input.nonce,
+        input.deadline,
+        input.chainId,
+        input.verifyingContract,
+    ];
+    const messageHex = abiCoder.encode([PERMIT_TUPLE_TYPE], [permit]);
+    const permitHash = (0, ethers_1.keccak256)(messageHex);
+    return { permit, messageHex, permitHash };
+}
+/**
+ * Wrap a permit tuple + signature blob into the `(permit, signature)` abi-encoded payload
+ * that `TacERC20Paymaster._parsePermitData` consumes.
+ */
+function packPermitData(permit, signatureBlob) {
+    return abiCoder.encode([PERMIT_TUPLE_TYPE, 'bytes'], [permit, signatureBlob]);
+}
+/** Convenience: full `paymasterData` for Mode 1 = `0x01 ‖ abi.encode(permit, signatureBlob)`. */
+function packPermitPaymasterData(permit, signatureBlob) {
+    return (0, ethers_1.concat)(['0x01', packPermitData(permit, signatureBlob)]);
+}

package/dist/src/accountAbstraction/PermitFlow.d.ts

@@ -0,0 +1,43 @@
+import { BigNumberish } from 'ethers';
+import { Ed25519Signer, TonConnectSigner } from './Ed25519';
+import { UserOperation } from './internal/userOp';
+import { PermitBatchTransferFromInput } from './Permit2';
+import { TacAccountAPI } from './TacAccountAPI';
+import { TransactionDetailsForUserOp } from './TransactionDetailsForUserOp';
+/**
+ * Inputs to {@link buildSignedUserOpWithPermit}.
+ *
+ * @param accountAPI  the TacAccountAPI driving sender/factory/callData/nonce. Should NOT have
+ *                    a paymasterAPI configured — this helper owns paymasterData.
+ * @param paymaster   TacERC20Paymaster contract address.
+ * @param permitInput the permit struct to authorise (permitted[].amount caps the gas budget).
+ * @param ed25519Signer invoked twice (once per round) with a 64-byte binding.
+ * @param txDetails   execution target/value/data for the UserOp.
+ */
+export interface BuildPermitUserOpInput {
+    accountAPI: TacAccountAPI;
+    paymaster: string;
+    paymasterVerificationGasLimit?: BigNumberish;
+    paymasterPostOpGasLimit?: BigNumberish;
+    permitInput: PermitBatchTransferFromInput;
+    ed25519Signer: Ed25519Signer;
+    txDetails: TransactionDetailsForUserOp;
+}
+/** TonConnect-wallet variant inputs. */
+export interface BuildPermitUserOpInputTonConnect {
+    accountAPI: TacAccountAPI;
+    paymaster: string;
+    paymasterVerificationGasLimit?: BigNumberish;
+    paymasterPostOpGasLimit?: BigNumberish;
+    permitInput: PermitBatchTransferFromInput;
+    tonConnectSigner: TonConnectSigner;
+    txDetails: TransactionDetailsForUserOp;
+}
+/**
+ * Build a fully-signed UserOp paying gas via TacERC20Paymaster's TRANSFER_VIA_PERMIT mode.
+ * Performs the two-round double-sign; the EntryPoint (for userOpHash) is derived from the
+ * accountAPI's entryPointAddress + provider.
+ */
+export declare function buildSignedUserOpWithPermit(input: BuildPermitUserOpInput): Promise<UserOperation>;
+/** TonConnect-wallet variant of {@link buildSignedUserOpWithPermit}. */
+export declare function buildSignedUserOpWithPermitTonConnect(input: BuildPermitUserOpInputTonConnect): Promise<UserOperation>;