nyxora 26.6.20 → 26.6.21

package/dist/packages/core/src/web3/skills/limitOrder.js

@@ -1,106 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.submitLimitOrder1inch = submitLimitOrder1inch;
-const config_1 = require("../config");
-const tokens_1 = require("../utils/tokens");
-const vaultClient_1 = require("../utils/vaultClient");
-const viem_1 = require("viem");
-async function submitLimitOrder1inch(chainName, fromToken, toToken, amountStr, targetPriceUsd, condition) {
-    try {
-        const userAddress = await (0, config_1.getAddress)();
-        let makerAsset = (0, tokens_1.resolveToken)(fromToken, chainName);
-        let takerAsset = (0, tokens_1.resolveToken)(toToken, chainName);
-        // 1inch limit orders don't support native ETH directly, MUST use WETH
-        if (makerAsset === "0x0000000000000000000000000000000000000000") {
-            makerAsset = (0, tokens_1.resolveToken)("W" + fromToken, chainName);
-        }
-        if (takerAsset === "0x0000000000000000000000000000000000000000") {
-            takerAsset = (0, tokens_1.resolveToken)("W" + toToken, chainName);
-        }
-        // Fetch chain ID from config based on chainName
-        const chainMap = {
-            'mainnet': 1, 'base': 8453, 'arbitrum': 42161, 'polygon': 137, 'optimism': 10, 'bsc': 56
-        };
-        const chainId = chainMap[chainName.toLowerCase()] || 1;
-        // Mocking the amount. In reality we need to calculate exact makingAmount/takingAmount based on target price
-        const makingAmount = (0, viem_1.parseUnits)(amountStr, 18).toString();
-        const takingAmount = (0, viem_1.parseUnits)((parseFloat(amountStr) * targetPriceUsd).toString(), 18).toString();
-        const contractAddress = '0x1111111254eeb25477b68fb85ed929f73a960582'; // 1inch Limit Order Protocol V4 address
-        // Dynamically import to prevent ESM loader crash at startup
-        // @ts-ignore
-        const { LimitOrderBuilder, Web3ProviderConnector } = await Promise.resolve().then(() => __importStar(require('@1inch/limit-order-protocol-utils'))).catch(() => require('@1inch/limit-order-protocol-utils'));
-        // We use a dummy provider connector since we only need offline EIP-712 typing
-        const dummyProvider = {
-            signTypedData: async () => '',
-            ethCall: async () => ''
-        };
-        const connector = new Web3ProviderConnector(dummyProvider);
-        const limitOrderBuilder = new LimitOrderBuilder(connector, {
-            domainName: '1inch Limit Order Protocol',
-            version: '4'
-        });
-        const order = limitOrderBuilder.buildLimitOrder({
-            makerAsset,
-            takerAsset,
-            maker: userAddress,
-            makingAmount,
-            takingAmount,
-        });
-        const typedData = limitOrderBuilder.buildLimitOrderTypedData(order, BigInt(chainId), contractAddress);
-        // Sign offline using our secure vault
-        // @ts-ignore
-        const signature = await (0, vaultClient_1.signTypedData)(typedData.domain, typedData.types, typedData.primaryType, typedData.message);
-        const payload = {
-            orderHash: limitOrderBuilder.buildLimitOrderHash(typedData),
-            signature,
-            data: order
-        };
-        // Submit to 1inch API
-        const res = await fetch(`https://limit-orders.1inch.io/v4.0/${chainId}/limit-order`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(payload)
-        });
-        if (!res.ok) {
-            const err = await res.text();
-            throw new Error(`1inch API Error: ${err}`);
-        }
-        return `Limit order successfully placed via 1inch. It is now off-chain and completely gasless. Order Hash: ${payload.orderHash}`;
-    }
-    catch (error) {
-        throw new Error(`Failed to create 1inch limit order: ${error.message}`);
-    }
-}

package/dist/packages/core/src/web3/utils/protocolRegistry.js

