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

package/dist/src/agnosticSdk/AgnosticStructs.d.ts

@@ -0,0 +1,108 @@
+/**
+ * NFTData is a struct that contains the nft, id, and amount of the nft
+ * @param nft - The address of the nft
+ * @param id - The id of the nft
+ * @param amount - The amount of the nft to transfer(for ERC1155, but currently supported only ERC721)
+ */
+export interface NFTData {
+    nft: string;
+    id: bigint;
+    amount: bigint;
+}
+/**
+ * BridgeData is a struct that contains the tokens, nfts, and isRequired of the bridge data
+ * @param tokens - The addresses of the tokens to bridge
+ * @param nfts - The nfts to bridge
+ * @param isRequired - Whether the bridge is required
+ */
+export interface BridgeData {
+    tokens: string[];
+    nfts: NFTData[];
+    isRequired: boolean;
+}
+/**
+ * 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
+ */
+export declare enum HookType {
+    Custom = 0,
+    FullBalanceApprove = 1,
+    FullBalanceTransfer = 2
+}
+/**
+ * ReplacementType is an enum that contains the type of the replacement
+ * @param Amount - The amount replacement
+ */
+export declare enum ReplacementType {
+    Amount = 0
+}
+/**
+ * AmountChange is a struct that contains the position, length, token, and balance address of the amount change
+ * @param position - The position of the amount change(position of the parameter in the function call)
+ * @param len - The length of the amount change(length of the parameter in the function call)
+ * @param token - The token of the amount change
+ * @param balanceAddress - The balance address of the amount change(address to check balance for)
+ */
+export interface AmountChange {
+    position: number;
+    len: number;
+    token: string;
+    balanceAddress: string;
+}
+/**
+ * CustomHookData is a struct that contains the isFromSAPerspective, contractAddress, value, data, and improvedMissionInfo of the custom hook
+ * @param isFromSAPerspective - Whether the hook is from the smart account perspective or from proxy perspective
+ * @param contractAddress - The address of the contract to call
+ * @param value - The value of the hook
+ * @param data - The data of the hook
+ * @param improvedMissionInfo - The improved mission info of the hook
+ */
+export interface CustomHookData {
+    isFromSAPerspective: boolean;
+    contractAddress: string;
+    value: bigint;
+    data: string;
+    improvedMissionInfo: string;
+}
+/**
+ * ApproveHookData is a struct that contains the token, to, and isFromSAPerspective of the 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
+ */
+export interface ApproveHookData {
+    token: string;
+    to: string;
+    isFromSAPerspective: boolean;
+}
+/**
+ * TransferHookData is a struct that contains the token, to, and isFromSAPerspective of the 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
+ */
+export interface TransferHookData {
+    token: string;
+    to: string;
+    isFromSAPerspective: boolean;
+}
+/**
+ * Hook is a struct that contains the hookType and hookData of the hook
+ * @param hookType - The type of the hook
+ * @param hookData - The data of the hook
+ */
+export interface Hook {
+    hookType: HookType;
+    hookData: string;
+}
+/**
+ * ZapCall is a struct that contains the hooks and bridgeData of the zap call
+ * @param hooks - The hooks of the zap call
+ * @param bridgeData - The bridge data of the zap call
+ */
+export interface ZapCall {
+    hooks: Hook[];
+    bridgeData: BridgeData;
+}

