@tonappchain/sdk 0.7.0-rc24-test-8 → 0.7.0-rc24-test-10

package/dist/src/agnosticSdk/AgnosticSdk.js

@@ -1,37 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgnosticProxySDK = exports.ReplacementType = exports.HookType = void 0;
-const ethers_1 = require("ethers");
+exports.AgnosticProxySDK = void 0;
 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 = {}));
+const AbiHandler_1 = require("./AbiHandler");
+const DebugHelpers_1 = require("./DebugHelpers");
+const HooksHandler_1 = require("./HooksHandler");
+const ReplacementHelper_1 = require("./ReplacementHelper");
 /**
  * SDK for building AgnosticProxy Zap calls with efficient hook encoding
+ * @param network - The network to use (MAINNET || TESTNET || DEV)
  * @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;
@@ -41,103 +24,20 @@ class AgnosticProxySDK {
                 break;
             case Struct_1.Network.DEV:
                 if (!agnosticProxyAddress) {
-                    throw new Error("Agnostic proxy address is required for dev network");
+                    throw new Error('Agnostic proxy address is required for dev network');
                 }
                 this.agnosticProxyAddress = agnosticProxyAddress;
                 break;
         }
+        this.abiHandler = new AbiHandler_1.AbiHandler();
+        this.replacementHelper = new ReplacementHelper_1.ReplacementHelper();
+        this.hooksHandler = new HooksHandler_1.HooksHandler();
+        this.debugHelpers = new DebugHelpers_1.DebugHelpers();
     }
-    /**
-     * 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));
+        this.abiHandler.addContractInterface(address, abi);
         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
@@ -147,40 +47,7 @@ class AgnosticProxySDK {
      * @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
-        };
+        return this.hooksHandler.createCustomHook(contractAddress, functionName, params, this.abiHandler.contractInterfaces, options);
     }
     /**
      * Create a full balance approve hook
@@ -190,17 +57,7 @@ class AgnosticProxySDK {
      * @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
-        };
+        return this.hooksHandler.createFullBalanceApproveHook(token, to, isFromSAPerspective);
     }
     /**
      * Create a full balance transfer hook
@@ -210,17 +67,23 @@ class AgnosticProxySDK {
      * @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
-        };
+        return this.hooksHandler.createFullBalanceTransferHook(token, to, isFromSAPerspective);
+    }
+    /**
+     * Utility: Create multiple approve hooks at once
+     * @param approvals - The approvals to create
+     * @returns The multiple approve hooks
+     */
+    createMultipleApproves(approvals) {
+        return this.hooksHandler.createMultipleApproves(approvals);
+    }
+    /**
+     * 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));
     }
     /**
      * Helper to create dynamic amount replacement for a specific parameter
@@ -230,14 +93,7 @@ class AgnosticProxySDK {
      * @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
-        };
+        return this.replacementHelper.createAmountReplacement(paramIndex, token, balanceAddress);
     }
     /**
      * Advanced replacement calculator - calculates position and length for any parameter type
@@ -251,35 +107,7 @@ class AgnosticProxySDK {
      * @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
-        };
+        return this.replacementHelper.calculateReplacementData(contractAddress, functionName, parameterName, token, balanceAddress, this.abiHandler.contractInterfaces);
     }
     /**
      * Get replacement helper - shows available functions and parameters for a contract
@@ -289,33 +117,7 @@ class AgnosticProxySDK {
      * @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
-        };
+        return this.replacementHelper.getReplacementHelper(contractAddress, this.abiHandler.contractInterfaces);
     }
     /**
      * Interactive replacement builder - helps build replacement step by step
@@ -328,177 +130,7 @@ class AgnosticProxySDK {
      * @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));
+        return this.replacementHelper.buildReplacementInteractive(contractAddress, functionName, parameterName, token, balanceAddress, this.abiHandler.contractInterfaces, options);
     }
     /**
      * Debug helper: Decode hook data back to readable format
@@ -506,21 +138,7 @@ class AgnosticProxySDK {
      * @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}`);
-        }
+        return this.debugHelpers.decodeHookData(hook);
     }
     /**
      * Debug helper: Get estimated gas for a ZapCall
@@ -528,160 +146,14 @@ class AgnosticProxySDK {
      * @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;
+        return this.debugHelpers.estimateGasUsage(zapCall);
     }
     /**
      * 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)}`;
+        return this.debugHelpers.visualizeZapCall(zapCall, this.abiHandler.contractInterfaces);
     }
     /**
      * Get a detailed breakdown of a ZapCall for logging
@@ -689,21 +161,7 @@ class AgnosticProxySDK {
      * @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
-        };
+        return this.debugHelpers.getZapCallBreakdown(zapCall, this.abiHandler.contractInterfaces);
     }
     /**
      * Compare two ZapCalls and show differences
@@ -712,25 +170,32 @@ class AgnosticProxySDK {
      * @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`);
+    compareZapCalls(zapCall1, zapCall2, label1 = 'ZapCall 1', label2 = 'ZapCall 2') {
+        return this.debugHelpers.compareZapCalls(zapCall1, zapCall2, label1, label2, this.abiHandler.contractInterfaces);
     }
     getAgnosticCallParams() {
         return {
             evmTargetAddress: this.agnosticProxyAddress,
-            methodName: "Zap(bytes,bytes)",
+            methodName: 'Zap(bytes,bytes)',
         };
     }
+    /**
+     * 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 this.debugHelpers.buildZapCall(hooks, bridgeTokens, bridgeNFTs);
+    }
+    /**
+     * Encode ZapCall for transaction
+     * @param zapCall - The zap call to encode
+     * @returns The encoded zap call that can be used as calldata in tac sdk
+     */
+    encodeZapCall(zapCall) {
+        return this.debugHelpers.encodeZapCall(zapCall);
+    }
 }
 exports.AgnosticProxySDK = AgnosticProxySDK;