gokite-aa-sdk 1.0.0

package/dist/gokite-aa-sdk.d.ts

@@ -0,0 +1,70 @@
+import { UserOperation, UserOperationRequest, BatchUserOperationRequest, UserOperationGasEstimate, UserOperationStatus, SignFunction, PollingOptions } from './types';
+/**
+ * Main Gokite AA SDK class
+ */
+export declare class GokiteAASDK {
+    private config;
+    private provider;
+    private ethersProvider;
+    constructor(network: string, rpcUrl: string, bundlerUrl?: string);
+    /**
+     * Calculate account address for a given owner and salt
+     */
+    getAccountAddress(owner: string, salt?: bigint): string;
+    /**
+     * Get account nonce
+     */
+    getAccountNonce(accountAddress: string): Promise<bigint>;
+    /**
+     * Get user operation hash from EntryPoint contract
+     */
+    getUserOpHash(userOp: any): Promise<string>;
+    /**
+     * Check if account is deployed
+     */
+    isAccountDeloyed(accountAddress: string): Promise<boolean>;
+    /**
+     * Build init code for account creation
+     */
+    buildInitCode(owner: string, salt: bigint): string;
+    /**
+     * Build call data for single transaction
+     */
+    buildCallData(request: UserOperationRequest): string;
+    /**
+     * Build call data for batch transactions
+     */
+    buildBatchCallData(request: BatchUserOperationRequest): string;
+    /**
+     * Create user operation
+     */
+    createUserOperation(owner: string, request: UserOperationRequest | BatchUserOperationRequest, salt?: bigint, paymasterAddress?: string): Promise<Partial<UserOperation>>;
+    /**
+     * Estimate gas for user operation
+     */
+    estimateGas(userOp: Partial<UserOperation>): Promise<UserOperationGasEstimate>;
+    /**
+     * Sign and send user operation
+     */
+    sendUserOperation(owner: string, request: UserOperationRequest | BatchUserOperationRequest, signFn: SignFunction, salt?: bigint, paymasterAddress?: string): Promise<string>;
+    /**
+     * Send user operation directly to EntryPoint contract (bypassing bundler)
+     * Note: This requires a signer to pay for gas. For now, we'll try with the read-only provider.
+     */
+    sendUserOperationDirectly(owner: string, userOp: UserOperation): Promise<string>;
+    /**
+     * Get user operation status
+     */
+    getUserOperationStatus(userOpHash: string): Promise<UserOperationStatus>;
+    /**
+     * Enhanced polling for user operation status with detailed result parsing
+     */
+    pollUserOperationStatus(userOpHash: string, options?: PollingOptions): Promise<UserOperationStatus>;
+    /**
+     * Send user operation and wait for completion with detailed status
+     */
+    sendUserOperationAndWait(owner: string, request: UserOperationRequest | BatchUserOperationRequest, signFn: SignFunction, salt?: bigint, paymasterAddress?: string, pollingOptions?: PollingOptions): Promise<{
+        userOpHash: string;
+        status: UserOperationStatus;
+    }>;
+}

package/dist/gokite-aa-sdk.js