@@ -1,46 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadRegistry = loadRegistry;
-exports.saveRegistry = saveRegistry;
-exports.getProtocol = getProtocol;
-exports.updateProtocol = updateProtocol;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const REGISTRY_PATH = path_1.default.join(process.env.HOME || process.env.USERPROFILE || '', '.nyxora', 'data', 'verified_protocols.json');
-function loadRegistry() {
-    if (!fs_1.default.existsSync(REGISTRY_PATH)) {
-        return {};
-    }
-    try {
-        const data = fs_1.default.readFileSync(REGISTRY_PATH, 'utf8');
-        return JSON.parse(data);
-    }
-    catch (error) {
-        console.error("Failed to load protocol registry:", error);
-        return {};
-    }
-}
-function saveRegistry(data) {
-    try {
-        const dir = path_1.default.dirname(REGISTRY_PATH);
-        if (!fs_1.default.existsSync(dir)) {
-            fs_1.default.mkdirSync(dir, { recursive: true });
-        }
-        fs_1.default.writeFileSync(REGISTRY_PATH, JSON.stringify(data, null, 2));
-    }
-    catch (error) {
-        console.error("Failed to save protocol registry:", error);
-    }
-}
-function getProtocol(name) {
-    const registry = loadRegistry();
-    return registry[name.toLowerCase()] || null;
-}
-function updateProtocol(name, entry) {
-    const registry = loadRegistry();
-    registry[name.toLowerCase()] = entry;
-    saveRegistry(registry);
-}

package/dist/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["../launcher.ts","../packages/core/src/test-all-routers.ts","../packages/core/src/test-router.ts","../packages/core/src/test_security.ts","../packages/core/src/agent/reasoning.ts","../packages/core/src/agent/transactionManager.ts","../packages/core/src/agent/updateProfile.ts","../packages/core/src/config/defiConfigManager.ts","../packages/core/src/config/parser.ts","../packages/core/src/config/paths.ts","../packages/core/src/gateway/cli.ts","../packages/core/src/gateway/doctor.ts","../packages/core/src/gateway/googleAuthModule.ts","../packages/core/src/gateway/legalGenerator.ts","../packages/core/src/gateway/server.ts","../packages/core/src/gateway/setup-cli.ts","../packages/core/src/gateway/setup.ts","../packages/core/src/gateway/telegram.ts","../packages/core/src/gateway/test.ts","../packages/core/src/gateway/tracker.ts","../packages/core/src/memory/episodic.ts","../packages/core/src/memory/logger.ts","../packages/core/src/memory/promotionEngine.ts","../packages/core/src/memory/reflection.ts","../packages/core/src/memory/validator.ts","../packages/core/src/system/pluginManager.ts","../packages/core/src/system/skills/analyzeDocument.ts","../packages/core/src/system/skills/audioTranscribe.ts","../packages/core/src/system/skills/browseWeb.ts","../packages/core/src/system/skills/editFile.ts","../packages/core/src/system/skills/executeShell.ts","../packages/core/src/system/skills/generateExcel.ts","../packages/core/src/system/skills/gitManager.ts","../packages/core/src/system/skills/googleWorkspace.ts","../packages/core/src/system/skills/installSkill.ts","../packages/core/src/system/skills/notionWorkspace.ts","../packages/core/src/system/skills/readFile.ts","../packages/core/src/system/skills/searchWeb.ts","../packages/core/src/system/skills/summarizeText.ts","../packages/core/src/system/skills/updateSecurityPolicy.ts","../packages/core/src/system/skills/writeFile.ts","../packages/core/src/system/skills/xManager.ts","../packages/core/src/utils/dynamicTokenUpdater.ts","../packages/core/src/utils/formatter.ts","../packages/core/src/utils/httpClient.ts","../packages/core/src/utils/safeLogger.ts","../packages/core/src/utils/skillManager.ts","../packages/core/src/utils/state.ts","../packages/core/src/utils/userWhitelistManager.ts","../packages/core/src/web3/config.ts","../packages/core/src/web3/aggregator/aggregatorMainnet.ts","../packages/core/src/web3/aggregator/aggregatorTestnet.ts","../packages/core/src/web3/aggregator/defiRouter.ts","../packages/core/src/web3/skills/bridgeToken.ts","../packages/core/src/web3/skills/checkAddress.ts","../packages/core/src/web3/skills/checkPortfolio.ts","../packages/core/src/web3/skills/checkRegistryStatus.ts","../packages/core/src/web3/skills/checkSecurity.ts","../packages/core/src/web3/skills/customTx.ts","../packages/core/src/web3/skills/defiLending.ts","../packages/core/src/web3/skills/executeDefi.ts","../packages/core/src/web3/skills/getBalance.ts","../packages/core/src/web3/skills/getMyAddress.ts","../packages/core/src/web3/skills/getPrice.ts","../packages/core/src/web3/skills/getTxHistory.ts","../packages/core/src/web3/skills/manageCustomTokens.ts","../packages/core/src/web3/skills/marketAnalysis.ts","../packages/core/src/web3/skills/mintNft.ts","../packages/core/src/web3/skills/provideLiquidity.ts","../packages/core/src/web3/skills/revokeApprovals.ts","../packages/core/src/web3/skills/swapToken.ts","../packages/core/src/web3/skills/transfer.ts","../packages/core/src/web3/skills/yieldVault.ts","../packages/core/src/web3/utils/chains.ts","../packages/core/src/web3/utils/marketEngine.ts","../packages/core/src/web3/utils/portfolioNormalizer.ts","../packages/core/src/web3/utils/routers.ts","../packages/core/src/web3/utils/rpcEngine.ts","../packages/core/src/web3/utils/tokens.ts","../packages/core/src/web3/utils/vaultClient.ts","../packages/core/src/web3/utils/zerionTracker.ts","../packages/policy/src/server.ts","../packages/signer/src/crypto.ts","../packages/signer/src/server.ts"],"version":"6.0.3"}

