@tonappchain/sdk 0.7.0-rc16 → 0.7.0-rc19

package/dist/src/agnosticSdk/AgnosticSdk.js

@@ -0,0 +1,736 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgnosticProxySDK = exports.ReplacementType = exports.HookType = void 0;
+const ethers_1 = require("ethers");
+const mainnet_1 = require("../../artifacts/mainnet");
+const testnet_1 = require("../../artifacts/testnet");
+const Struct_1 = require("../structs/Struct");
+/**
+ * HookType is an enum that contains the type of the hook
+ * @param Custom - The custom hook
+ * @param FullBalanceApprove - The full balance approve hook
+ * @param FullBalanceTransfer - The full balance transfer hook
+ */
+var HookType;
+(function (HookType) {
+    HookType[HookType["Custom"] = 0] = "Custom";
+    HookType[HookType["FullBalanceApprove"] = 1] = "FullBalanceApprove";
+    HookType[HookType["FullBalanceTransfer"] = 2] = "FullBalanceTransfer";
+})(HookType || (exports.HookType = HookType = {}));
+/**
+ * ReplacementType is an enum that contains the type of the replacement
+ * @param Amount - The amount replacement
+ */
+var ReplacementType;
+(function (ReplacementType) {
+    ReplacementType[ReplacementType["Amount"] = 0] = "Amount";
+})(ReplacementType || (exports.ReplacementType = ReplacementType = {}));
+/**
+ * SDK for building AgnosticProxy Zap calls with efficient hook encoding
+ * @param agnosticProxyAddress - The address of the agnostic proxy(optional)
+ */
+class AgnosticProxySDK {
+    constructor(network, agnosticProxyAddress) {
+        this.contractInterfaces = new Map();
+        switch (network) {
+            case Struct_1.Network.MAINNET:
+                this.agnosticProxyAddress = agnosticProxyAddress ?? mainnet_1.AGNOSTIC_PROXY_ADDRESS;
+                break;
+            case Struct_1.Network.TESTNET:
+                this.agnosticProxyAddress = agnosticProxyAddress ?? testnet_1.AGNOSTIC_PROXY_ADDRESS;
+                break;
+            case Struct_1.Network.DEV:
+                if (!agnosticProxyAddress) {
+                    throw new Error("Agnostic proxy address is required for dev network");
+                }
+                this.agnosticProxyAddress = agnosticProxyAddress;
+                break;
+        }
+    }
+    /**
+     * Add a contract interface for encoding function calls
+     * Supports both human-readable ABI strings and generated ABI JSON objects
+     * @param address - The address of the contract to add interface for
+     * @param abi - The abi of the contract to add interface for
+     * @returns The sdk instance
+     */
+    addContractInterface(address, abi) {
+        const parsedAbi = this._parseAbi(abi);
+        this.contractInterfaces.set(address.toLowerCase(), new ethers_1.Interface(parsedAbi));
+        return this;
+    }
+    /**
+     * Parse ABI - handles both human-readable strings and generated ABI JSON objects
+     * Extracts only function definitions from JSON ABI
+     */
+    _parseAbi(abi) {
+        const humanReadableAbi = [];
+        for (const item of abi) {
+            // If it's already a string (human-readable format), keep it
+            if (typeof item === 'string') {
+                humanReadableAbi.push(item);
+                continue;
+            }
+            // If it's a JSON ABI object, parse it
+            if (typeof item === 'object' && item.type) {
+                // Only process functions
+                if (item.type === 'function') {
+                    const signature = this._buildFunctionSignature(item);
+                    if (signature) {
+                        humanReadableAbi.push(signature);
+                    }
+                }
+                // Skip events, errors, constructor, etc.
+            }
+        }
+        return humanReadableAbi;
+    }
+    /**
+     * Build human-readable function signature from JSON ABI function object
+     * @param func - The function to build signature for
+     * @returns The signature of the function
+     */
+    _buildFunctionSignature(func) {
+        if (!func.name || !Array.isArray(func.inputs)) {
+            return null;
+        }
+        // Build parameter list
+        const params = func.inputs.map((input) => {
+            let paramType = input.type;
+            // Handle array types
+            if (input.type.includes('[]')) {
+                paramType = input.type;
+            }
+            // Add parameter name if available
+            if (input.name) {
+                return `${paramType} ${input.name}`;
+            }
+            return paramType;
+        }).join(', ');
+        // Build return types if available
+        let returnTypes = '';
+        if (func.outputs && func.outputs.length > 0) {
+            const outputs = func.outputs.map((output) => {
+                const outputType = output.type;
+                if (output.name) {
+                    return `${outputType} ${output.name}`;
+                }
+                return outputType;
+            }).join(', ');
+            if (func.outputs.length === 1) {
+                returnTypes = ` returns (${outputs})`;
+            }
+            else {
+                returnTypes = ` returns (${outputs})`;
+            }
+        }
+        // Build full signature
+        const stateMutability = func.stateMutability || 'nonpayable';
+        let mutabilityKeyword = '';
+        if (stateMutability === 'view') {
+            mutabilityKeyword = ' view';
+        }
+        else if (stateMutability === 'pure') {
+            mutabilityKeyword = ' pure';
+        }
+        else if (stateMutability === 'payable') {
+            mutabilityKeyword = ' payable';
+        }
+        return `function ${func.name}(${params})${mutabilityKeyword} external${returnTypes}`;
+    }
+    /**
+     * Create a custom hook with optional dynamic value replacement
+     * @param contractAddress - The address of the contract to call
+     * @param functionName - The name of the function to call
+     * @param params - The parameters of the function to call
+     * @param options - The options of the custom hook
+     * @returns The custom hook
+     */
+    createCustomHook(contractAddress, functionName, params, options = {}) {
+        const { isFromSAPerspective = true, value = 0n, dynamicReplacements } = options;
+        const contractInterface = this.contractInterfaces.get(contractAddress.toLowerCase());
+        if (!contractInterface) {
+            throw new Error(`Contract interface not found for address: ${contractAddress}`);
+        }
+        const data = contractInterface.encodeFunctionData(functionName, params);
+        let improvedMissionInfo = "0x";
+        // If dynamic replacements are specified, encode them
+        if (dynamicReplacements && dynamicReplacements.length > 0) {
+            // For now, support single replacement (can be extended)
+            const replacement = dynamicReplacements[0];
+            const replacementData = ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(["tuple(uint16,uint16,address,address)"], [[replacement.position, replacement.len, replacement.token, replacement.balanceAddress]]);
+            // Encode as ReplacementType.Amount with the replacement data
+            improvedMissionInfo = ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(["uint8", "bytes"], [ReplacementType.Amount, replacementData]);
+        }
+        const customHookData = {
+            isFromSAPerspective,
+            contractAddress,
+            value,
+            data,
+            improvedMissionInfo
+        };
+        // Encode only the CustomHookData
+        const encodedHookData = ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(["tuple(bool,address,uint256,bytes,bytes)"], [[
+                customHookData.isFromSAPerspective,
+                customHookData.contractAddress,
+                customHookData.value,
+                customHookData.data,
+                customHookData.improvedMissionInfo
+            ]]);
+        return {
+            hookType: HookType.Custom,
+            hookData: encodedHookData
+        };
+    }
+    /**
+     * Create a full balance approve hook
+     * @param token - The token to approve
+     * @param to - The address to approve to
+     * @param isFromSAPerspective - Whether the hook is from the smart account perspective or from proxy perspective
+     * @returns The full balance approve hook
+     */
+    createFullBalanceApproveHook(token, to, isFromSAPerspective = true) {
+        const approveHookData = {
+            token,
+            to,
+            isFromSAPerspective
+        };
+        // Encode only the ApproveHookData
+        const encodedHookData = ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(["tuple(address,address,bool)"], [[approveHookData.token, approveHookData.to, approveHookData.isFromSAPerspective]]);
+        return {
+            hookType: HookType.FullBalanceApprove,
+            hookData: encodedHookData
+        };
+    }
+    /**
+     * Create a full balance transfer hook
+     * @param token - The token to transfer
+     * @param to - The address to transfer to
+     * @param isFromSAPerspective - Whether the hook is from the smart account perspective or from proxy perspective
+     * @returns The full balance transfer hook
+     */
+    createFullBalanceTransferHook(token, to, isFromSAPerspective = true) {
+        const transferHookData = {
+            token,
+            to,
+            isFromSAPerspective
+        };
+        // Encode only the TransferHookData
+        const encodedHookData = ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(["tuple(address,address,bool)"], [[transferHookData.token, transferHookData.to, transferHookData.isFromSAPerspective]]);
+        return {
+            hookType: HookType.FullBalanceTransfer,
+            hookData: encodedHookData
+        };
+    }
+    /**
+     * Helper to create dynamic amount replacement for a specific parameter
+     * @param paramIndex - The index of the parameter to replace
+     * @param token - The token to replace
+     * @param balanceAddress - The address to replace the parameter with
+     * @returns The amount replacement
+     */
+    createAmountReplacement(paramIndex, token, balanceAddress) {
+        // Calculate position in calldata (4 bytes selector + 32 bytes per param)
+        const position = 4 + (paramIndex * 32);
+        return {
+            position,
+            len: 32, // uint256 is 32 bytes
+            token,
+            balanceAddress
+        };
+    }
+    /**
+     * Advanced replacement calculator - calculates position and length for any parameter type
+     * Required that you have added the contract interface first using addContractInterface().
+     * If human readable abi is used, need to provide function and params names also
+     * @param contractAddress - The address of the contract to call
+     * @param functionName - The name of the function to call
+     * @param parameterName - The name of the parameter to replace
+     * @param token - The token to replace
+     * @param balanceAddress - The address to replace the parameter with
+     * @returns The replacement data
+     */
+    calculateReplacementData(contractAddress, functionName, parameterName, token, balanceAddress) {
+        const contractInterface = this.contractInterfaces.get(contractAddress.toLowerCase());
+        if (!contractInterface) {
+            throw new Error(`Contract interface not found for address: ${contractAddress}. Please add it first using addContractInterface().`);
+        }
+        let functionFragment;
+        try {
+            functionFragment = contractInterface.getFunction(functionName);
+        }
+        catch {
+            throw new Error(`Function '${functionName}' not found in contract interface for ${contractAddress}`);
+        }
+        if (!functionFragment) {
+            throw new Error(`Function '${functionName}' not found in contract interface for ${contractAddress}`);
+        }
+        // Find the parameter by name
+        const paramIndex = functionFragment.inputs.findIndex(input => input.name === parameterName);
+        if (paramIndex === -1) {
+            const availableParams = functionFragment.inputs.map(input => `${input.name} (${input.type})`).join(', ');
+            throw new Error(`Parameter '${parameterName}' not found in function '${functionName}'. Available parameters: ${availableParams}`);
+        }
+        const param = functionFragment.inputs[paramIndex];
+        // Calculate position and length based on parameter type
+        const { position, len } = this._calculateParamPositionAndLength(functionFragment.inputs, paramIndex);
+        return {
+            position,
+            len,
+            token,
+            balanceAddress
+        };
+    }
+    /**
+     * Get replacement helper - shows available functions and parameters for a contract
+     * Required that you have added the contract interface first using addContractInterface().
+     * If human readable abi is used, need to provide function and params names also
+     * @param contractAddress - The address of the contract to call
+     * @returns The replacement helper
+     */
+    getReplacementHelper(contractAddress) {
+        const contractInterface = this.contractInterfaces.get(contractAddress.toLowerCase());
+        if (!contractInterface) {
+            throw new Error(`Contract interface not found for address: ${contractAddress}. Please add it first using addContractInterface().`);
+        }
+        const functions = contractInterface.fragments
+            .filter(fragment => fragment.type === 'function')
+            .map(fragment => {
+            const func = fragment;
+            return {
+                name: func.name,
+                signature: func.format('full'),
+                parameters: func.inputs.map((input, index) => {
+                    const canReplace = this._canParameterBeReplaced(input.type);
+                    return {
+                        name: input.name || `param${index}`,
+                        type: input.type,
+                        index,
+                        canReplace: canReplace.canReplace,
+                        reason: canReplace.reason
+                    };
+                })
+            };
+        });
+        return {
+            contractAddress,
+            functions
+        };
+    }
+    /**
+     * Interactive replacement builder - helps build replacement step by step
+     * @param contractAddress - The address of the contract to call
+     * @param functionName - The name of the function to call
+     * @param parameterName - The name of the parameter to replace
+     * @param token - The token to replace
+     * @param balanceAddress - The address to replace the parameter with
+     * @param options - The options of the interactive replacement builder
+     * @returns The interactive replacement builder
+     */
+    buildReplacementInteractive(contractAddress, functionName, parameterName, token, balanceAddress, options = {}) {
+        const { showCalculation = true, validate = true } = options;
+        // Get the replacement data
+        const replacement = this.calculateReplacementData(contractAddress, functionName, parameterName, token, balanceAddress);
+        // Get function info for calculation details
+        const contractInterface = this.contractInterfaces.get(contractAddress.toLowerCase());
+        if (!contractInterface) {
+            throw new Error(`Contract interface not found for address: ${contractAddress}`);
+        }
+        const functionFragment = contractInterface.getFunction(functionName);
+        if (!functionFragment) {
+            throw new Error(`Function '${functionName}' not found in contract interface for ${contractAddress}`);
+        }
+        const paramIndex = functionFragment.inputs.findIndex(input => input.name === parameterName);
+        const param = functionFragment.inputs[paramIndex];
+        const calculation = {
+            functionSignature: functionFragment.format('full'),
+            parameterInfo: {
+                name: parameterName,
+                type: param.type,
+                index: paramIndex,
+                position: replacement.position,
+                length: replacement.len
+            },
+            positionCalculation: `Position = 4 bytes (selector) + ${paramIndex} * 32 bytes = ${replacement.position} bytes`
+        };
+        // Validation
+        const validation = {
+            isValid: true,
+            warnings: [],
+            suggestions: []
+        };
+        if (validate) {
+            // Check if parameter type is suitable for replacement
+            const typeCheck = this._canParameterBeReplaced(param.type);
+            if (!typeCheck.canReplace) {
+                validation.isValid = false;
+                validation.warnings.push(`Parameter type '${param.type}' ${typeCheck.reason}`);
+            }
+            // Check if it's a reasonable parameter to replace
+            if (param.name.toLowerCase().includes('amount') || param.name.toLowerCase().includes('value')) {
+                validation.suggestions.push(`✅ Parameter '${param.name}' looks suitable for dynamic replacement`);
+            }
+            else {
+                validation.warnings.push(`⚠️ Parameter '${param.name}' might not be intended for amount replacement`);
+            }
+            // Check token address
+            if (!ethers_1.ethers.isAddress(token)) {
+                validation.isValid = false;
+                validation.warnings.push(`Invalid token address: ${token}`);
+            }
+            if (!ethers_1.ethers.isAddress(balanceAddress)) {
+                validation.isValid = false;
+                validation.warnings.push(`Invalid balance address: ${balanceAddress}`);
+            }
+        }
+        return {
+            replacement,
+            calculation,
+            validation
+        };
+    }
+    /**
+     * Private helper to calculate position and length for complex parameter types
+     * @param inputs - The inputs of the function
+     * @param targetIndex - The index of the parameter to calculate the position and length for
+     * @returns The position and length of the parameter
+     */
+    _calculateParamPositionAndLength(inputs, targetIndex) {
+        // For now, we support simple types. Complex types (arrays, structs) would need more sophisticated calculation
+        // This is a simplified version that works for basic types like uint256, address, etc.
+        let position = 4; // Start after function selector
+        for (let i = 0; i < targetIndex; i++) {
+            const paramType = inputs[i].type;
+            position += this._getTypeSize(paramType);
+        }
+        const targetType = inputs[targetIndex].type;
+        const len = this._getTypeSize(targetType);
+        return { position, len };
+    }
+    /**
+     * Get the size in bytes for a parameter type
+     * @param type - The type of the parameter
+     * @returns The size in bytes of the parameter
+     */
+    _getTypeSize(type) {
+        // Basic types are all 32 bytes in calldata (due to ABI encoding)
+        if (type.startsWith('uint') || type.startsWith('int') || type === 'address' || type === 'bool' || type.startsWith('bytes32')) {
+            return 32;
+        }
+        // Dynamic types (bytes, string) are also 32 bytes for the offset
+        if (type === 'bytes' || type === 'string') {
+            return 32;
+        }
+        // Arrays are 32 bytes for the offset
+        if (type.includes('[]')) {
+            return 32;
+        }
+        // Default to 32 bytes for unknown types
+        return 32;
+    }
+    /**
+     * Check if a parameter type can be replaced with a balance
+     * @param type - The type of the parameter
+     * @returns The can replace and reason of the parameter
+     */
+    _canParameterBeReplaced(type) {
+        if (type.startsWith('uint') && !type.includes('[]')) {
+            return { canReplace: true };
+        }
+        if (type.startsWith('int') && !type.includes('[]')) {
+            return { canReplace: true, reason: 'but be careful with signed integers' };
+        }
+        return {
+            canReplace: false,
+            reason: `is not suitable for balance replacement. Only uint/int types are supported.`
+        };
+    }
+    /**
+     * Build a complete ZapCall
+     * @param hooks - The hooks of the zap call
+     * @param bridgeTokens - The tokens to bridge
+     * @param bridgeNFTs - The nfts to bridge
+     * @returns The zap call
+     */
+    buildZapCall(hooks, bridgeTokens = [], bridgeNFTs = []) {
+        return {
+            hooks,
+            bridgeData: {
+                tokens: bridgeTokens,
+                nfts: bridgeNFTs,
+                isRequired: (bridgeTokens.length > 0 || bridgeNFTs.length > 0) ? true : false
+            }
+        };
+    }
+    /**
+     * Encode ZapCall for transaction - Much more efficient now!
+     * @param zapCall - The zap call to encode
+     * @returns The encoded zap call that can be used as calldata in tac sdk
+     */
+    encodeZapCall(zapCall) {
+        return ethers_1.ethers.AbiCoder.defaultAbiCoder().encode([
+            "tuple(" +
+                "tuple(uint8,bytes)[]," + // hooks: only hookType and hookData
+                "tuple(address[],tuple(address,uint256,uint256)[],bool)" + // bridgeData
+                ")"
+        ], [
+            [
+                zapCall.hooks.map(hook => [hook.hookType, hook.hookData]),
+                [
+                    zapCall.bridgeData.tokens,
+                    zapCall.bridgeData.nfts.map(nft => [nft.nft, nft.id, nft.amount]),
+                    zapCall.bridgeData.isRequired
+                ]
+            ]
+        ]);
+    }
+    /**
+     * Utility: Create multiple approve hooks at once
+     * @param approvals - The approvals to create
+     * @returns The multiple approve hooks
+     */
+    createMultipleApproves(approvals) {
+        return approvals.map(approval => this.createFullBalanceApproveHook(approval.token, approval.spender, approval.isFromSA ?? true));
+    }
+    /**
+     * Utility: Create a sequence of custom hooks
+     * @param calls - The calls to create
+     * @returns The hook sequence
+     */
+    createHookSequence(calls) {
+        return calls.map(call => this.createCustomHook(call.contract, call.functionName, call.params, call.options));
+    }
+    /**
+     * Debug helper: Decode hook data back to readable format
+     * @param hook - The hook to decode
+     * @returns The decoded hook
+     */
+    decodeHookData(hook) {
+        try {
+            switch (hook.hookType) {
+                case HookType.Custom:
+                    return ethers_1.ethers.AbiCoder.defaultAbiCoder().decode(["tuple(bool,address,uint256,bytes,bytes)"], hook.hookData)[0];
+                case HookType.FullBalanceApprove:
+                    return ethers_1.ethers.AbiCoder.defaultAbiCoder().decode(["tuple(address,address,bool)"], hook.hookData)[0];
+                case HookType.FullBalanceTransfer:
+                    return ethers_1.ethers.AbiCoder.defaultAbiCoder().decode(["tuple(address,address,bool)"], hook.hookData)[0];
+                default:
+                    throw new Error(`Unknown hook type: ${hook.hookType}`);
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to decode hook data: ${error}`);
+        }
+    }
+    /**
+     * Debug helper: Get estimated gas for a ZapCall
+     * @param zapCall - The zap call to estimate the gas usage for
+     * @returns The estimated gas usage
+     */
+    estimateGasUsage(zapCall) {
+        // Rough estimation based on hook types and operations
+        let gasEstimate = 50000; // Base gas
+        zapCall.hooks.forEach(hook => {
+            switch (hook.hookType) {
+                case HookType.Custom:
+                    gasEstimate += 100000; // Custom calls can vary widely
+                    break;
+                case HookType.FullBalanceApprove:
+                    gasEstimate += 50000; // ERC20 approve
+                    break;
+                case HookType.FullBalanceTransfer:
+                    gasEstimate += 65000; // ERC20 transfer
+                    break;
+            }
+        });
+        if (zapCall.bridgeData.isRequired) {
+            gasEstimate += 200000; // Bridge operations
+        }
+        return gasEstimate;
+    }
+    /**
+     * Visualize ZapCall chain - Human readable description of all operations
+     * @param zapCall - The zap call to visualize
+     */
+    visualizeZapCall(zapCall) {
+        console.log("🔗 ZapCall Chain Visualization");
+        console.log("================================");
+        if (zapCall.hooks.length === 0) {
+            console.log("❌ No hooks in this ZapCall");
+            return;
+        }
+        zapCall.hooks.forEach((hook, index) => {
+            const stepNumber = (index + 1).toString().padStart(2, " ");
+            console.log(`\n${stepNumber}. ${this._describeHook(hook)}`);
+        });
+        // Bridge information
+        if (zapCall.bridgeData.isRequired) {
+            console.log("\n🌉 Bridge Operations:");
+            if (zapCall.bridgeData.tokens.length > 0) {
+                console.log(`   📤 Bridge tokens: ${zapCall.bridgeData.tokens.map(t => this._formatAddress(t)).join(", ")}`);
+            }
+            if (zapCall.bridgeData.nfts.length > 0) {
+                console.log(`   🖼️  Bridge NFTs: ${zapCall.bridgeData.nfts.length} NFT(s)`);
+                zapCall.bridgeData.nfts.forEach((nft, i) => {
+                    console.log(`      ${i + 1}. ${this._formatAddress(nft.nft)} #${nft.id} (amount: ${nft.amount})`);
+                });
+            }
+        }
+        else {
+            console.log("\n🚫 No bridge operations required");
+        }
+        // Summary
+        console.log("\n📊 Summary:");
+        console.log(`   Total hooks: ${zapCall.hooks.length}`);
+        console.log(`   Estimated gas: ${this.estimateGasUsage(zapCall).toLocaleString()}`);
+        console.log(`   Bridge required: ${zapCall.bridgeData.isRequired ? "Yes" : "No"}`);
+        console.log("================================");
+    }
+    /**
+     * Private helper to describe individual hooks
+     * @param hook - The hook to describe
+     * @returns The description of the hook
+     */
+    _describeHook(hook) {
+        try {
+            switch (hook.hookType) {
+                case HookType.Custom:
+                    return this._describeCustomHook(hook);
+                case HookType.FullBalanceApprove:
+                    return this._describeApproveHook(hook);
+                case HookType.FullBalanceTransfer:
+                    return this._describeTransferHook(hook);
+                default:
+                    return `❓ Unknown hook type: ${hook.hookType}`;
+            }
+        }
+        catch (error) {
+            return `❌ Error describing hook: ${error}`;
+        }
+    }
+    /**
+     * Describe custom hook with function details
+     * @param hook - The hook to describe
+     * @returns The description of the hook
+     */
+    _describeCustomHook(hook) {
+        const decoded = this.decodeHookData(hook);
+        const [isFromSA, contractAddress, value, data, improvedMissionInfo] = decoded;
+        // Try to decode function name from data
+        let functionDescription = "unknown function";
+        let hasReplacements = false;
+        if (data && data.length >= 10) { // At least 4 bytes for selector + some data
+            const selector = data.slice(0, 10); // "0x" + 8 hex chars
+            // Try to find function name from registered interfaces
+            for (const [address, contractInterface] of this.contractInterfaces) {
+                if (address === contractAddress.toLowerCase()) {
+                    try {
+                        const fragment = contractInterface.getFunction(selector);
+                        if (fragment) {
+                            functionDescription = `${fragment.name}(${fragment.inputs.map(input => input.type).join(", ")})`;
+                            break;
+                        }
+                    }
+                    catch {
+                        // Function not found in this interface
+                    }
+                }
+            }
+            // If not found in registered interfaces, just show selector
+            if (functionDescription === "unknown function") {
+                functionDescription = `function with selector ${selector}`;
+            }
+        }
+        // Check for dynamic replacements
+        if (improvedMissionInfo && improvedMissionInfo !== "0x" && improvedMissionInfo.length > 2) {
+            hasReplacements = true;
+        }
+        const perspective = isFromSA ? "Smart Account" : "Proxy Contract";
+        const valueStr = value > 0n ? ` (sending ${ethers_1.ethers.formatEther(value)} ETH)` : "";
+        const replacementStr = hasReplacements ? " 🔄 [with dynamic value replacement]" : "";
+        return `📞 Custom call to ${this._formatAddress(contractAddress)} from ${perspective}${valueStr}
+     Function: ${functionDescription}${replacementStr}`;
+    }
+    /**
+     * Describe approve hook
+     * @param hook - The hook to describe
+     * @returns The description of the hook
+     */
+    _describeApproveHook(hook) {
+        const decoded = this.decodeHookData(hook);
+        const [token, to, isFromSA] = decoded;
+        const perspective = isFromSA ? "Smart Account" : "Proxy Contract";
+        return `✅ Approve full balance of ${this._formatAddress(token)} to ${this._formatAddress(to)} from ${perspective}`;
+    }
+    /**
+     * Describe transfer hook
+     * @param hook - The hook to describe
+     * @returns The description of the hook
+     */
+    _describeTransferHook(hook) {
+        const decoded = this.decodeHookData(hook);
+        const [token, to, isFromSA] = decoded;
+        const perspective = isFromSA ? "Smart Account" : "Proxy Contract";
+        return `💸 Transfer full balance of ${this._formatAddress(token)} to ${this._formatAddress(to)} from ${perspective}`;
+    }
+    /**
+     * Format address for display (show first 6 and last 4 characters)
+     * @param address - The address to format
+     * @returns The formatted address
+     */
+    _formatAddress(address) {
+        if (!address || address.length < 10)
+            return address;
+        return `${address.slice(0, 6)}...${address.slice(-4)}`;
+    }
+    /**
+     * Get a detailed breakdown of a ZapCall for logging
+     * @param zapCall - The zap call to get the breakdown for
+     * @returns The breakdown of the zap call
+     */
+    getZapCallBreakdown(zapCall) {
+        const hookTypes = {};
+        const hookDescriptions = [];
+        zapCall.hooks.forEach((hook, index) => {
+            const typeName = HookType[hook.hookType];
+            hookTypes[typeName] = (hookTypes[typeName] || 0) + 1;
+            hookDescriptions.push(`${index + 1}. ${this._describeHook(hook)}`);
+        });
+        return {
+            totalHooks: zapCall.hooks.length,
+            hookTypes,
+            gasEstimate: this.estimateGasUsage(zapCall),
+            encodedSize: this.encodeZapCall(zapCall).length / 2, // bytes
+            bridgeRequired: zapCall.bridgeData.isRequired,
+            hookDescriptions
+        };
+    }
+    /**
+     * Compare two ZapCalls and show differences
+     * @param zapCall1 - The first zap call to compare
+     * @param zapCall2 - The second zap call to compare
+     * @param label1 - The label of the first zap call
+     * @param label2 - The label of the second zap call
+     */
+    compareZapCalls(zapCall1, zapCall2, label1 = "ZapCall 1", label2 = "ZapCall 2") {
+        console.log(`🔄 Comparing ${label1} vs ${label2}`);
+        console.log("=".repeat(50));
+        const breakdown1 = this.getZapCallBreakdown(zapCall1);
+        const breakdown2 = this.getZapCallBreakdown(zapCall2);
+        console.log(`📊 ${label1}:`);
+        console.log(`   Hooks: ${breakdown1.totalHooks}, Gas: ${breakdown1.gasEstimate.toLocaleString()}, Size: ${breakdown1.encodedSize} bytes`);
+        console.log(`📊 ${label2}:`);
+        console.log(`   Hooks: ${breakdown2.totalHooks}, Gas: ${breakdown2.gasEstimate.toLocaleString()}, Size: ${breakdown2.encodedSize} bytes`);
+        console.log("\n📈 Differences:");
+        console.log(`   Hooks: ${breakdown2.totalHooks - breakdown1.totalHooks > 0 ? "+" : ""}${breakdown2.totalHooks - breakdown1.totalHooks}`);
+        console.log(`   Gas: ${breakdown2.gasEstimate - breakdown1.gasEstimate > 0 ? "+" : ""}${(breakdown2.gasEstimate - breakdown1.gasEstimate).toLocaleString()}`);
+        console.log(`   Size: ${breakdown2.encodedSize - breakdown1.encodedSize > 0 ? "+" : ""}${breakdown2.encodedSize - breakdown1.encodedSize} bytes`);
+    }
+    getAgnosticCallParams() {
+        return {
+            evmTargetAddress: this.agnosticProxyAddress,
+            methodName: "Zap(bytes,bytes)",
+        };
+    }
+}
+exports.AgnosticProxySDK = AgnosticProxySDK;