@@ -0,0 +1,428 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GokiteAASDK = void 0;
+const ethers_1 = require("ethers");
+const types_1 = require("./types");
+const config_1 = require("./config");
+const utils_1 = require("./utils");
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+// Error classification helper
+function classifyError(error, context) {
+    // Network/fetch errors
+    if (error.name === 'TypeError' || error.message?.includes('fetch')) {
+        return {
+            type: 'NETWORK_ERROR',
+            message: `Network error during ${context}: ${error.message}`,
+            details: error
+        };
+    }
+    // Bundler RPC errors
+    if (error.code) {
+        const errorType = context.includes('estimate') ? 'ESTIMATE_GAS_FAILED' : 'SEND_USEROP_FAILED';
+        let specificType = errorType;
+        // Common error codes mapping
+        if (error.code === -32602 || error.message?.includes('insufficient funds')) {
+            specificType = 'INSUFFICIENT_FUNDS';
+        }
+        else if (error.code === -32602 || error.message?.includes('signature')) {
+            specificType = 'INVALID_SIGNATURE';
+        }
+        else if (error.code < 0) {
+            specificType = 'BUNDLER_ERROR';
+        }
+        return {
+            type: specificType,
+            message: error.message || `${context} failed`,
+            code: error.code,
+            details: error
+        };
+    }
+    // Generic error
+    return {
+        type: 'UNKNOWN_ERROR',
+        message: error.message || `Unknown error during ${context}`,
+        details: error
+    };
+}
+class BundlerProvider {
+    constructor(bundlerUrl) {
+        this.bundlerUrl = bundlerUrl;
+    }
+    async estimateUserOperationGas(userOp, entryPoint) {
+        try {
+            const response = await fetch(this.bundlerUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    jsonrpc: '2.0',
+                    id: Date.now(),
+                    method: 'eth_estimateUserOperationGas',
+                    params: [(0, utils_1.serializeUserOperation)(userOp), entryPoint]
+                })
+            });
+            const result = await response.json();
+            if (result.error) {
+                throw new types_1.AASDKError(classifyError(result.error, 'estimate gas'));
+            }
+            if (!result.result) {
+                throw new types_1.AASDKError({
+                    type: 'ESTIMATE_GAS_FAILED',
+                    message: 'No gas estimate result returned from bundler'
+                });
+            }
+            return {
+                callGasLimit: BigInt(result.result.callGasLimit),
+                verificationGasLimit: BigInt(result.result.verificationGasLimit),
+                preVerificationGas: BigInt(result.result.preVerificationGas),
+                maxFeePerGas: BigInt(result.result.maxFeePerGas || 1000000000n),
+                maxPriorityFeePerGas: BigInt(result.result.maxPriorityFeePerGas || 1000000000n), // 1 gwei
+            };
+        }
+        catch (error) {
+            if (error instanceof types_1.AASDKError)
+                throw error;
+            throw new types_1.AASDKError(classifyError(error, 'estimate gas'));
+        }
+    }
+    async sendUserOperation(userOp, entryPoint) {
+        try {
+            const serializedUserOp = (0, utils_1.serializeUserOperation)(userOp);
+            console.log('Sending UserOp to bundler:', JSON.stringify(serializedUserOp, null, 2));
+            const response = await fetch(this.bundlerUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    jsonrpc: '2.0',
+                    id: Date.now(),
+                    method: 'eth_sendUserOperation',
+                    params: [serializedUserOp, entryPoint]
+                })
+            });
+            const result = await response.json();
+            if (result.error) {
+                throw new types_1.AASDKError(classifyError(result.error, 'send user operation'));
+            }
+            if (!result.result) {
+                throw new types_1.AASDKError({
+                    type: 'SEND_USEROP_FAILED',
+                    message: 'No user operation hash returned from bundler'
+                });
+            }
+            return result.result;
+        }
+        catch (error) {
+            if (error instanceof types_1.AASDKError)
+                throw error;
+            throw new types_1.AASDKError(classifyError(error, 'send user operation'));
+        }
+    }
+    async getUserOperationStatus(userOpHash) {
+        const response = await fetch(this.bundlerUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: Date.now(),
+                method: 'eth_getUserOperationReceipt',
+                params: [userOpHash]
+            })
+        });
+        const result = await response.json();
+        // If error or no result, operation is still pending
+        if (result.error || !result.result) {
+            return { userOpHash, status: 'pending' };
+        }
+        const receipt = result.result;
+        // Determine status based on success field
+        let status;
+        if (receipt.success) {
+            status = 'success';
+        }
+        else {
+            status = 'reverted';
+        }
+        return {
+            userOpHash,
+            status,
+            transactionHash: receipt.receipt.transactionHash,
+            blockNumber: parseInt(receipt.receipt.blockNumber, 16),
+            gasUsed: receipt.receipt.gasUsed,
+            actualGasCost: receipt.actualGasCost,
+            reason: receipt.reason,
+            receipt
+        };
+    }
+    async getUserOperationByHash(userOpHash) {
+        const response = await fetch(this.bundlerUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: Date.now(),
+                method: 'eth_getUserOperationByHash',
+                params: [userOpHash]
+            })
+        });
+        const result = await response.json();
+        return result.result || null;
+    }
+}
+/**
+ * Main Gokite AA SDK class
+ */
+class GokiteAASDK {
+    constructor(network, rpcUrl, bundlerUrl) {
+        this.config = config_1.NETWORKS[network];
+        if (!this.config) {
+            throw new Error(`Unsupported network: ${network}`);
+        }
+        this.ethersProvider = new ethers_1.ethers.JsonRpcProvider(rpcUrl);
+        if (bundlerUrl) {
+            this.provider = new BundlerProvider(bundlerUrl);
+        }
+        else {
+            throw new Error('Bundler URL is required');
+        }
+    }
+    /**
+     * Calculate account address for a given owner and salt
+     */
+    getAccountAddress(owner, salt) {
+        const actualSalt = salt || (0, utils_1.generateSalt)();
+        return (0, utils_1.getAccountAddress)(this.config.accountFactory, this.config.accountImplementation, owner, actualSalt);
+    }
+    /**
+     * Get account nonce
+     */
+    async getAccountNonce(accountAddress) {
+        const entryPoint = new ethers_1.ethers.Contract(this.config.entryPoint, ['function getNonce(address,uint192) view returns (uint256)'], this.ethersProvider);
+        return await entryPoint.getNonce(accountAddress, 0);
+    }
+    /**
+     * Get user operation hash from EntryPoint contract
+     */
+    async getUserOpHash(userOp) {
+        const entryPoint = new ethers_1.ethers.Contract(this.config.entryPoint, ['function getUserOpHash((address,uint256,bytes,bytes,bytes32,uint256,bytes32,bytes,bytes)) view returns (bytes32)'], this.ethersProvider);
+        // Convert userOp to the format expected by the contract - ensure proper types
+        const packedUserOp = [
+            userOp.sender,
+            userOp.nonce,
+            userOp.initCode,
+            userOp.callData,
+            userOp.accountGasLimits,
+            userOp.preVerificationGas,
+            userOp.gasFees,
+            userOp.paymasterAndData,
+            '0x' // signature (empty for hash calculation)
+        ];
+        console.log('getUserOpHash packedUserOp:', packedUserOp);
+        const hash = await entryPoint.getUserOpHash(packedUserOp);
+        console.log('Raw hash from contract:', hash);
+        return hash;
+    }
+    /**
+     * Check if account is deployed
+     */
+    async isAccountDeloyed(accountAddress) {
+        const code = await this.ethersProvider.getCode(accountAddress);
+        return code !== '0x';
+    }
+    /**
+     * Build init code for account creation
+     */
+    buildInitCode(owner, salt) {
+        const initCallData = (0, utils_1.encodeFunctionCall)(['function createAccount(address,uint256) returns (address)'], 'createAccount', [owner, salt]);
+        return this.config.accountFactory + initCallData.slice(2);
+    }
+    /**
+     * Build call data for single transaction
+     */
+    buildCallData(request) {
+        return (0, utils_1.encodeFunctionCall)(['function execute(address,uint256,bytes)'], 'execute', [request.target, request.value || 0n, request.callData]);
+    }
+    /**
+     * Build call data for batch transactions
+     */
+    buildBatchCallData(request) {
+        const values = request.values || new Array(request.targets.length).fill(0n);
+        return (0, utils_1.encodeFunctionCall)(['function executeBatch(address[],uint256[],bytes[])'], 'executeBatch', [request.targets, values, request.callDatas]);
+    }
+    /**
+     * Create user operation
+     */
+    async createUserOperation(owner, request, salt, paymasterAddress) {
+        const actualSalt = salt || (0, utils_1.generateSalt)();
+        const accountAddress = this.getAccountAddress(owner, actualSalt);
+        const isDeployed = await this.isAccountDeloyed(accountAddress);
+        const callData = 'targets' in request
+            ? this.buildBatchCallData(request)
+            : this.buildCallData(request);
+        // Gas settings (matching Go implementation)
+        const callGasLimit = BigInt(300000);
+        const verificationGasLimit = BigInt(300000);
+        const preVerificationGas = BigInt(1000000);
+        const maxFeePerGas = BigInt(10000000); // 0.001 gwei
+        const maxPriorityFeePerGas = BigInt(1); // 1 wei
+        // Pack gas limits and fees (note: verificationGasLimit first, callGasLimit second)
+        const accountGasLimits = (0, utils_1.packAccountGasLimits)(verificationGasLimit, callGasLimit);
+        const gasFees = (0, utils_1.packAccountGasLimits)(maxPriorityFeePerGas, maxFeePerGas);
+        if (!paymasterAddress) {
+            paymasterAddress = this.config.paymaster;
+        }
+        // Pack paymaster data (paymasterAddress, paymasterVerificationGasLimit, postOpGasLimit, paymasterData) 
+        const paymasterAndData = paymasterAddress
+            ? (0, utils_1.packPaymasterAndData)(paymasterAddress, BigInt(100000), BigInt(100000), '0x')
+            : '0x';
+        return {
+            sender: accountAddress,
+            nonce: await this.getAccountNonce(accountAddress),
+            initCode: isDeployed ? '0x' : this.buildInitCode(owner, actualSalt),
+            callData,
+            accountGasLimits,
+            preVerificationGas,
+            gasFees,
+            paymasterAndData,
+            signature: '0x', // Will be set later
+        };
+    }
+    /**
+     * Estimate gas for user operation
+     */
+    async estimateGas(userOp) {
+        // Create a version with dummy signature for estimation
+        const userOpForEstimation = (0, utils_1.createUserOpForEstimation)(userOp);
+        return await this.provider.estimateUserOperationGas(userOpForEstimation, this.config.entryPoint);
+    }
+    /**
+     * Sign and send user operation
+     */
+    async sendUserOperation(owner, request, signFn, salt, paymasterAddress) {
+        // Create user operation
+        const userOp = await this.createUserOperation(owner, request, salt, paymasterAddress);
+        // Add dummy signature for gas estimation
+        const userOpWithDummy = (0, utils_1.createUserOpForEstimation)(userOp);
+        // Estimate gas using bundler
+        const gasEstimate = await this.provider.estimateUserOperationGas(userOpWithDummy, this.config.entryPoint);
+        console.log('gasEstimate:', gasEstimate);
+        // Update gas fields in packed format (verificationGasLimit first, callGasLimit second)
+        userOp.accountGasLimits = (0, utils_1.packAccountGasLimits)(gasEstimate.verificationGasLimit, gasEstimate.callGasLimit);
+        userOp.preVerificationGas = gasEstimate.preVerificationGas;
+        const userOpHash = await this.getUserOpHash(userOp);
+        // Sign user operation
+        const signature = await signFn(userOpHash);
+        userOp.signature = signature;
+        // // Send user operation directly to EntryPoint contract (bypassing bundler)
+        // return await this.sendUserOperationDirectly(owner, userOp as UserOperation);
+        return await this.provider.sendUserOperation(userOp, this.config.entryPoint);
+    }
+    /**
+     * Send user operation directly to EntryPoint contract (bypassing bundler)
+     * Note: This requires a signer to pay for gas. For now, we'll try with the read-only provider.
+     */
+    async sendUserOperationDirectly(owner, userOp) {
+        // TODO: We need a signer here to pay for gas
+        // For now, let's see what error we get with the read-only provider
+        const entryPoint = new ethers_1.ethers.Contract(this.config.entryPoint, [
+            'function handleOps((address,uint256,bytes,bytes,bytes32,uint256,bytes32,bytes,bytes)[] calldata ops, address payable beneficiary) external'
+        ], this.ethersProvider);
+        // Convert userOp to the format expected by the contract
+        const packedUserOp = [
+            userOp.sender,
+            userOp.nonce,
+            userOp.initCode,
+            userOp.callData,
+            userOp.accountGasLimits,
+            userOp.preVerificationGas,
+            userOp.gasFees,
+            userOp.paymasterAndData,
+            userOp.signature
+        ];
+        // Create operations array (only one operation)
+        const ops = [packedUserOp];
+        // Set beneficiary (use owner address)
+        const beneficiary = owner;
+        console.log('Calling EntryPoint.handleOps directly...');
+        console.log('ops:', ops);
+        console.log('beneficiary:', beneficiary);
+        const signer_pk = process.env.PRIVATE_KEY;
+        const signer = new ethers_1.ethers.Wallet(signer_pk, this.ethersProvider);
+        console.log('signer:', signer.address);
+        try {
+            // Call handleOps on EntryPoint contract
+            const tx = await entryPoint.connect(signer).handleOps(ops, beneficiary, {
+                gasLimit: 1000000,
+            });
+            console.log('Transaction sent:', tx.hash);
+            // Wait for transaction confirmation
+            const receipt = await tx.wait();
+            console.log('Transaction confirmed:', receipt.hash);
+            return tx.hash;
+        }
+        catch (error) {
+            console.error('EntryPoint.handleOps failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get user operation status
+     */
+    async getUserOperationStatus(userOpHash) {
+        return await this.provider.getUserOperationStatus(userOpHash);
+    }
+    /**
+     * Enhanced polling for user operation status with detailed result parsing
+     */
+    async pollUserOperationStatus(userOpHash, options = {}) {
+        const { interval = 2000, timeout = 60000, maxRetries = 30 } = options;
+        const startTime = Date.now();
+        let retryCount = 0;
+        while (Date.now() - startTime < timeout && retryCount < maxRetries) {
+            try {
+                const status = await this.getUserOperationStatus(userOpHash);
+                // Check if operation is completed (either success or failed)
+                if (status.status === 'success' || status.status === 'reverted' || status.status === 'failed') {
+                    console.log(`UserOp completed:`, {
+                        status: status.status,
+                        transactionHash: status.transactionHash,
+                        gasUsed: status.gasUsed,
+                        actualGasCost: status.actualGasCost,
+                        reason: status.reason
+                    });
+                    return status;
+                }
+                retryCount++;
+                if (retryCount < maxRetries) {
+                    await new Promise(resolve => setTimeout(resolve, interval));
+                }
+            }
+            catch (error) {
+                console.error(`polling error (attempt ${retryCount + 1}):`, error);
+                retryCount++;
+                if (retryCount < maxRetries) {
+                    await new Promise(resolve => setTimeout(resolve, interval));
+                }
+            }
+        }
+        throw new Error(`UserOp polling timeout: ${userOpHash} (attempt ${retryCount})`);
+    }
+    /**
+     * Send user operation and wait for completion with detailed status
+     */
+    async sendUserOperationAndWait(owner, request, signFn, salt, paymasterAddress, pollingOptions) {
+        console.log('Sending UserOp and waiting for completion...');
+        // Step 1: Send user operation
+        const userOpHash = await this.sendUserOperation(owner, request, signFn, salt, paymasterAddress);
+        console.log(`UserOp sent: ${userOpHash}`);
+        // Step 2: Poll for status until completion
+        const status = await this.pollUserOperationStatus(userOpHash, pollingOptions);
+        return {
+            userOpHash,
+            status
+        };
+    }
+}
+exports.GokiteAASDK = GokiteAASDK;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { GokiteAASDK } from './gokite-aa-sdk';
+export * from './types';
+export * from './config';
+export * from './utils';

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GokiteAASDK = void 0;
+// Gokite AA SDK - Entry point
+var gokite_aa_sdk_1 = require("./gokite-aa-sdk");
+Object.defineProperty(exports, "GokiteAASDK", { enumerable: true, get: function () { return gokite_aa_sdk_1.GokiteAASDK; } });
+__exportStar(require("./types"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./utils"), exports);

package/dist/types.d.ts

@@ -0,0 +1,95 @@
+export interface UserOperation {
+    sender: string;
+    nonce: bigint;
+    initCode: string;
+    callData: string;
+    accountGasLimits: string;
+    preVerificationGas: bigint;
+    gasFees: string;
+    paymasterAndData: string;
+    signature: string;
+}
+export interface UserOperationGasEstimate {
+    callGasLimit: bigint;
+    verificationGasLimit: bigint;
+    preVerificationGas: bigint;
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+}
+export interface UserOperationRequest {
+    target: string;
+    value?: bigint;
+    callData: string;
+}
+export interface BatchUserOperationRequest {
+    targets: string[];
+    values?: bigint[];
+    callDatas: string[];
+}
+export interface UserOperationStatus {
+    userOpHash: string;
+    status: 'pending' | 'included' | 'failed' | 'success' | 'reverted';
+    transactionHash?: string;
+    blockNumber?: number;
+    gasUsed?: string;
+    actualGasCost?: string;
+    reason?: string;
+    receipt?: UserOperationReceipt;
+}
+export interface PollingOptions {
+    interval?: number;
+    timeout?: number;
+    maxRetries?: number;
+}
+export interface AAError {
+    type: 'ESTIMATE_GAS_FAILED' | 'SEND_USEROP_FAILED' | 'INSUFFICIENT_FUNDS' | 'INVALID_SIGNATURE' | 'BUNDLER_ERROR' | 'NETWORK_ERROR' | 'UNKNOWN_ERROR';
+    message: string;
+    code?: number;
+    details?: any;
+}
+export declare class AASDKError extends Error {
+    readonly type: AAError['type'];
+    readonly code?: number;
+    readonly details?: any;
+    constructor(error: AAError);
+}
+export interface SignFunction {
+    (userOpHash: string): Promise<string>;
+}
+export interface AAProvider {
+    estimateUserOperationGas(userOp: Partial<UserOperation>, entryPoint: string): Promise<UserOperationGasEstimate>;
+    sendUserOperation(userOp: UserOperation, entryPoint: string): Promise<string>;
+    getUserOperationStatus(userOpHash: string): Promise<UserOperationStatus>;
+    getUserOperationByHash(userOpHash: string): Promise<UserOperation | null>;
+}
+export interface BundlerResponse<T = any> {
+    jsonrpc: string;
+    id: number;
+    result?: T;
+    error?: {
+        code: number;
+        message: string;
+    };
+}
+export interface GasEstimateResult {
+    callGasLimit: string;
+    verificationGasLimit: string;
+    preVerificationGas: string;
+    maxFeePerGas?: string;
+    maxPriorityFeePerGas?: string;
+}
+export interface UserOperationReceipt {
+    userOpHash: string;
+    sender: string;
+    nonce: string;
+    actualGasCost: string;
+    actualGasUsed: string;
+    success: boolean;
+    receipt: {
+        transactionHash: string;
+        blockNumber: string;
+        gasUsed: string;
+        logs: any[];
+    };
+    reason?: string;
+}

package/dist/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AASDKError = void 0;
+class AASDKError extends Error {
+    constructor(error) {
+        super(error.message);
+        this.name = 'AASDKError';
+        this.type = error.type;
+        this.code = error.code;
+        this.details = error.details;
+    }
+}
+exports.AASDKError = AASDKError;

package/dist/utils.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Calculate the counterfactual address of a GokiteAccount
+ * This matches the logic in GokiteAccountFactory.getAddress()
+ */
+export declare function getAccountAddress(factoryAddress: string, implementationAddress: string, owner: string, salt: bigint): string;
+/**
+ * Encode function call data
+ */
+export declare function encodeFunctionCall(abi: string[], functionName: string, params: any[]): string;
+/**
+ * Pack user operation for hashing
+ */
+export declare function packUserOperation(userOp: any): string;
+/**
+ * Pack account gas limits into 32 bytes
+ * @param verificationGasLimit Verification gas limit (16 bytes, first half)
+ * @param callGasLimit Call gas limit (16 bytes, second half)
+ * @returns 32 bytes packed data as hex string
+ */
+export declare function packAccountGasLimits(verificationGasLimit: bigint, callGasLimit: bigint): string;
+/**
+ * Pack paymaster and data
+ * @param paymasterAddress Paymaster contract address (20 bytes)
+ * @param paymasterVerificationGasLimit Paymaster verification gas limit (16 bytes)
+ * @param postOpGasLimit Post operation gas limit (16 bytes)
+ * @param paymasterData Additional paymaster data (variable length)
+ * @returns Packed paymaster and data as hex string
+ */
+export declare function packPaymasterAndData(paymasterAddress: string, paymasterVerificationGasLimit: bigint, postOpGasLimit: bigint, paymasterData?: string): string;
+/**
+ * Get user operation hash
+ */
+export declare function getUserOperationHash(userOp: any, entryPointAddress: string, chainId: number): string;
+/**
+ * Convert bigint values to hex strings for JSON serialization
+ * Also unpacks PackedUserOperation format to legacy format for bundler compatibility
+ */
+export declare function serializeUserOperation(userOp: any): any;
+export declare function generateSalt(): bigint;
+/**
+ * Generate a dummy signature for gas estimation
+ * The signature needs to be the correct length but doesn't need to be valid
+ * Using a format that won't cause ECDSA.recover to revert
+ */
+export declare function generateDummySignature(): string;
+/**
+ * Create a user operation with dummy signature for gas estimation
+ */
+export declare function createUserOpForEstimation(userOp: any): any;