package/packages/core/src/__tests__/reasoning.test.ts

@@ -1,81 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { processUserInput } from '../agent/reasoning';
-
-// Mock dependencies
-vi.mock('../agent/openai', () => {
-  return {
-    getOpenAI: vi.fn().mockResolvedValue({
-      chat: {
-        completions: {
-          create: vi.fn().mockResolvedValue({
-            choices: [{
-              message: {
-                content: null,
-                tool_calls: [{
-                  id: "call_123",
-                  type: "function",
-                  function: {
-                    name: "transfer",
-                    // Malformed JSON that would break JSON.parse
-                    arguments: "{\"amount\": \"1\", \"toAddress\": \"0x123\"" 
-                  }
-                }]
-              }
-            }]
-          })
-        }
-      }
-    })
-  };
-});
-
-vi.mock('../memory/logger', () => {
-  return {
-    logger: {
-      getHistory: vi.fn().mockReturnValue([]),
-      addEntry: vi.fn()
-    },
-    Logger: class MockLogger {
-      getHistory() { return []; }
-      addEntry() {}
-    }
-  };
-});
-
-vi.mock('../memory/episodic', () => {
-  return {
-    episodicDB: {
-      getMemories: vi.fn().mockReturnValue([]),
-      addCandidateFact: vi.fn(),
-      decayMemories: vi.fn(),
-      deleteMemory: vi.fn()
-    }
-  };
-});
-
-vi.mock('../config', () => {
-  return {
-    loadConfig: vi.fn().mockReturnValue({ agent: { default_model: "gpt-4o" } })
-  };
-});
-
-vi.mock('../utils/userWhitelistManager', () => {
-  return {
-    getUserWhitelist: vi.fn().mockReturnValue({})
-  };
-});
-
-describe('Agent Reasoning Pipeline', () => {
-  it('should not crash when LLM returns malformed JSON arguments', async () => {
-    // If it crashes, this promise will reject and the test will fail
-    // If the catch block in reasoning.ts works correctly, it should gracefully loop and return an error message string
-    
-    const response = await processUserInput('transfer 1 eth to 0x123', 'user', undefined, 'test-session');
-    
-    // The agent should detect the JSON error and feedback to the LLM or return an error string
-    // depending on the max iteration limit. Since we mocked the LLM to ALWAYS return bad JSON,
-    // it will hit the max iterations (5) and eventually return a fallback string or last message.
-    expect(typeof response).toBe('string');
-    // Ensure it doesn't throw a "TypeError: executeReasoningLoop is not a function"
-  }, 10000); // 10s timeout just in case it loops
-});

package/packages/core/src/__tests__/tokens.test.ts

