amped-defi 1.0.0

package/dist/tools/moneyMarket.js

@@ -0,0 +1,867 @@
+/**
+ * Money Market Tools for Amped DeFi Plugin
+ *
+ * Provides advanced supply, withdraw, borrow, and repay operations for the SODAX money market.
+ * Supports both same-chain and cross-chain operations (e.g., supply on Chain A, borrow to Chain B).
+ *
+ * Key capabilities:
+ * - Supply: Deposit tokens as collateral on any supported chain
+ * - Borrow: Borrow tokens to any chain (cross-chain capable)
+ * - Withdraw: Withdraw supplied tokens from any chain
+ * - Repay: Repay borrowed tokens from any chain
+ * - Intent-based operations: Create intents for custom flows
+ *
+ * Cross-chain flows:
+ * 1. Supply on Chain A → Borrow to Chain B (different destination)
+ * 2. Supply on Chain A → Borrow on Chain A (same chain)
+ * 3. Cross-chain repay: Repay debt from any chain
+ * 4. Cross-chain withdraw: Withdraw collateral to any chain
+ */
+import { Type } from "@sinclair/typebox";
+import { getSodaxClient } from "../sodax/client";
+import { getSpokeProvider } from "../providers/spokeProviderFactory";
+import { PolicyEngine } from "../policy/policyEngine";
+import { getWalletManager } from '../wallet/walletManager';
+import { serializeError } from '../utils/errorUtils';
+import { resolveToken, getTokenInfo } from '../utils/tokenResolver';
+import { toSodaxChainId } from '../wallet/types';
+// ============================================================================
+// TypeBox Schemas
+// ============================================================================
+/**
+ * Base schema for money market operations
+ */
+const MoneyMarketBaseSchema = Type.Object({
+    walletId: Type.String({
+        description: "Unique identifier for the wallet"
+    }),
+    chainId: Type.String({
+        description: "Source SODAX spoke chain ID where the operation originates (e.g., 'ethereum', 'arbitrum', 'sonic')"
+    }),
+    token: Type.String({
+        description: "Token address or symbol to supply/borrow/withdraw/repay",
+    }),
+    amount: Type.String({
+        description: "Amount in human-readable units (e.g., '100.5' for 100.5 USDC). Use '-1' for max repay (repay full debt).",
+    }),
+    timeoutMs: Type.Optional(Type.Number({
+        description: "Operation timeout in milliseconds",
+        default: 180000,
+    })),
+    policyId: Type.Optional(Type.String({ description: "Optional policy profile identifier for custom limits" })),
+    skipSimulation: Type.Optional(Type.Boolean({
+        description: "Skip transaction simulation (not recommended)",
+        default: false,
+    })),
+});
+/**
+ * Supply operation schema
+ * Supply tokens as collateral to the money market on the specified chain
+ */
+const MoneyMarketSupplySchema = Type.Composite([
+    MoneyMarketBaseSchema,
+    Type.Object({
+        useAsCollateral: Type.Optional(Type.Boolean({
+            description: "Whether to use the supplied tokens as collateral for borrowing (default: true)",
+            default: true,
+        })),
+        // Cross-chain supply options
+        dstChainId: Type.Optional(Type.String({
+            description: "Optional destination chain for the supply operation. If different from chainId, performs cross-chain supply.",
+        })),
+        recipient: Type.Optional(Type.String({
+            description: "Optional recipient address for the supplied position (defaults to wallet address)",
+        })),
+    }),
+]);
+/**
+ * Withdraw operation schema
+ * Withdraw supplied tokens from the money market
+ */
+const MoneyMarketWithdrawSchema = Type.Composite([
+    MoneyMarketBaseSchema,
+    Type.Object({
+        withdrawType: Type.Optional(Type.Union([
+            Type.Literal('default'),
+            Type.Literal('collateral'),
+            Type.Literal('all'),
+        ], {
+            description: "Withdraw type: 'default' (standard), 'collateral' (withdraw collateral only), 'all' (withdraw maximum)",
+            default: 'default',
+        })),
+        // Cross-chain withdraw options
+        dstChainId: Type.Optional(Type.String({
+            description: "Optional destination chain to receive withdrawn tokens. If different from chainId, performs cross-chain withdraw.",
+        })),
+        recipient: Type.Optional(Type.String({
+            description: "Optional recipient address to receive withdrawn tokens (defaults to wallet address)",
+        })),
+    }),
+]);
+/**
+ * Borrow operation schema
+ * Borrow tokens from the money market
+ *
+ * Key feature: Can borrow to a DIFFERENT chain than where collateral is supplied!
+ * Example: Supply USDC on Ethereum, borrow USDT to Arbitrum
+ */
+const MoneyMarketBorrowSchema = Type.Composite([
+    MoneyMarketBaseSchema,
+    Type.Object({
+        interestRateMode: Type.Optional(Type.Union([
+            Type.Literal(1, { description: "Stable interest rate" }),
+            Type.Literal(2, { description: "Variable interest rate (recommended)" }),
+        ], {
+            description: "Interest rate mode: 1 = Stable, 2 = Variable",
+            default: 2,
+        })),
+        referralCode: Type.Optional(Type.String({
+            description: "Optional referral code for the borrow operation",
+        })),
+        // Cross-chain borrow options (key feature!)
+        dstChainId: Type.Optional(Type.String({
+            description: "Destination chain to receive borrowed tokens. If different from chainId, performs cross-chain borrow (supply on chainId, receive borrowed tokens on dstChainId).",
+        })),
+        recipient: Type.Optional(Type.String({
+            description: "Optional recipient address to receive borrowed tokens (defaults to wallet address on dstChainId or chainId)",
+        })),
+    }),
+]);
+/**
+ * Repay operation schema
+ * Repay borrowed tokens to the money market
+ */
+const MoneyMarketRepaySchema = Type.Composite([
+    MoneyMarketBaseSchema,
+    Type.Object({
+        interestRateMode: Type.Optional(Type.Union([
+            Type.Literal(1, { description: "Stable interest rate" }),
+            Type.Literal(2, { description: "Variable interest rate" }),
+        ], {
+            description: "Interest rate mode of the debt to repay: 1 = Stable, 2 = Variable",
+            default: 2,
+        })),
+        repayAll: Type.Optional(Type.Boolean({
+            description: "If true, repays the full debt amount (useful for closing position)",
+            default: false,
+        })),
+        // Cross-chain repay options
+        collateralChainId: Type.Optional(Type.String({
+            description: "Optional chain ID where collateral is held (for cross-chain repay scenarios)",
+        })),
+    }),
+]);
+/**
+ * Create Intent schemas for advanced users
+ * These allow building custom multi-step flows
+ */
+const CreateSupplyIntentSchema = Type.Composite([
+    MoneyMarketSupplySchema,
+    Type.Object({
+        raw: Type.Optional(Type.Boolean({
+            description: "If true, returns raw transaction data instead of executing (for custom signing flows)",
+            default: false,
+        })),
+    }),
+]);
+const CreateBorrowIntentSchema = Type.Composite([
+    MoneyMarketBorrowSchema,
+    Type.Object({
+        raw: Type.Optional(Type.Boolean({
+            description: "If true, returns raw transaction data instead of executing (for custom signing flows)",
+            default: false,
+        })),
+    }),
+]);
+const CreateWithdrawIntentSchema = Type.Composite([
+    MoneyMarketWithdrawSchema,
+    Type.Object({
+        raw: Type.Optional(Type.Boolean({
+            description: "If true, returns raw transaction data instead of executing (for custom signing flows)",
+            default: false,
+        })),
+    }),
+]);
+const CreateRepayIntentSchema = Type.Composite([
+    MoneyMarketRepaySchema,
+    Type.Object({
+        raw: Type.Optional(Type.Boolean({
+            description: "If true, returns raw transaction data instead of executing (for custom signing flows)",
+            default: false,
+        })),
+    }),
+]);
+// ============================================================================
+// Helper Functions
+// ============================================================================
+/**
+ * Converts human-readable amount to token units (wei)
+ */
+function parseTokenAmount(amount, decimals = 18) {
+    // Handle special case for max repay
+    if (amount === '-1') {
+        return BigInt(-1);
+    }
+    const parsed = parseFloat(amount);
+    if (isNaN(parsed)) {
+        throw new Error(`Invalid amount: ${amount}`);
+    }
+    const multiplier = Math.pow(10, decimals);
+    return BigInt(Math.floor(parsed * multiplier));
+}
+/**
+ * Resolves wallet and creates spoke provider for the operation
+ */
+async function resolveWalletAndProvider(walletId, chainId) {
+    const walletManager = getWalletManager();
+    const wallet = await walletManager.resolve(walletId);
+    const walletAddress = await wallet.getAddress();
+    const spokeProvider = await getSpokeProvider(walletId, chainId);
+    return { walletAddress, spokeProvider };
+}
+/**
+ * Common pre-operation checks and allowance handling
+ */
+async function prepareMoneyMarketOperation(walletId, chainId, token, amount, operation, policyId) {
+    // ============================================================================
+    // Hub Chain Validation
+    // ============================================================================
+    // SODAX architecture: Money market operations must be initiated from spoke chains,
+    // not the hub chain (Sonic). The hub chain is the settlement layer where contracts
+    // live, but users interact via spoke chains that relay operations to the hub.
+    // Reference: sodax-tests/tests/crossChainSdk.test.ts explicitly omits SONIC_MAINNET_CHAIN_ID
+    const isHubChainSource = chainId.toLowerCase() === 'sonic' || chainId === '146';
+    if (isHubChainSource) {
+        throw new Error(`Money market operations cannot be initiated from the hub chain (Sonic). ` +
+            `Please use a spoke chain (base, arbitrum, ethereum, optimism, avalanche, bsc, polygon) as the source chain.`);
+    }
+    // Ensure sodax client is initialized
+    const _sodaxClient = getSodaxClient(); // Just verify it's ready
+    void _sodaxClient;
+    // Normalize chain ID to SDK format for token resolution
+    const sdkChainId = toSodaxChainId(chainId);
+    // Resolve token symbol to address
+    const tokenAddr = await resolveToken(sdkChainId, token);
+    // Resolve wallet and create spoke provider
+    const { walletAddress, spokeProvider } = await resolveWalletAndProvider(walletId, chainId);
+    // Policy check
+    const policyEngine = new PolicyEngine();
+    const policyResult = await policyEngine.checkMoneyMarket({
+        walletId,
+        chainId,
+        token,
+        amount, // Add required amount parameter
+        amountUsd: parseFloat(amount), // Simplified - would need actual price lookup
+        operation,
+        policyId,
+    });
+    if (!policyResult.allowed) {
+        throw new Error(`Policy check failed: ${policyResult.reason || "Operation not permitted"}.`);
+    }
+    return { walletAddress, spokeProvider, policyResult, tokenAddr };
+}
+/**
+ * Resolves token and returns its decimals
+ * Falls back to 18 decimals if token info not found
+ */
+async function getTokenDecimals(chainId, token) {
+    try {
+        const sdkChainId = toSodaxChainId(chainId);
+        const tokenInfo = await getTokenInfo(sdkChainId, token);
+        return tokenInfo?.decimals ?? 18;
+    }
+    catch {
+        // If token info lookup fails, fall back to 18 decimals
+        return 18;
+    }
+}
+/**
+ * Checks and handles token approval if needed
+ */
+async function ensureAllowance(params, spokeProvider, raw = false) {
+    const sodaxClient = await getSodaxClient();
+    // Check if allowance is sufficient
+    const isAllowanceValid = await sodaxClient.moneyMarket.isAllowanceValid(params, spokeProvider);
+    if (!isAllowanceValid.ok || !isAllowanceValid.value) {
+        if (raw) {
+            // Return raw approval transaction
+            const rawApproval = await sodaxClient.moneyMarket.approve(params, spokeProvider, true // raw mode
+            );
+            return { rawApproval };
+        }
+        else {
+            // Execute approval transaction
+            const approvalResult = await sodaxClient.moneyMarket.approve(params, spokeProvider, false);
+            // Handle Result type from SDK
+            const txHash = approvalResult.ok
+                ? approvalResult.value
+                : approvalResult.txHash || approvalResult;
+            return { approvalTxHash: String(txHash) };
+        }
+    }
+    return {};
+}
+/**
+ * Determine if operation is cross-chain
+ */
+function isCrossChainOperation(srcChainId, dstChainId) {
+    return !!dstChainId && dstChainId !== srcChainId;
+}
+// ============================================================================
+// Tool Handlers
+// ============================================================================
+/**
+ * Supply tokens to the money market
+ *
+ * Supports cross-chain supply: supply tokens on chainId, collateral is recorded on dstChainId (if different)
+ */
+async function handleSupply(params) {
+    const { walletId, chainId, token, amount, timeoutMs = 180000, policyId, useAsCollateral = true, dstChainId, recipient, skipSimulation = false } = params;
+    const crossChain = isCrossChainOperation(chainId, dstChainId);
+    const warnings = [];
+    try {
+        // Pre-operation checks
+        const { walletAddress, spokeProvider, tokenAddr } = await prepareMoneyMarketOperation(walletId, chainId, token, amount, "supply", policyId);
+        // Parse amount with actual token decimals
+        const decimals = await getTokenDecimals(chainId, token);
+        const amountBigInt = parseTokenAmount(amount, decimals);
+        // Check allowance for supply
+        const { approvalTxHash } = await ensureAllowance({ token: tokenAddr, amount: amountBigInt, action: 'supply' }, spokeProvider);
+        if (approvalTxHash) {
+            warnings.push(`Approval transaction executed: ${approvalTxHash}`);
+        }
+        const sodaxClient = await getSodaxClient();
+        // Build supply parameters
+        const supplyParams = {
+            action: 'supply',
+            token: tokenAddr,
+            amount: amountBigInt,
+            toAddress: recipient || walletAddress,
+        };
+        // Add cross-chain parameters if applicable
+        if (crossChain && dstChainId) {
+            supplyParams.toChainId = toSodaxChainId(dstChainId);
+            warnings.push(`Cross-chain supply: tokens supplied on ${chainId}, collateral recorded on ${dstChainId}`);
+        }
+        // Check and handle allowance (required for ALL supply operations)
+        // Reference: sodax-frontend moneymarket-ops.ts - supply ALWAYS checks allowance
+        try {
+            const allowanceResult = await sodaxClient.moneyMarket.isAllowanceValid({ token: tokenAddr, amount: amountBigInt, action: 'supply' }, spokeProvider);
+            if (allowanceResult.ok && !allowanceResult.value) {
+                console.log('[mm:supply] Approval needed, approving...');
+                const approveResult = await sodaxClient.moneyMarket.approve({ token: tokenAddr, amount: amountBigInt, action: 'supply' }, spokeProvider);
+                if (!approveResult.ok) {
+                    throw new Error(`Approval failed: ${serializeError(approveResult.error)}`);
+                }
+                // Wait for approval confirmation
+                const approvalTxHash = approveResult.value;
+                if (approvalTxHash && spokeProvider.walletProvider?.waitForTransactionReceipt) {
+                    await spokeProvider.walletProvider.waitForTransactionReceipt(approvalTxHash);
+                    console.log('[mm:supply] Approval confirmed');
+                }
+            }
+        }
+        catch (allowanceError) {
+            console.warn('[mm:supply] Allowance check failed, proceeding anyway:', allowanceError);
+        }
+        // Execute supply
+        const supplyResult = await sodaxClient.moneyMarket.supply(supplyParams, spokeProvider, timeoutMs);
+        // Handle Result type from SDK
+        if (supplyResult.ok === false) {
+            throw new Error(`Supply failed: ${serializeError(supplyResult.error)}`);
+        }
+        const value = supplyResult.ok ? supplyResult.value : supplyResult;
+        // SDK may return [spokeTxHash, hubTxHash] tuple
+        const [solverResponse, intent, deliveryInfo] = Array.isArray(value) ? value : [value, undefined, undefined];
+        // Extract tx hashes from deliveryInfo (SDK returns 3-element tuple)
+        const spokeTxHash = deliveryInfo?.srcTxHash || solverResponse?.txHash || solverResponse;
+        const hubTxHash = deliveryInfo?.hubTxHash || intent?.hubTxHash;
+        const dstTxHash = deliveryInfo?.dstTxHash;
+        return {
+            success: true,
+            txHash: String(spokeTxHash),
+            status: "success",
+            spokeTxHash: String(spokeTxHash),
+            hubTxHash: hubTxHash ? String(hubTxHash) : undefined,
+            intentHash: undefined,
+            operation: "supply",
+            chainId,
+            dstChainId: dstChainId || chainId,
+            token,
+            amount,
+            isCrossChain: crossChain,
+            message: crossChain
+                ? `Successfully supplied ${amount} ${token} on ${chainId}. Collateral available on ${dstChainId || chainId}.`
+                : `Successfully supplied ${amount} ${token} to money market on ${chainId}`,
+            warnings: warnings.length > 0 ? warnings : undefined,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error during supply";
+        return {
+            success: false,
+            status: "failed",
+            operation: "supply",
+            chainId,
+            dstChainId: dstChainId || chainId,
+            token,
+            amount,
+            isCrossChain: crossChain,
+            message: `Money market supply failed: ${errorMessage}`,
+        };
+    }
+}
+/**
+ * Withdraw tokens from the money market
+ *
+ * Supports cross-chain withdraw: withdraw collateral from chainId, receive tokens on dstChainId
+ */
+async function handleWithdraw(params) {
+    const { walletId, chainId, token, amount, timeoutMs = 180000, policyId, withdrawType = 'default', dstChainId, recipient, skipSimulation = false } = params;
+    const crossChain = isCrossChainOperation(chainId, dstChainId);
+    const warnings = [];
+    try {
+        // Pre-operation checks
+        const { walletAddress, spokeProvider, tokenAddr } = await prepareMoneyMarketOperation(walletId, chainId, token, amount, "withdraw", policyId);
+        // Parse amount with actual token decimals
+        const decimals = await getTokenDecimals(chainId, token);
+        const amountBigInt = parseTokenAmount(amount, decimals);
+        const sodaxClient = await getSodaxClient();
+        // Build withdraw parameters
+        const withdrawParams = {
+            action: 'withdraw',
+            token: tokenAddr,
+            amount: amountBigInt,
+            toAddress: recipient || walletAddress,
+        };
+        // Add cross-chain parameters if applicable
+        if (crossChain && dstChainId) {
+            withdrawParams.toChainId = toSodaxChainId(dstChainId);
+            warnings.push(`Cross-chain withdraw: withdrawing from ${chainId}, receiving tokens on ${dstChainId}`);
+        }
+        // Check and handle allowance (required for hub chain operations)
+        // Reference: sodax-frontend moneymarket-ops.ts
+        const isHubChain = chainId === 'sonic' || chainId === '146';
+        if (isHubChain) {
+            try {
+                const allowanceResult = await sodaxClient.moneyMarket.isAllowanceValid({ token: tokenAddr, amount: amountBigInt, action: 'withdraw' }, spokeProvider);
+                if (allowanceResult.ok && !allowanceResult.value) {
+                    console.log('[mm:withdraw] Approval needed, approving...');
+                    const approveResult = await sodaxClient.moneyMarket.approve({ token: tokenAddr, amount: amountBigInt, action: 'withdraw' }, spokeProvider);
+                    if (!approveResult.ok) {
+                        throw new Error(`Approval failed: ${serializeError(approveResult.error)}`);
+                    }
+                    // Wait for approval confirmation
+                    const approvalTxHash = approveResult.value;
+                    if (approvalTxHash && spokeProvider.walletProvider?.waitForTransactionReceipt) {
+                        await spokeProvider.walletProvider.waitForTransactionReceipt(approvalTxHash);
+                        console.log('[mm:withdraw] Approval confirmed');
+                    }
+                }
+            }
+            catch (allowanceError) {
+                console.warn('[mm:withdraw] Allowance check failed, proceeding anyway:', allowanceError);
+            }
+        }
+        // Execute withdraw
+        const withdrawResult = await sodaxClient.moneyMarket.withdraw(withdrawParams, spokeProvider, timeoutMs);
+        // Handle Result type from SDK
+        if (withdrawResult.ok === false) {
+            throw new Error(`Withdraw failed: ${serializeError(withdrawResult.error)}`);
+        }
+        const value = withdrawResult.ok ? withdrawResult.value : withdrawResult;
+        const [solverResponse, intent, deliveryInfo] = Array.isArray(value) ? value : [value, undefined, undefined];
+        // Extract tx hashes from deliveryInfo (SDK returns 3-element tuple)
+        const spokeTxHash = deliveryInfo?.srcTxHash || solverResponse?.txHash || solverResponse;
+        const hubTxHash = deliveryInfo?.hubTxHash || intent?.hubTxHash;
+        const dstTxHash = deliveryInfo?.dstTxHash;
+        return {
+            success: true,
+            txHash: String(spokeTxHash),
+            status: "success",
+            spokeTxHash: String(spokeTxHash),
+            hubTxHash: hubTxHash ? String(hubTxHash) : undefined,
+            intentHash: undefined,
+            operation: "withdraw",
+            chainId,
+            dstChainId: dstChainId || chainId,
+            token,
+            amount,
+            isCrossChain: crossChain,
+            message: crossChain
+                ? `Successfully withdrew ${amount} ${token} from ${chainId} to ${dstChainId}`
+                : `Successfully withdrew ${amount} ${token} from money market on ${chainId}`,
+            warnings: warnings.length > 0 ? warnings : undefined,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error during withdraw";
+        return {
+            success: false,
+            status: "failed",
+            operation: "withdraw",
+            chainId,
+            dstChainId: dstChainId || chainId,
+            token,
+            amount,
+            isCrossChain: crossChain,
+            message: `Money market withdraw failed: ${errorMessage}`,
+        };
+    }
+}
+/**
+ * Borrow tokens from the money market
+ *
+ * KEY FEATURE: Can borrow to a DIFFERENT chain than where collateral is supplied!
+ * Example: Supply USDC on Ethereum (chainId), borrow USDT to Arbitrum (dstChainId)
+ *
+ * This is a powerful cross-chain DeFi primitive that allows:
+ * 1. Accessing liquidity without moving collateral
+ * 2. Arbitraging interest rates across chains
+ * 3. Efficient capital utilization across the entire SODAX network
+ */
+async function handleBorrow(params) {
+    const { walletId, chainId, token, amount, timeoutMs = 180000, policyId, interestRateMode = 2, referralCode, dstChainId, // KEY: This can be different from chainId for cross-chain borrow!
+    recipient, skipSimulation = false } = params;
+    const crossChain = isCrossChainOperation(chainId, dstChainId);
+    const warnings = [];
+    try {
+        // Pre-operation checks
+        const { walletAddress, spokeProvider, tokenAddr } = await prepareMoneyMarketOperation(walletId, chainId, token, amount, "borrow", policyId);
+        // Parse amount with actual token decimals
+        const decimals = await getTokenDecimals(chainId, token);
+        const amountBigInt = parseTokenAmount(amount, decimals);
+        // Get user's positions to check health factor (best practice)
+        const sodaxClient = await getSodaxClient();
+        // For cross-chain borrow, resolve token on DESTINATION chain
+        // SDK expects: getMoneyMarketToken(toChainId, params.token)
+        // So params.token must be the destination chain's token address
+        let borrowTokenAddr = tokenAddr;
+        if (crossChain && dstChainId) {
+            borrowTokenAddr = await resolveToken(dstChainId, token);
+            console.log('[mm:borrow] Cross-chain: resolved token on destination chain', {
+                srcChain: chainId,
+                dstChain: dstChainId,
+                srcTokenAddr: tokenAddr,
+                dstTokenAddr: borrowTokenAddr,
+            });
+        }
+        // Build borrow parameters
+        const borrowParams = {
+            action: 'borrow',
+            token: borrowTokenAddr,
+            amount: amountBigInt,
+            toAddress: recipient || walletAddress,
+        };
+        // KEY CROSS-CHAIN FEATURE:
+        // If dstChainId is provided and different from chainId, the borrowed tokens
+        // will be delivered to dstChainId instead of chainId where the borrow is initiated
+        if (crossChain && dstChainId) {
+            borrowParams.toChainId = toSodaxChainId(dstChainId);
+            warnings.push(`Cross-chain borrow: Using collateral on ${chainId}, receiving borrowed tokens on ${dstChainId}`);
+            warnings.push(`Ensure you have sufficient collateral on ${chainId} to support this borrow`);
+        }
+        // Check and handle allowance (required for hub chain operations)
+        // Reference: sodax-frontend moneymarket-ops.ts
+        const isHubChain = chainId === 'sonic' || chainId === '146';
+        if (isHubChain) {
+            try {
+                const allowanceResult = await sodaxClient.moneyMarket.isAllowanceValid({ token: borrowTokenAddr, amount: amountBigInt, action: 'borrow' }, spokeProvider);
+                if (allowanceResult.ok && !allowanceResult.value) {
+                    console.log('[mm:borrow] Approval needed, approving...');
+                    const approveResult = await sodaxClient.moneyMarket.approve({ token: borrowTokenAddr, amount: amountBigInt, action: 'borrow' }, spokeProvider);
+                    if (!approveResult.ok) {
+                        throw new Error(`Approval failed: ${serializeError(approveResult.error)}`);
+                    }
+                    // Wait for approval confirmation
+                    const approvalTxHash = approveResult.value;
+                    if (approvalTxHash && spokeProvider.walletProvider?.waitForTransactionReceipt) {
+                        await spokeProvider.walletProvider.waitForTransactionReceipt(approvalTxHash);
+                        console.log('[mm:borrow] Approval confirmed');
+                    }
+                }
+            }
+            catch (allowanceError) {
+                console.warn('[mm:borrow] Allowance check failed, proceeding anyway:', allowanceError);
+            }
+        }
+        // Execute borrow
+        const borrowResult = await sodaxClient.moneyMarket.borrow(borrowParams, spokeProvider, timeoutMs);
+        // Handle Result type from SDK
+        if (borrowResult.ok === false) {
+            throw new Error(`Borrow failed: ${serializeError(borrowResult.error)}`);
+        }
+        const value = borrowResult.ok ? borrowResult.value : borrowResult;
+        const [solverResponse, intent, deliveryInfo] = Array.isArray(value) ? value : [value, undefined, undefined];
+        // Extract tx hashes from deliveryInfo (SDK returns 3-element tuple)
+        const spokeTxHash = deliveryInfo?.srcTxHash || solverResponse?.txHash || solverResponse;
+        const hubTxHash = deliveryInfo?.hubTxHash || intent?.hubTxHash;
+        const dstTxHash = deliveryInfo?.dstTxHash;
+        return {
+            success: true,
+            txHash: String(spokeTxHash),
+            status: "success",
+            spokeTxHash: String(spokeTxHash),
+            hubTxHash: hubTxHash ? String(hubTxHash) : undefined,
+            intentHash: undefined,
+            operation: "borrow",
+            chainId,
+            dstChainId: dstChainId || chainId,
+            token,
+            amount,
+            isCrossChain: crossChain,
+            message: crossChain
+                ? `Successfully borrowed ${amount} ${token} on ${dstChainId} using collateral from ${chainId}. Interest rate mode: ${interestRateMode === 1 ? 'Stable' : 'Variable'}`
+                : `Successfully borrowed ${amount} ${token} from money market on ${chainId}. Interest rate mode: ${interestRateMode === 1 ? 'Stable' : 'Variable'}`,
+            warnings: warnings.length > 0 ? warnings : undefined,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error during borrow";
+        return {
+            success: false,
+            status: "failed",
+            operation: "borrow",
+            chainId,
+            dstChainId: dstChainId || chainId,
+            token,
+            amount,
+            isCrossChain: crossChain,
+            message: `Money market borrow failed: ${errorMessage}`,
+        };
+    }
+}
+/**
+ * Repay borrowed tokens to the money market
+ *
+ * Supports cross-chain repay: repay debt using tokens from a different chain
+ */
+async function handleRepay(params) {
+    const { walletId, chainId, token, amount, timeoutMs = 180000, policyId, interestRateMode = 2, repayAll = false, collateralChainId, skipSimulation = false } = params;
+    const crossChain = !!collateralChainId && collateralChainId !== chainId;
+    const warnings = [];
+    try {
+        // Pre-operation checks
+        const { walletAddress, spokeProvider, tokenAddr } = await prepareMoneyMarketOperation(walletId, chainId, token, amount, "repay", policyId);
+        // Parse amount with actual token decimals (use -1 for max repay if repayAll is true)
+        const decimals = await getTokenDecimals(chainId, token);
+        const amountBigInt = repayAll ? BigInt(-1) : parseTokenAmount(amount, decimals);
+        // Check allowance for repay
+        const { approvalTxHash } = await ensureAllowance({ token: tokenAddr, amount: amountBigInt === BigInt(-1) ? BigInt(0) : amountBigInt, action: 'repay' }, spokeProvider);
+        if (approvalTxHash) {
+            warnings.push(`Approval transaction executed: ${approvalTxHash}`);
+        }
+        const sodaxClient = await getSodaxClient();
+        // Build repay parameters
+        const repayParams = {
+            action: 'repay',
+            token: tokenAddr,
+            amount: amountBigInt,
+        };
+        // Add cross-chain parameters if applicable
+        if (crossChain && collateralChainId) {
+            repayParams.toChainId = collateralChainId;
+            warnings.push(`Cross-chain repay: Repaying debt on ${collateralChainId} using tokens from ${chainId}`);
+        }
+        // Check and handle allowance (required for ALL repay operations)
+        // Reference: sodax-frontend moneymarket-ops.ts - repay ALWAYS checks allowance
+        try {
+            const allowanceResult = await sodaxClient.moneyMarket.isAllowanceValid({ token: tokenAddr, amount: amountBigInt, action: 'repay' }, spokeProvider);
+            if (allowanceResult.ok && !allowanceResult.value) {
+                console.log('[mm:repay] Approval needed, approving...');
+                const approveResult = await sodaxClient.moneyMarket.approve({ token: tokenAddr, amount: amountBigInt, action: 'repay' }, spokeProvider);
+                if (!approveResult.ok) {
+                    throw new Error(`Approval failed: ${serializeError(approveResult.error)}`);
+                }
+                // Wait for approval confirmation
+                const approvalTxHash = approveResult.value;
+                if (approvalTxHash && spokeProvider.walletProvider?.waitForTransactionReceipt) {
+                    await spokeProvider.walletProvider.waitForTransactionReceipt(approvalTxHash);
+                    console.log('[mm:repay] Approval confirmed');
+                }
+            }
+        }
+        catch (allowanceError) {
+            console.warn('[mm:repay] Allowance check failed, proceeding anyway:', allowanceError);
+        }
+        // Execute repay
+        const repayResult = await sodaxClient.moneyMarket.repay(repayParams, spokeProvider, timeoutMs);
+        // Handle Result type from SDK
+        if (repayResult.ok === false) {
+            throw new Error(`Repay failed: ${serializeError(repayResult.error)}`);
+        }
+        const value = repayResult.ok ? repayResult.value : repayResult;
+        const [solverResponse, intent, deliveryInfo] = Array.isArray(value) ? value : [value, undefined, undefined];
+        // Extract tx hashes from deliveryInfo (SDK returns 3-element tuple)
+        const spokeTxHash = deliveryInfo?.srcTxHash || solverResponse?.txHash || solverResponse;
+        const hubTxHash = deliveryInfo?.hubTxHash || intent?.hubTxHash;
+        const dstTxHash = deliveryInfo?.dstTxHash;
+        return {
+            success: true,
+            txHash: String(spokeTxHash),
+            status: "success",
+            spokeTxHash: String(spokeTxHash),
+            hubTxHash: hubTxHash ? String(hubTxHash) : undefined,
+            intentHash: undefined,
+            operation: "repay",
+            chainId,
+            token,
+            amount: repayAll ? "max (full debt)" : amount,
+            isCrossChain: crossChain,
+            message: repayAll
+                ? `Successfully repaid full debt for ${token} on ${chainId}`
+                : `Successfully repaid ${amount} ${token} to money market on ${chainId}`,
+            warnings: warnings.length > 0 ? warnings : undefined,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error during repay";
+        return {
+            success: false,
+            status: "failed",
+            operation: "repay",
+            chainId,
+            token,
+            amount: repayAll ? "max (full debt)" : amount,
+            isCrossChain: crossChain,
+            message: `Money market repay failed: ${errorMessage}`,
+        };
+    }
+}
+// ============================================================================
+// Intent Creation Handlers (Advanced)
+// ============================================================================
+/**
+ * Create a supply intent without executing (for custom flows)
+ */
+async function handleCreateSupplyIntent(params) {
+    const { walletId, chainId, token, amount, useAsCollateral = true, dstChainId, recipient, raw = true } = params;
+    try {
+        const { walletAddress, spokeProvider, tokenAddr } = await prepareMoneyMarketOperation(walletId, chainId, token, amount, "supply");
+        const decimals = await getTokenDecimals(chainId, token);
+        const amountBigInt = parseTokenAmount(amount, decimals);
+        const sodaxClient = await getSodaxClient();
+        const supplyParams = {
+            action: 'supply',
+            token: tokenAddr,
+            amount: amountBigInt,
+            toAddress: recipient || walletAddress,
+        };
+        if (dstChainId) {
+            supplyParams.toChainId = toSodaxChainId(dstChainId);
+        }
+        const intentData = await sodaxClient.moneyMarket.createSupplyIntent(supplyParams, spokeProvider, raw);
+        return {
+            success: true,
+            status: "pending",
+            operation: "createSupplyIntent",
+            chainId,
+            dstChainId: dstChainId || chainId,
+            token,
+            amount,
+            intentData,
+            requiresSubmission: true,
+            message: "Supply intent created. Submit this intent to execute the supply operation.",
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        throw new Error(`Create supply intent failed: ${errorMessage}`);
+    }
+}
+/**
+ * Create a borrow intent without executing (for custom flows)
+ */
+async function handleCreateBorrowIntent(params) {
+    const { walletId, chainId, token, amount, interestRateMode = 2, dstChainId, recipient, raw = true } = params;
+    try {
+        const { walletAddress, spokeProvider, tokenAddr } = await prepareMoneyMarketOperation(walletId, chainId, token, amount, "borrow");
+        const decimals = await getTokenDecimals(chainId, token);
+        const amountBigInt = parseTokenAmount(amount, decimals);
+        const sodaxClient = await getSodaxClient();
+        const borrowParams = {
+            action: 'borrow',
+            token: tokenAddr,
+            amount: amountBigInt,
+            toAddress: recipient || walletAddress,
+        };
+        if (dstChainId) {
+            borrowParams.toChainId = toSodaxChainId(dstChainId);
+        }
+        const intentData = await sodaxClient.moneyMarket.createBorrowIntent(borrowParams, spokeProvider, raw);
+        return {
+            success: true,
+            status: "pending",
+            operation: "createBorrowIntent",
+            chainId,
+            dstChainId: dstChainId || chainId,
+            token,
+            amount,
+            intentData,
+            requiresSubmission: true,
+            message: dstChainId && dstChainId !== chainId
+                ? `Cross-chain borrow intent created. Collateral on ${chainId}, borrowed tokens to ${dstChainId}. Submit this intent to execute.`
+                : "Borrow intent created. Submit this intent to execute the borrow operation.",
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        throw new Error(`Create borrow intent failed: ${errorMessage}`);
+    }
+}
+// ============================================================================
+// Tool Registration
+// ============================================================================
+/**
+ * Registers all money market tools with the agent tools registry
+ */
+export function registerMoneyMarketTools(agentTools) {
+    // Supply
+    agentTools.register({
+        name: "amped_mm_supply",
+        summary: "Supply tokens as collateral to the SODAX money market. Supports same-chain and cross-chain supply (supply on chain A, collateral available on chain B).",
+        schema: MoneyMarketSupplySchema,
+        handler: handleSupply,
+    });
+    // Withdraw
+    agentTools.register({
+        name: "amped_mm_withdraw",
+        summary: "Withdraw supplied tokens from the SODAX money market. Supports cross-chain withdraw (withdraw from chain A, receive tokens on chain B).",
+        schema: MoneyMarketWithdrawSchema,
+        handler: handleWithdraw,
+    });
+    // Borrow
+    agentTools.register({
+        name: "amped_mm_borrow",
+        summary: "Borrow tokens from the SODAX money market. KEY FEATURE: Can borrow to a different chain than collateral! Example: Supply on Ethereum, borrow to Arbitrum using dstChainId parameter.",
+        schema: MoneyMarketBorrowSchema,
+        handler: handleBorrow,
+    });
+    // Repay
+    agentTools.register({
+        name: "amped_mm_repay",
+        summary: "Repay borrowed tokens to the SODAX money market. Use amount='-1' or repayAll=true to repay full debt. Supports cross-chain repay.",
+        schema: MoneyMarketRepaySchema,
+        handler: handleRepay,
+    });
+    // Advanced: Create Intent variants for custom flows
+    agentTools.register({
+        name: "amped_mm_create_supply_intent",
+        summary: "[Advanced] Create a supply intent without executing. Returns raw intent data for custom signing or multi-step flows.",
+        schema: CreateSupplyIntentSchema,
+        handler: handleCreateSupplyIntent,
+    });
+    agentTools.register({
+        name: "amped_mm_create_borrow_intent",
+        summary: "[Advanced] Create a borrow intent without executing. Supports cross-chain borrow intents. Returns raw intent data for custom signing or multi-step flows.",
+        schema: CreateBorrowIntentSchema,
+        handler: handleCreateBorrowIntent,
+    });
+}
+// ============================================================================
+// Re-exports for testing and direct usage
+// ============================================================================
+export { MoneyMarketBaseSchema, MoneyMarketSupplySchema, MoneyMarketWithdrawSchema, MoneyMarketBorrowSchema, MoneyMarketRepaySchema, CreateSupplyIntentSchema, CreateWithdrawIntentSchema, CreateBorrowIntentSchema, CreateRepayIntentSchema, handleSupply, handleWithdraw, handleBorrow, handleRepay, handleCreateSupplyIntent, handleCreateBorrowIntent, };
+// Aliases for index.ts compatibility
+export { MoneyMarketSupplySchema as MmSupplySchema, MoneyMarketWithdrawSchema as MmWithdrawSchema, MoneyMarketBorrowSchema as MmBorrowSchema, MoneyMarketRepaySchema as MmRepaySchema, handleSupply as handleMmSupply, handleWithdraw as handleMmWithdraw, handleBorrow as handleMmBorrow, handleRepay as handleMmRepay, };
+//# sourceMappingURL=moneyMarket.js.map