package/dist/src/agnosticSdk/AgnosticStructs.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplacementType = exports.HookType = void 0;
+/**
+ * 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 = {}));

package/dist/src/agnosticSdk/DebugHelpers.d.ts

@@ -0,0 +1,88 @@
+import { Interface } from 'ethers';
+import { Hook, NFTData, ZapCall } from './AgnosticStructs';
+export declare class DebugHelpers {
+    /**
+     * 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: Hook[], bridgeTokens?: string[], bridgeNFTs?: NFTData[]): ZapCall;
+    /**
+     * Debug helper: Decode hook data back to readable format
+     * @param hook - The hook to decode
+     * @returns The decoded hook
+     */
+    decodeHookData(hook: Hook): any;
+    /**
+     * 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: ZapCall): number;
+    /**
+     * Visualize ZapCall chain - Human readable description of all operations
+     * @param zapCall - The zap call to visualize
+     */
+    visualizeZapCall(zapCall: ZapCall, contractInterfaces: Map<string, Interface>): void;
+    /**
+     * Private helper to describe individual hooks
+     * @param hook - The hook to describe
+     * @returns The description of the hook
+     */
+    private _describeHook;
+    /**
+     * Describe custom hook with function details
+     * @param hook - The hook to describe
+     * @returns The description of the hook
+     */
+    private _describeCustomHook;
+    /**
+     * Describe approve hook
+     * @param hook - The hook to describe
+     * @returns The description of the hook
+     */
+    private _describeApproveHook;
+    /**
+     * Describe transfer hook
+     * @param hook - The hook to describe
+     * @returns The description of the hook
+     */
+    private _describeTransferHook;
+    /**
+     * Format address for display (show first 6 and last 4 characters)
+     * @param address - The address to format
+     * @returns The formatted address
+     */
+    private _formatAddress;
+    /**
+     * 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: ZapCall, contractInterfaces: Map<string, Interface>): {
+        totalHooks: number;
+        hookTypes: {
+            [key: string]: number;
+        };
+        gasEstimate: number;
+        encodedSize: number;
+        bridgeRequired: boolean;
+        hookDescriptions: string[];
+    };
+    /**
+     * 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: ZapCall, zapCall2: ZapCall, label1: string | undefined, label2: string | undefined, contractInterfaces: Map<string, Interface>): void;
+    /**
+     * 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: ZapCall): string;
+}

package/dist/src/agnosticSdk/DebugHelpers.js

@@ -0,0 +1,274 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DebugHelpers = void 0;
+const ethers_1 = require("ethers");
+const AgnosticStructs_1 = require("./AgnosticStructs");
+class DebugHelpers {
+    /**
+     * 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,
+            },
+        };
+    }
+    /**
+     * 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 AgnosticStructs_1.HookType.Custom:
+                    return ethers_1.ethers.AbiCoder.defaultAbiCoder().decode(['tuple(bool,address,uint256,bytes,bytes)'], hook.hookData)[0];
+                case AgnosticStructs_1.HookType.FullBalanceApprove:
+                    return ethers_1.ethers.AbiCoder.defaultAbiCoder().decode(['tuple(address,address,bool)'], hook.hookData)[0];
+                case AgnosticStructs_1.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 AgnosticStructs_1.HookType.Custom:
+                    gasEstimate += 100000; // Custom calls can vary widely
+                    break;
+                case AgnosticStructs_1.HookType.FullBalanceApprove:
+                    gasEstimate += 50000; // ERC20 approve
+                    break;
+                case AgnosticStructs_1.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, contractInterfaces) {
+        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, contractInterfaces)}`);
+        });
+        // 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, contractInterfaces) {
+        try {
+            switch (hook.hookType) {
+                case AgnosticStructs_1.HookType.Custom:
+                    return this._describeCustomHook(hook, contractInterfaces);
+                case AgnosticStructs_1.HookType.FullBalanceApprove:
+                    return this._describeApproveHook(hook);
+                case AgnosticStructs_1.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, contractInterfaces) {
+        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 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, contractInterfaces) {
+        const hookTypes = {};
+        const hookDescriptions = [];
+        zapCall.hooks.forEach((hook, index) => {
+            const typeName = AgnosticStructs_1.HookType[hook.hookType];
+            hookTypes[typeName] = (hookTypes[typeName] || 0) + 1;
+            hookDescriptions.push(`${index + 1}. ${this._describeHook(hook, contractInterfaces)}`);
+        });
+        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', contractInterfaces) {
+        console.log(`🔄 Comparing ${label1} vs ${label2}`);
+        console.log('='.repeat(50));
+        const breakdown1 = this.getZapCallBreakdown(zapCall1, contractInterfaces);
+        const breakdown2 = this.getZapCallBreakdown(zapCall2, contractInterfaces);
+        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`);
+    }
+    /**
+     * 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 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,
+                ],
+            ],
+        ]);
+    }
+}
+exports.DebugHelpers = DebugHelpers;

package/dist/src/agnosticSdk/HooksHandler.d.ts

@@ -0,0 +1,43 @@
+import { Interface } from 'ethers';
+import { AmountChange, Hook } from './AgnosticStructs';
+export declare class HooksHandler {
+    /**
+     * 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: string, functionName: string, params: any[], contractInterfaces: Map<string, Interface>, options?: {
+        isFromSAPerspective?: boolean;
+        value?: bigint;
+        dynamicReplacements?: AmountChange[];
+    }): Hook;
+    /**
+     * 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: string, to: string, isFromSAPerspective?: boolean): Hook;
+    /**
+     * 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: string, to: string, isFromSAPerspective?: boolean): Hook;
+    /**
+     * Utility: Create multiple approve hooks at once
+     * @param approvals - The approvals to create
+     * @returns The multiple approve hooks
+     */
+    createMultipleApproves(approvals: {
+        token: string;
+        spender: string;
+        isFromSA?: boolean;
+    }[]): Hook[];
+}

package/dist/src/agnosticSdk/HooksHandler.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HooksHandler = void 0;
+const ethers_1 = require("ethers");
+const AgnosticStructs_1 = require("./AgnosticStructs");
+class HooksHandler {
+    /**
+     * 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, contractInterfaces, options = {}) {
+        const { isFromSAPerspective = true, value = 0n, dynamicReplacements } = options;
+        const contractInterface = 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'], [AgnosticStructs_1.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: AgnosticStructs_1.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: AgnosticStructs_1.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: AgnosticStructs_1.HookType.FullBalanceTransfer,
+            hookData: encodedHookData,
+        };
+    }
+    /**
+     * 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));
+    }
+}
+exports.HooksHandler = HooksHandler;