@@ -1,55 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { getTokenMetadata } from '../web3/utils/tokens';
-
-describe('Token Metadata Cache', () => {
-  it('should return native token metadata without RPC calls', async () => {
-    const mockClient = {
-      chain: { id: 1 },
-      readContract: vi.fn()
-    };
-    
-    const meta = await getTokenMetadata(mockClient as any, "0x0000000000000000000000000000000000000000");
-    expect(meta.decimals).toBe(18);
-    expect(meta.symbol).toBe("ETH/BNB/MATIC");
-    expect(mockClient.readContract).not.toHaveBeenCalled();
-  });
-
-  it('should fetch from RPC on first call and cache on subsequent calls', async () => {
-    const mockClient = {
-      chain: { id: 1 },
-      multicall: vi.fn().mockImplementation(async () => {
-        return [
-          { status: 'success', result: 6 },
-          { status: 'success', result: 'USDC' }
-        ];
-      })
-    };
-
-    const tokenAddr = "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"; // USDC
-    
-    // First call: Should hit RPC (1 multicall)
-    const meta1 = await getTokenMetadata(mockClient as any, tokenAddr);
-    expect(meta1.decimals).toBe(6);
-    expect(meta1.symbol).toBe("USDC");
-    expect(mockClient.multicall).toHaveBeenCalledTimes(1);
-
-    // Second call: Should return from cache instantly, no new RPC calls
-    const meta2 = await getTokenMetadata(mockClient as any, tokenAddr);
-    expect(meta2.decimals).toBe(6);
-    expect(meta2.symbol).toBe("USDC");
-    expect(mockClient.multicall).toHaveBeenCalledTimes(1); // Still 1
-  });
-
-  it('should handle RPC failures gracefully by using fallback values', async () => {
-    const mockClient = {
-      chain: { id: 1 },
-      multicall: vi.fn().mockRejectedValue(new Error("RPC Error"))
-    };
-
-    const tokenAddr = "0xunknown123456789012345678901234567890123";
-    
-    const meta = await getTokenMetadata(mockClient as any, tokenAddr);
-    expect(meta.decimals).toBe(18); // Fallback
-    expect(meta.symbol).toBe("TOKEN"); // Fallback
-  });
-});

package/packages/core/src/__tests__/web3.test.ts

@@ -1,50 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { executeTransfer } from '../web3/skills/transfer';
-
-// Mock dependencies
-vi.mock('../web3/config', async (importOriginal) => {
-  const actual: any = await importOriginal();
-  return {
-    ...actual,
-    getPublicClient: vi.fn(),
-    getAddress: vi.fn().mockResolvedValue("0x123"),
-    CHAIN_IDS: { ethereum: 1 }
-  };
-});
-
-describe('Web3 Action Safety Nets', () => {
-  beforeEach(() => {
-    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-      ok: true,
-      json: vi.fn().mockResolvedValue({ signedHash: "0xabc" })
-    }));
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('executeTransfer should include AbortSignal.timeout(30000)', async () => {
-    const params = {
-      toAddress: "0xabc",
-      amountStr: "1.0",
-      tokenAddress: "0x0000000000000000000000000000000000000000",
-      isNative: true,
-      decimals: 18
-    };
-
-    await executeTransfer('ethereum', params, false);
-
-    const fetchMock = global.fetch as any;
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-    
-    const callArgs = fetchMock.mock.calls[0];
-    const fetchOptions = callArgs[1];
-    
-    expect(fetchOptions).toHaveProperty('signal');
-    // We cannot easily test AbortSignal instance type directly in jsdom without polyfills, 
-    // but we can check if it's an object with aborted property (standard AbortSignal shape)
-    expect(typeof fetchOptions.signal).toBe('object');
-    expect('aborted' in fetchOptions.signal).toBe(true);
-  });
-});

package/packages/core/src/agent/reasoning.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reasoning.d.ts","sourceRoot":"","sources":["reasoning.ts"],"names":[],"mappings":"AAkBA,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAmFrE"}

package/packages/core/src/config/parser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["parser.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE;QACL,IAAI,EAAE,MAAM,CAAC;QACb,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;IACF,GAAG,EAAE;QACH,QAAQ,EAAE,QAAQ,GAAG,WAAW,GAAG,QAAQ,CAAC;QAC5C,KAAK,EAAE,MAAM,CAAC;QACd,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;IACF,MAAM,EAAE;QACN,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;CACH;AAED,wBAAgB,UAAU,IAAI,aAAa,CAc1C"}

package/packages/core/src/gateway/cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["cli.ts"],"names":[],"mappings":""}

package/packages/core/src/memory/logger.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["logger.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,QAAQ,GAAG,MAAM,CAAC;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,GAAG,EAAE,CAAC;CACpB;AAED,qBAAa,MAAM;IACjB,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,MAAM,CAAqB;;IAQnC,OAAO,CAAC,UAAU;IAYlB,OAAO,CAAC,UAAU;IAQX,UAAU,IAAI,WAAW,EAAE;IAI3B,QAAQ,CAAC,KAAK,EAAE,WAAW;IAK3B,KAAK;CAIb"}

package/packages/core/src/test-all-routers.ts

