wallet-agent-ai-radix 1.0.0

package/dist/core/AgentWallet.js

@@ -0,0 +1,658 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentWallet = void 0;
+const AGGRClient_1 = require("./AGGRClient");
+const RadixClient_1 = require("./RadixClient");
+// Direcciones de los assets en cada red
+const ASSET_ADDRESSES = {
+    mainnet: {
+        XRD: "resource_rdx1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxradxrd",
+        HWBTC: "resource_rdx1t58kkcqdz0mavfz98m98qh9m4jexyl9tacsvlhns6yxs4r6hrm5re5",
+        HUSDC: "resource_rdx1thxj9m87sn5cc9ehgp9qxp6vzeqxtce90xm5cp33373tclyp4et4gv",
+        HETH: "resource_rdx1th09yvv7tgsrv708ffsgqjjf2mhy84mscmj5jwu4g670fh3e5zgef0",
+        HUSDT: "resource_rdx1th4v03gezwgzkuma6p38lnum8ww8t4ds9nvcrkr2p9ft6kxx3kxvhe",
+    },
+    stokenet: {
+        XRD: "resource_tdx_2_1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxtfd2jc",
+        HWBTC: "resource_tdx_2_1tkshqwxsg524asnfd5e6d27dwc27sywtdmlrpgp63uwdwk90e9sf7h",
+        HUSDC: "resource_tdx_2_1tkvlvu3zekq5dj8n34cg4swlnj6mwdkcrcal2wf54kwehwx02ly5my",
+        HETH: "resource_tdx_2_1tk76lm84jurun672nkn6893hjsfwyp9wd7qz0yxha5dvu5h72svtzq",
+        HUSDT: "resource_tdx_2_1tk6g9gwdph40v8sd8qfte0lgftc7g8xxqkz86dtynwm6x72zm6ezce",
+    },
+    localnet: {
+        XRD: "resource_sim1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxakj8n3",
+        HUSDC: "resource_sim1t_husdc",
+        HWBTC: "resource_sim1t_hwbtc",
+        HETH: "resource_sim1t_heth",
+        HUSDT: "resource_sim1t_husdt",
+    },
+};
+// Configuración de red
+const NETWORK_CONFIG = {
+    mainnet: {
+        gatewayUrl: "https://mainnet.radixdlt.com",
+        networkId: 0x01,
+    },
+    stokenet: {
+        gatewayUrl: "https://stokenet.radixdlt.com",
+        networkId: 0x02,
+    },
+    localnet: {
+        gatewayUrl: "http://localhost:8080",
+        networkId: 0xf2,
+    },
+};
+class AgentWallet {
+    constructor(config) {
+        const network = config.network ?? "mainnet";
+        if (!NETWORK_CONFIG[network]) {
+            throw new Error(`[AgentWallet] Invalid network "${network}". Valid options: mainnet, stokenet, localnet`);
+        }
+        this.config = { ...config, network };
+        this.networkConfig = NETWORK_CONFIG[network];
+        this.assetAddresses = ASSET_ADDRESSES[network];
+        this.activeOrders = new Map();
+        this.customAssets = new Map();
+        if (config.aggrConfig) {
+            this.aggrClient = new AGGRClient_1.AGGRClient(config.aggrConfig);
+        }
+        if (config.privateKey) {
+            this.radixClient = new RadixClient_1.RadixClient(config.privateKey, this.networkConfig);
+        }
+        else {
+            this.radixClient = RadixClient_1.RadixClient.fromKeystore(this.networkConfig);
+        }
+    }
+    async checkFunds() {
+        try {
+            const config = await this.getConfig();
+            const balance = await this.getBalance();
+            const warnings = [];
+            const xrdBalance = balance.balances["XRD"] ?? 0;
+            const threshold = config.maxPerTransaction + 10;
+            if (xrdBalance < threshold) {
+                warnings.push(`Low funds in component: ${xrdBalance} XRD. Minimum recommended: ${threshold} XRD`);
+            }
+            if (warnings.length > 0 && this.config.onLowFunds) {
+                this.config.onLowFunds(warnings);
+            }
+        }
+        catch (err) {
+            console.error("[AgentWallet] checkFunds error:", err);
+        }
+    }
+    // Obtiene la dirección del resource de un asset
+    getAssetAddress(asset) {
+        // Primero busca en assets registrados por el usuario
+        const custom = this.customAssets.get(asset.toUpperCase());
+        if (custom) {
+            const address = custom[this.config.network];
+            if (address)
+                return address;
+            throw new Error(`[AgentWallet] Asset ${asset} has no address for network ${this.config.network}`);
+        }
+        // Si no encuentra busca en los assets por defecto
+        const defaults = ASSET_ADDRESSES[this.config.network];
+        const address = defaults[asset];
+        if (!address) {
+            throw new Error(`[AgentWallet] Asset ${asset} not found. Use registerAsset() to add custom assets.`);
+        }
+        return address;
+    }
+    // El usuario registra un asset custom con sus addresses por red
+    registerAsset(symbol, addresses) {
+        const upper = symbol.toUpperCase();
+        if (ASSET_ADDRESSES[this.config.network][upper]) {
+            throw new Error(`[AgentWallet] Asset ${upper} already exists as a default asset.`);
+        }
+        this.customAssets.set(upper, addresses);
+        console.log(`[AgentWallet] Asset ${upper} registered successfully.`);
+    }
+    // Lista todos los assets disponibles — default + custom
+    listAssets() {
+        const defaults = Object.keys(ASSET_ADDRESSES[this.config.network]);
+        const custom = Array.from(this.customAssets.keys());
+        return [...defaults, ...custom];
+    }
+    // Consulta el balance del PolicyVault
+    async getBalance() {
+        const response = await fetch(`${this.networkConfig.gatewayUrl}/state/entity/details`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                addresses: [this.config.componentAddress],
+                aggregation_level: "Vault",
+                opt_ins: {
+                    explicit_metadata: ["name", "symbol"]
+                }
+            }),
+        });
+        const data = await response.json();
+        const fungibles = data?.items?.[0]?.fungible_resources?.items || [];
+        const balances = {};
+        for (const resource of fungibles) {
+            const metadata = resource.explicit_metadata?.items || [];
+            const symbol = metadata.find((m) => m.key === "symbol")?.value?.typed?.value;
+            const amount = parseFloat(resource.vaults?.items?.[0]?.amount || "0");
+            if (symbol && amount > 0) {
+                balances[symbol] = amount;
+            }
+        }
+        return {
+            balances,
+            componentAddress: this.config.componentAddress,
+            timestamp: new Date(),
+        };
+    }
+    // Transfiere assets a una dirección — el agente presenta su badge automáticamente
+    async transfer(params) {
+        const assetAddress = this.getAssetAddress(params.asset);
+        const badgeLocalId = this.config.badgeLocalId ?? "#1#";
+        // 1. Obtener configuración actual del contrato
+        const config = await this.getConfig();
+        // 2. VALIDAR FROZEN
+        if (config.frozen) {
+            throw new Error(`[AgentWallet] Contract is frozen. No transfers allowed.`);
+        }
+        // 3. VALIDAR MULTISIG THRESHOLD PRIMERO
+        // Si supera el umbral del owner — necesita aprobación del owner
+        let manifest;
+        if (config.multisigThreshold && params.amount > config.multisigThreshold) {
+            console.log(`[AgentWallet] Amount ${params.amount} exceeds multisig threshold (${config.multisigThreshold}). Requesting owner approval...`);
+            await this.requestLargeTransfer({
+                to: params.to,
+                amount: params.amount,
+                asset: params.asset,
+                reason: params.reason,
+            });
+            return {
+                txId: "pending_owner_approval",
+                amount: params.amount,
+                asset: params.asset,
+                to: params.to,
+                reason: params.reason,
+                timestamp: new Date(),
+                success: false,
+            };
+        }
+        // 4. VALIDAR MAX PER TRANSACTION
+        // Si supera el límite del agente pero NO el del owner — rechazar
+        else if (params.amount > config.maxPerTransaction) {
+            throw new Error(`[AgentWallet] Amount ${params.amount} exceeds max per transaction (${config.maxPerTransaction}). ` +
+                `For larger transfers up to ${config.multisigThreshold}, owner approval is required. ` +
+                `Use requestOwnerApproval() instead.`);
+        }
+        // 5. TRANSFERENCIA NORMAL — dentro de los límites del agente
+        else {
+            console.log(`[AgentWallet] Amount ${params.amount} within agent limits. Normal transfer.`);
+            manifest = this.buildTransferManifest(params.to, assetAddress, params.amount, this.config.badgeResourceAddress, badgeLocalId);
+        }
+        // 5. Enviar la transacción
+        let txId;
+        try {
+            txId = await this.submitManifest(manifest);
+            console.log("[AgentWallet] TX submitted:", txId);
+        }
+        catch (err) {
+            console.error("[AgentWallet] submitManifest ERROR:", err);
+            throw err;
+        }
+        this.checkFunds().catch(console.error);
+        return {
+            txId,
+            amount: params.amount,
+            asset: params.asset,
+            to: params.to,
+            reason: params.reason,
+            timestamp: new Date(),
+            success: true,
+        };
+    }
+    // Agent need these to know the limits 
+    async getConfig() {
+        try {
+            // Usar el endpoint correcto
+            const response = await fetch(`${this.networkConfig.gatewayUrl}/state/entity/details`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    addresses: [this.config.componentAddress],
+                }),
+            });
+            const data = await response.json();
+            // Extraer los fields del state
+            const fields = data?.items?.[0]?.details?.state?.fields ?? [];
+            // Buscar los valores por field_name
+            let maxPerTransaction = 100;
+            let multisigThreshold = 500;
+            let dailyCap = 1000;
+            let frozen = false;
+            for (const field of fields) {
+                switch (field.field_name) {
+                    case "max_per_transaction":
+                        maxPerTransaction = parseFloat(field.value);
+                        break;
+                    case "multisig_threshold":
+                        multisigThreshold = parseFloat(field.value);
+                        break;
+                    case "daily_cap":
+                        dailyCap = parseFloat(field.value);
+                        break;
+                    case "frozen":
+                        frozen = field.value === true;
+                        break;
+                }
+            }
+            console.log("  ✅ Config get from  agent component:");
+            console.log(`  📈 Max for transaction: ${maxPerTransaction}`);
+            console.log(`  🔐 Multisig level: ${multisigThreshold}`);
+            console.log(`  💰 Dairy limit: ${dailyCap}`);
+            console.log(`  ❄️  Frozen: ${frozen}`);
+            return {
+                maxPerTransaction,
+                multisigThreshold,
+                dailyCap,
+                frozen,
+            };
+        }
+        catch (error) {
+            console.error("❌ Error when consult the endpoint:", error);
+        }
+        // Fallback en caso de error
+        return {
+            maxPerTransaction: 100,
+            multisigThreshold: 500,
+            dailyCap: 1000,
+            frozen: false,
+        };
+    }
+    // ─── Pending Transfer — Large TX que requiere aprobación del owner ─────────
+    async requestLargeTransfer(params) {
+        const assetAddress = this.getAssetAddress(params.asset);
+        const badgeLocalId = this.config.badgeLocalId ?? "#1#";
+        const notarizer = this.config.notarizerAddress ?? RadixClient_1.RadixClient.getAddress();
+        const manifest = `
+CALL_METHOD
+    Address("${notarizer}")
+    "lock_fee"
+    Decimal("2")
+;
+CALL_METHOD
+    Address("${this.config.componentAddress}")
+    "lock_fee"
+    Decimal("8")
+;
+CALL_METHOD
+    Address("${notarizer}")
+    "create_proof_of_non_fungibles"
+    Address("${this.config.badgeResourceAddress}")
+    Array<NonFungibleLocalId>(NonFungibleLocalId("${badgeLocalId}"))
+;
+POP_FROM_AUTH_ZONE
+    Proof("agent_proof")
+;
+CALL_METHOD
+    Address("${this.config.componentAddress}")
+    "request_large_transfer"
+    Address("${params.to}")
+    Decimal("${params.amount}")
+    Address("${assetAddress}")
+    "${params.reason}"
+    Proof("agent_proof")
+;
+`;
+        await this.submitManifest(manifest);
+        this.checkFunds().catch(console.error);
+        console.log(`[AgentWallet] Large transfer requested:`);
+        console.log(`   To: ${params.to}`);
+        console.log(`   Amount: ${params.amount} ${params.asset}`);
+        console.log(`   Reason: ${params.reason}`);
+        console.log(`   ⚠️  Owner approval required — check the web dashboard`);
+        return {
+            requested: true,
+            to: params.to,
+            amount: params.amount,
+            asset: params.asset,
+            reason: params.reason,
+        };
+    }
+    async getPendingTransfer() {
+        // CALL_METHOD
+        //     Address("${this.config.agentAccountAddress}")
+        //     "create_proof_of_amount"
+        //      Address("${this.config.ownerBadgeAddress}")
+        //      Decimal("1")
+        // ;
+        const manifest = `
+CALL_METHOD
+    Address("${this.config.componentAddress}")
+    "get_pending_transfer"
+;
+`;
+        const response = await fetch(`${this.networkConfig.gatewayUrl}/transaction/preview`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                manifest,
+                start_epoch_inclusive: 1,
+                end_epoch_exclusive: 100,
+                nonce: 1,
+                signer_public_keys: [],
+                notary_public_key: {
+                    key_type: "EddsaEd25519",
+                    key_hex: "0000000000000000000000000000000000000000000000000000000000000001"
+                },
+                notary_is_signatory: true,
+                tip_percentage: 0,
+                flags: {
+                    use_free_credit: true,
+                    assume_all_signature_proofs: true,
+                    skip_epoch_check: true
+                }
+            })
+        });
+        const data = await response.json();
+        //const output = data?.receipt?.output?.[1]?.programmatic_json;
+        const output = data?.receipt?.output?.[0]?.programmatic_json;
+        // variant_id "0" = None, "1" = Some
+        if (!output || output.variant_id === "0") {
+            return { hasPending: false };
+        }
+        const fields = output?.fields?.[0]?.fields;
+        return {
+            hasPending: true,
+            to: fields?.[0]?.value,
+            amount: fields?.[1]?.value,
+            asset: fields?.[2]?.value,
+            reason: fields?.[3]?.value,
+            requestedAtEpoch: fields?.[4]?.value,
+        };
+    }
+    //Ejecuta un swap a través del AGGR
+    async swap(params) {
+        if (!this.aggrClient) {
+            throw new Error("[AgentWallet] AGGR not configured. Pass aggrConfig to use swap.");
+        }
+        const fromAddress = this.getAssetAddress(params.fromAsset);
+        const toAddress = this.getAssetAddress(params.toAsset);
+        const badgeLocalId = this.config.badgeLocalId ?? "#1#";
+        // Descuentamos el fee del PolicyVault (0.1%) antes de llamar al AGGR
+        // para que el monto que llega al AGGR sea el real disponible
+        const FEE_RATE = 0.001;
+        const adjustedAmount = params.amount * (1 - FEE_RATE);
+        // Llamamos al AGGR con el monto ajustado y el PolicyVault como fromAddress
+        const quote = await this.aggrClient.getSwapQuote(fromAddress, toAddress, adjustedAmount, this.config.componentAddress);
+        // VERSION MOCK 
+        //console.log("=== AGGR MANIFEST RAW ===");
+        //console.log(quote.manifest);
+        if (this.config.aggrConfig?.mockMode) {
+            console.log("[AgentWallet] SWAP MOCK — simulando resultado sin TX");
+            return {
+                txId: "mock_swap_" + Date.now(),
+                fromAsset: params.fromAsset,
+                toAsset: params.toAsset,
+                amountIn: params.amount,
+                amountOut: quote.outputTokens,
+                executedPrice: quote.outputTokens / params.amount,
+                reason: params.reason,
+                timestamp: new Date(),
+                success: true,
+            };
+        }
+        // FIN MOCK 
+        const aggrManifest = quote.manifest;
+        //
+        const withdrawPattern = /CALL_METHOD\s+Address\("[^"]+"\)\s+"withdraw"[^;]+;/;
+        const manifestWithoutWithdraw = aggrManifest.replace(withdrawPattern, "");
+        const notarizer = this.config.notarizerAddress ?? RadixClient_1.RadixClient.getAddress();
+        // Construimos el resto manifiesto
+        const manifest = `
+CALL_METHOD
+    Address("${notarizer}")
+    "lock_fee"
+    Decimal("10")
+;
+CALL_METHOD
+    Address("${this.config.componentAddress}")
+    "lock_fee"
+    Decimal("8")
+;
+CALL_METHOD
+    Address("${notarizer}")
+    "create_proof_of_non_fungibles"
+    Address("${this.config.badgeResourceAddress}")
+    Array<NonFungibleLocalId>(NonFungibleLocalId("${badgeLocalId}"))
+;
+POP_FROM_AUTH_ZONE
+    Proof("agent_proof")
+;
+CALL_METHOD
+    Address("${this.config.componentAddress}")
+    "transfer"
+    Address("${this.config.componentAddress}")
+    Decimal("${params.amount}")
+    Address("${fromAddress}")
+    "swap ${params.fromAsset} to ${params.toAsset}"
+    Proof("agent_proof")
+;
+${manifestWithoutWithdraw}
+`;
+        const txId = await this.submitManifest(manifest);
+        this.checkFunds().catch(console.error);
+        return {
+            txId,
+            fromAsset: params.fromAsset,
+            toAsset: params.toAsset,
+            amountIn: params.amount,
+            amountOut: quote.outputTokens,
+            executedPrice: quote.outputTokens / params.amount,
+            reason: params.reason,
+            timestamp: new Date(),
+            success: true,
+        };
+    }
+    // Crea una orden condicional — ejecuta cuando se cumple el precio trigger
+    async createConditionalOrder(order) {
+        if (!this.aggrClient) {
+            throw new Error("[AgentWallet] AGGR not configured. Pass aggrConfig to use conditional orders.");
+        }
+        const orderId = `order_${Date.now()}`;
+        const fromAddress = this.getAssetAddress(order.asset);
+        const toAddress = this.getAssetAddress(order.againstAsset);
+        const cancelWatch = await this.aggrClient.watchPrice(fromAddress, toAddress, order.amount, this.config.componentAddress, order.triggerPrice, order.condition, 5000, async (quote) => {
+            console.log(`[AgentWallet] Order ${orderId} triggered at price ${quote.outputTokens / order.amount}`);
+            // Cancela el monitor antes de ejecutar
+            this.cancelOrder(orderId);
+            // Mock — no ejecutar swap real
+            if (this.config.aggrConfig?.mockMode) {
+                console.log(`[AgentWallet] MOCK order ${orderId} triggered`);
+                return;
+            }
+            // FIN MOCK
+            await this.swap({
+                fromAsset: order.asset,
+                toAsset: order.againstAsset,
+                amount: order.amount,
+                maxSlippage: order.maxSlippage,
+                reason: `conditional order ${orderId} triggered at price ${quote.outputTokens / order.amount}`,
+            });
+        });
+        // Guardamos la función de cancelación
+        this.activeOrders.set(orderId, cancelWatch);
+        return orderId;
+    }
+    // Cancela una orden condicional activa
+    cancelOrder(orderId) {
+        const cancel = this.activeOrders.get(orderId);
+        if (cancel) {
+            cancel();
+            this.activeOrders.delete(orderId);
+            return true;
+        }
+        return false;
+    }
+    // Lista las órdenes activas
+    listActiveOrders() {
+        return Array.from(this.activeOrders.keys());
+    }
+    // Construye el manifiesto de transferencia desde el PolicyVault
+    buildTransferManifest(to, assetAddress, amount, badgeResourceAddress, badgeLocalId = "#1#") {
+        const notarizer = this.config.notarizerAddress ?? RadixClient_1.RadixClient.getAddress();
+        return `
+CALL_METHOD
+    Address("${notarizer}")
+    "lock_fee"
+    Decimal("2")
+;
+  CALL_METHOD    
+    Address("${this.config.componentAddress}")
+    "lock_fee"
+    Decimal("8")
+;
+CALL_METHOD
+    Address("${notarizer}")
+    "create_proof_of_non_fungibles"
+    Address("${badgeResourceAddress}")
+    Array<NonFungibleLocalId>(NonFungibleLocalId("${badgeLocalId}"))
+;
+POP_FROM_AUTH_ZONE
+    Proof("agent_proof")
+;
+CALL_METHOD
+    Address("${this.config.componentAddress}")
+    "transfer"
+    Address("${to}")
+    Decimal("${amount}")
+    Address("${assetAddress}")
+    "transfer"
+    Proof("agent_proof")
+;
+CALL_METHOD
+    Address("${to}")
+    "try_deposit_batch_or_abort"
+    Expression("ENTIRE_WORKTOP")
+    None
+;`;
+    }
+    // Firma y envía un manifiesto a la red Radix
+    async submitManifest(manifest) {
+        return await this.radixClient.submitManifest(manifest);
+    }
+    waitForOwnerApproval(pendingDetails, intervalMs = 30000) {
+        let active = true;
+        let fromStateVersion = 0;
+        // Obtener state_version actual antes de arrancar el polling
+        const init = async () => {
+            try {
+                const response = await fetch(`${this.networkConfig.gatewayUrl}/stream/transactions`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                        affected_global_entities_filter: [this.config.componentAddress],
+                        limit_per_page: 1,
+                        order: "Desc",
+                    })
+                });
+                const data = await response.json();
+                fromStateVersion = data?.items?.[0]?.state_version ?? 0;
+                console.log(`[AgentWallet] waitForOwnerApproval — starting from state_version: ${fromStateVersion}`);
+            }
+            catch (err) {
+                console.error("[AgentWallet] waitForOwnerApproval init error:", err);
+            }
+            setTimeout(checkResult, intervalMs);
+        };
+        const checkResult = async () => {
+            if (!active)
+                return;
+            try {
+                const response = await fetch(`${this.networkConfig.gatewayUrl}/stream/transactions`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                        affected_global_entities_filter: [this.config.componentAddress],
+                        limit_per_page: 10,
+                        order: "Desc",
+                        opt_ins: { manifest_instructions: true }
+                    })
+                });
+                const data = await response.json();
+                const items = data?.items || [];
+                // Solo mirar TXs posteriores al inicio del polling
+                const newItems = items.filter((tx) => tx.state_version > fromStateVersion);
+                for (const tx of newItems) {
+                    const instructions = tx.manifest_instructions || "";
+                    if (instructions.includes("approve_transfer")) {
+                        active = false;
+                        this.config.onTransferApproved?.(pendingDetails);
+                        return;
+                    }
+                    if (instructions.includes("reject_transfer")) {
+                        active = false;
+                        this.config.onTransferRejected?.(pendingDetails);
+                        return;
+                    }
+                }
+            }
+            catch (err) {
+                console.error("[AgentWallet] waitForOwnerApproval error:", err);
+            }
+            if (active)
+                setTimeout(checkResult, intervalMs);
+        };
+        init();
+        return () => { active = false; };
+    }
+    async getWhitelist() {
+        const manifest = `
+CALL_METHOD
+    Address("${this.config.componentAddress}")
+    "get_whitelist"
+;
+`;
+        const response = await fetch(`${this.networkConfig.gatewayUrl}/transaction/preview`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                manifest,
+                start_epoch_inclusive: 1,
+                end_epoch_exclusive: 100,
+                nonce: 1,
+                signer_public_keys: [],
+                notary_public_key: {
+                    key_type: "EddsaEd25519",
+                    key_hex: "0000000000000000000000000000000000000000000000000000000000000001"
+                },
+                notary_is_signatory: true,
+                tip_percentage: 0,
+                flags: {
+                    use_free_credit: true,
+                    assume_all_signature_proofs: true,
+                    skip_epoch_check: true
+                }
+            })
+        });
+        const data = await response.json();
+        const output = data?.receipt?.output?.[0]?.programmatic_json;
+        if (!output || !output.elements)
+            return [];
+        return output.elements.map((item) => ({
+            name: item.fields?.[0]?.value ?? "",
+            address: item.fields?.[1]?.value ?? "",
+        }));
+    }
+    async getSwapQuote(fromAsset, toAsset, amount) {
+        if (!this.aggrClient) {
+            throw new Error("[AgentWallet] AGGR not configured. Pass aggrConfig to use swap quotes.");
+        }
+        const fromAddress = this.getAssetAddress(fromAsset);
+        const toAddress = this.getAssetAddress(toAsset);
+        const quote = await this.aggrClient.getSwapQuote(fromAddress, toAddress, amount, this.config.componentAddress);
+        return {
+            outputTokens: quote.outputTokens,
+            price: quote.outputTokens / amount,
+        };
+    }
+}
+exports.AgentWallet = AgentWallet;
+//# sourceMappingURL=AgentWallet.js.map