@@ -1,59 +0,0 @@
-import { prepareSwapToken } from './web3/skills/swapToken';
-import * as configModule from './web3/config';
-
-// Mock getAddress to bypass Vault lock
-(configModule as any).getAddress = async () => "0x28C6c06298d514Db089934071355E22Af1257125"; // dummy address
-
-const CHAINS = ["ethereum", "bsc", "base", "arbitrum", "optimism", "polygon"] as const;
-const ROUTERS = ["auto", "lifi", "relay", "uniswap_v2", "uniswap_v3", "pancakeswap", "1inch", "cowswap"] as const;
-
-// Helper to get native and stablecoin addresses per chain
-const TOKENS: Record<string, { in: string, out: string }> = {
-  ethereum: { in: "0x0000000000000000000000000000000000000000", out: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" }, // ETH to USDC
-  bsc: { in: "0x0000000000000000000000000000000000000000", out: "0x55d398326f99059fF775485246999027B3197955" }, // BNB to USDT
-  base: { in: "0x0000000000000000000000000000000000000000", out: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" }, // ETH to USDC
-  arbitrum: { in: "0x0000000000000000000000000000000000000000", out: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831" }, // ETH to USDC
-  optimism: { in: "0x0000000000000000000000000000000000000000", out: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85" }, // ETH to USDC
-  polygon: { in: "0x0000000000000000000000000000000000000000", out: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359" }  // MATIC to USDC
-};
-
-async function runAllTests() {
-  console.log("=== COMPREHENSIVE ROUTER TEST ===");
-  
-  for (const chain of CHAINS) {
-    console.log(`\n--- 🌐 Testing Chain: ${chain.toUpperCase()} ---`);
-    const { in: fromToken, out: toToken } = TOKENS[chain];
-    
-    const providers: Array<"auto" | "1inch" | "lifi" | "relay" | "openocean" | "kyberswap" | "0x"> = [
-      "1inch",
-      "0x",
-      "lifi",
-      "openocean",
-      "kyberswap"
-    ];
-
-    for (const router of providers) {
-      try {
-        const res = await prepareSwapToken(
-          chain,
-          fromToken,
-          toToken,
-          "0.01",
-          "manual",
-          router
-        );
-        // Extract just the success info to keep logs readable
-        const outputMatch = res.match(/Expected Output: ~([\d.]+) /);
-        if (outputMatch) {
-          console.log(`[✅ SUCCESS] ${router.padEnd(15)} -> Quote: ~${outputMatch[1]} USDC/USDT`);
-        } else {
-          console.log(`[⚠️ PENDING] ${router.padEnd(15)} -> ${res.substring(0, 50)}...`);
-        }
-      } catch (err: any) {
-        console.log(`[❌ FAILED]  ${router.padEnd(15)} -> ${err.message.split('\\n')[0]}`);
-      }
-    }
-  }
-}
-
-runAllTests();

package/packages/core/src/test-router.ts

@@ -1,49 +0,0 @@
-import { prepareSwapToken } from './web3/skills/swapToken';
-
-async function runTest() {
-  console.log("=== Testing Native Routers ===");
-
-  try {
-    // 1. Test Uniswap V2
-    // 1. Test 1inch
-    console.log("\n[Test 1] Testing 1inch route (ETH to USDC on Base)...");
-    const resV2 = await prepareSwapToken(
-      "base", // chain
-      "0x0000000000000000000000000000000000000000", // ETH native
-      "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", // USDC on Base
-      "0.001", // amount
-      "manual", // mode
-      "1inch" // providerName
-    );
-    console.log("Result 1 (1inch):", resV2);
-
-    // 2. Test 0x
-    console.log("\n[Test 2] Testing 0x route (WETH to USDT on Ethereum)...");
-    const resCow = await prepareSwapToken(
-      "ethereum", // chain
-      "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
-      "0xdAC17F958D2ee523a2206206994597C13D831ec7", // USDT
-      "0.1", // 0.1 ETH
-      "auto", // mode
-      "0x" // providerName
-    );
-    console.log("Result 0x:", resCow);
-    
-    // 3. Test Auto
-    console.log("\n[Test 3] Testing Auto route...");
-    const resAuto = await prepareSwapToken(
-      "base",
-      "0x0000000000000000000000000000000000000000",
-      "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-      "0.001",
-      "auto"
-    );
-    console.log("Result Auto:", resAuto);
-
-    console.log("\\nAll tests completed!");
-  } catch (error: any) {
-    console.error("\\nTEST FAILED:", error.message);
-  }
-}
-
-runTest();

package/packages/core/src/web3/config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["config.ts"],"names":[],"mappings":"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"}

package/packages/core/src/web3/skills/getBalance.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getBalance.d.ts","sourceRoot":"","sources":["getBalance.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,SAAS,EAAE,MAAM,WAAW,CAAC;AAEvD,wBAAsB,UAAU,CAAC,SAAS,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,KAAK,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAkB/F;AAED,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;CAqBpC,CAAC"}