@coinbase/agentkit 0.10.2 → 0.10.4

package/dist/action-providers/sushi/sushiRouterActionProvider.test.js

@@ -0,0 +1,392 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sushiRouterSchemas_1 = require("./sushiRouterSchemas");
+const evm_1 = require("sushi/evm");
+const sushiRouterActionProvider_1 = require("./sushiRouterActionProvider");
+const viem_1 = require("viem");
+const constants_1 = require("./constants");
+// Mock the entire module
+jest.mock("sushi/evm", () => {
+    const originalModule = jest.requireActual("sushi/evm");
+    return {
+        __esModule: true,
+        ...originalModule,
+        getSwap: jest.fn(originalModule.getSwap),
+    };
+});
+const mockedGetSwap = evm_1.getSwap;
+describe("Sushi Action Provider Input Schemas", () => {
+    describe("Swap Schema", () => {
+        it("should successfully parse valid input", () => {
+            const validInput = {
+                fromAssetAddress: "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83",
+                amount: "0.0001",
+                toAssetAddress: "0x1234567890123456789012345678901234567890",
+                maxSlippage: 0.005,
+            };
+            const result = sushiRouterSchemas_1.SushiSwapSchema.safeParse(validInput);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(validInput);
+        });
+        it("should fail parsing invalid fromAssetAddress", () => {
+            const invalidInput = {
+                fromAssetAddress: "invalid-address",
+                amount: "0.0001",
+                toAssetAddress: "0x1234567890123456789012345678901234567890",
+                maxSlippage: 0.005,
+            };
+            const result = sushiRouterSchemas_1.SushiSwapSchema.safeParse(invalidInput);
+            expect(result.success).toBe(false);
+        });
+        it("should fail parsing invalid toAssetAddress", () => {
+            const invalidInput = {
+                fromAssetAddress: "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83",
+                amount: "0.0001",
+                toAssetAddress: "invalid-address",
+                maxSlippage: 0.005,
+            };
+            const result = sushiRouterSchemas_1.SushiSwapSchema.safeParse(invalidInput);
+            expect(result.success).toBe(false);
+        });
+        it("should fail parsing invalid maxSlippage (>1)", () => {
+            const invalidInput = {
+                fromAssetAddress: "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83",
+                amount: "0.0001",
+                toAssetAddress: "0x1234567890123456789012345678901234567890",
+                maxSlippage: 1.1,
+            };
+            const result = sushiRouterSchemas_1.SushiSwapSchema.safeParse(invalidInput);
+            expect(result.success).toBe(false);
+        });
+        it("should fail parsing invalid maxSlippage (<0)", () => {
+            const invalidInput = {
+                fromAssetAddress: "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83",
+                amount: "0.0001",
+                toAssetAddress: "0x1234567890123456789012345678901234567890",
+                maxSlippage: -1.1,
+            };
+            const result = sushiRouterSchemas_1.SushiSwapSchema.safeParse(invalidInput);
+            expect(result.success).toBe(false);
+        });
+    });
+    describe("Quote Schema", () => {
+        it("should successfully parse valid input", () => {
+            const validInput = {
+                fromAssetAddress: "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83",
+                amount: "0.0001",
+                toAssetAddress: "0x1234567890123456789012345678901234567890",
+            };
+            const result = sushiRouterSchemas_1.SushiQuoteSchema.safeParse(validInput);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(validInput);
+        });
+        it("should fail parsing invalid fromAssetAddress", () => {
+            const invalidInput = {
+                fromAssetAddress: "invalid-address",
+                amount: "0.0001",
+                toAssetAddress: "0x1234567890123456789012345678901234567890",
+                maxSlippage: 0.005,
+            };
+            const result = sushiRouterSchemas_1.SushiQuoteSchema.safeParse(invalidInput);
+            expect(result.success).toBe(false);
+        });
+        it("should fail parsing invalid toAssetAddress", () => {
+            const invalidInput = {
+                fromAssetAddress: "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83",
+                amount: "0.0001",
+                toAssetAddress: "invalid-address",
+                maxSlippage: 0.005,
+            };
+            const result = sushiRouterSchemas_1.SushiQuoteSchema.safeParse(invalidInput);
+            expect(result.success).toBe(false);
+        });
+    });
+});
+describe("Sushi Action Provider", () => {
+    let actionProvider;
+    let mockWallet;
+    const amountIn = BigInt(1000000);
+    const amountOut = BigInt(500000);
+    const nativeToken = {
+        address: evm_1.nativeAddress,
+        symbol: "ETH",
+        name: "Ether",
+        decimals: 18,
+    };
+    const tokenIn = {
+        address: "0xaAaAaAaaAaAaAaaAaAAAAAAAAaaaAaAaAaaAaaAa",
+        symbol: "TIN",
+        name: "Token In",
+        decimals: 18,
+    };
+    const tokenOut = {
+        address: "0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB",
+        symbol: "TOU",
+        name: "Token Out",
+        decimals: 18,
+    };
+    const user = "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF";
+    const txHash = "0xhash";
+    const chainId = 1;
+    const getRouteLog = ({ tokenIn, tokenOut, amountIn, amountOut, }) => [
+        {
+            data: (0, viem_1.encodeAbiParameters)((0, viem_1.parseAbiParameters)("address to, address tokenOut, uint256 amountIn, uint256 amountOut, int256 slippage, bytes32 diagnosticsFirst32"), [user, tokenOut.address, amountIn, amountOut, 0n, `0x${"00".repeat(32)}`]),
+            topics: (0, viem_1.encodeEventTopics)({
+                abi: constants_1.routeProcessor9Abi_Route,
+                eventName: "Route",
+                args: {
+                    from: user,
+                    tokenIn: tokenIn.address,
+                    referralCode: 0,
+                },
+            }),
+        },
+    ];
+    const getSuccessfullSwapResponse = async ({ tokenIn, amountIn, tokenOut, amountOut, }) => ({
+        amountIn: String(amountIn),
+        assumedAmountOut: String(amountOut),
+        priceImpact: 0,
+        status: evm_1.RouteStatus.Success,
+        swapPrice: 1,
+        tokens: [tokenIn, tokenOut],
+        tokenFrom: tokenIn,
+        tokenTo: tokenOut,
+        tx: {
+            to: "0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC",
+            data: "0x",
+            from: user,
+            value: BigInt(0),
+            gas: "1000000",
+            gasPrice: 1000000000,
+        },
+    });
+    beforeEach(() => {
+        // Reset all mocks before each test
+        jest.clearAllMocks();
+        actionProvider = new sushiRouterActionProvider_1.SushiRouterActionProvider();
+        mockWallet = {
+            readContract: jest.fn(),
+            sendTransaction: jest.fn(),
+            waitForTransactionReceipt: jest.fn(),
+            getBalance: jest.fn(),
+            getNetwork: jest.fn().mockResolvedValue({
+                protocolFamily: "evm",
+                networkId: "ethereum-mainnet",
+                chainId: String(chainId),
+            }),
+            getAddress: jest.fn().mockReturnValue(user),
+        };
+    });
+    describe("swap", () => {
+        it("should successfully perform a swap (token -> token)", async () => {
+            const args = {
+                amount: (0, viem_1.formatUnits)(amountIn, tokenIn.decimals),
+                fromAssetAddress: tokenIn.address,
+                toAssetAddress: tokenOut.address,
+                maxSlippage: 0.005,
+            };
+            /*
+             * 1. Mock the readContract which checks the decimals of the fromAssetAddress token (18, default)
+             * 2. Mock the readContract which checks for the balance of the fromAssetAddress token (1000000, enough balance)
+             * 3. Mock the readContract which checks for the approval (0, not approved)
+             */
+            mockWallet.readContract
+                .mockResolvedValueOnce(tokenIn.decimals)
+                .mockResolvedValueOnce(amountIn)
+                .mockResolvedValueOnce(BigInt(0));
+            mockWallet.sendTransaction.mockResolvedValue(txHash);
+            /*
+             * 1. Mock the waitForTransactionReceipt to return success for the approval tx
+             * 2. Mock the waitForTransactionReceipt to return success for the swap tx, including the Route log
+             */
+            mockWallet.waitForTransactionReceipt
+                .mockResolvedValueOnce({
+                status: "success",
+            })
+                .mockResolvedValueOnce({
+                status: "success",
+                logs: getRouteLog({
+                    tokenIn,
+                    tokenOut,
+                    amountIn,
+                    amountOut,
+                }),
+            });
+            mockedGetSwap.mockReturnValue(getSuccessfullSwapResponse({
+                tokenIn,
+                amountIn,
+                tokenOut,
+                amountOut,
+            }));
+            const result = await actionProvider.swap(mockWallet, args);
+            expect(mockWallet.readContract).toHaveBeenCalledTimes(3); // Decimals + Balance + Approval
+            expect(mockWallet.sendTransaction).toHaveBeenCalledTimes(2); // Approval + Swap
+            expect(mockedGetSwap).toHaveBeenCalledTimes(2);
+            expect(result).toContain(`Swapped ${(0, viem_1.formatUnits)(amountIn, tokenIn.decimals)} of ${tokenIn.symbol} (${tokenIn.address}) for ${(0, viem_1.formatUnits)(amountOut, tokenOut.decimals)} of ${tokenOut.symbol} (${tokenOut.address})`);
+            expect(result).toContain(`Transaction hash: ${txHash}`);
+            expect(result).toContain(`Transaction link: ${(0, evm_1.getEvmChainById)(chainId).getTransactionUrl(txHash)}`);
+            expect(result).toContain(`on ${(0, evm_1.getEvmChainById)(chainId).shortName}`);
+        });
+        it("should successfully perform a swap (native -> token)", async () => {
+            const args = {
+                amount: (0, viem_1.formatUnits)(amountIn, tokenIn.decimals),
+                fromAssetAddress: nativeToken.address,
+                toAssetAddress: tokenOut.address,
+                maxSlippage: 0.005,
+            };
+            // Mock the readContract which checks for the balance of the fromAssetAddress token (1000000, enough balance)
+            mockWallet.getBalance.mockResolvedValue(amountIn);
+            mockWallet.sendTransaction.mockResolvedValue(txHash);
+            // Mock the waitForTransactionReceipt to return success for the swap tx, including the Route log
+            mockWallet.waitForTransactionReceipt.mockResolvedValueOnce({
+                status: "success",
+                logs: getRouteLog({
+                    tokenIn: nativeToken,
+                    tokenOut,
+                    amountIn,
+                    amountOut,
+                }),
+            });
+            mockedGetSwap.mockReturnValue(getSuccessfullSwapResponse({
+                tokenIn: nativeToken,
+                amountIn,
+                tokenOut,
+                amountOut,
+            }));
+            const result = await actionProvider.swap(mockWallet, args);
+            expect(mockWallet.getBalance).toHaveBeenCalledTimes(1);
+            expect(mockWallet.readContract).toHaveBeenCalledTimes(0); // No balance check nor approval
+            expect(mockWallet.sendTransaction).toHaveBeenCalledTimes(1); // Swap
+            expect(mockedGetSwap).toHaveBeenCalledTimes(2);
+            expect(result).toContain(`Swapped ${(0, viem_1.formatUnits)(amountIn, nativeToken.decimals)} of ${nativeToken.symbol} (${nativeToken.address}) for ${(0, viem_1.formatUnits)(amountOut, tokenOut.decimals)} of ${tokenOut.symbol} (${tokenOut.address})`);
+            expect(result).toContain(`Transaction hash: ${txHash}`);
+            expect(result).toContain(`Transaction link: ${(0, evm_1.getEvmChainById)(chainId).getTransactionUrl(txHash)}`);
+            expect(result).toContain(`on ${(0, evm_1.getEvmChainById)(chainId).shortName}`);
+        });
+        it("should fail if there isn't enough balance (native)", async () => {
+            const args = {
+                amount: (0, viem_1.formatUnits)(amountIn, tokenIn.decimals),
+                fromAssetAddress: nativeToken.address,
+                toAssetAddress: tokenOut.address,
+                maxSlippage: 0.005,
+            };
+            // Mock the readContract which checks for the balance of the fromAssetAddress token (99, not enough balance)
+            mockWallet.getBalance.mockResolvedValue(amountIn - BigInt(1));
+            const result = await actionProvider.swap(mockWallet, args);
+            expect(mockWallet.getBalance).toHaveBeenCalledTimes(1);
+            expect(mockWallet.readContract).toHaveBeenCalledTimes(0);
+            expect(mockWallet.sendTransaction).toHaveBeenCalledTimes(0);
+            expect(mockedGetSwap).toHaveBeenCalledTimes(1);
+            expect(result).toContain(`Swap failed: Insufficient balance for ${nativeToken.symbol} (${nativeToken.address})`);
+        });
+        it("should fail if there isn't enough balance (token)", async () => {
+            const args = {
+                amount: (0, viem_1.formatUnits)(amountIn, tokenIn.decimals),
+                fromAssetAddress: tokenIn.address,
+                toAssetAddress: tokenOut.address,
+                maxSlippage: 0.005,
+            };
+            /*
+             * 1. Mock the readContract which checks the decimals of the fromAssetAddress token (18, default)
+             * 2. Mock the readContract which checks for the balance of the fromAssetAddress token (1000000, enough balance)
+             */
+            mockWallet.readContract.mockResolvedValueOnce(18).mockResolvedValue(amountIn - BigInt(1));
+            mockedGetSwap.mockReturnValue(getSuccessfullSwapResponse({
+                tokenIn,
+                amountIn,
+                tokenOut,
+                amountOut,
+            }));
+            const result = await actionProvider.swap(mockWallet, args);
+            expect(mockWallet.getBalance).toHaveBeenCalledTimes(0);
+            expect(mockWallet.readContract).toHaveBeenCalledTimes(2);
+            expect(mockWallet.sendTransaction).toHaveBeenCalledTimes(0);
+            expect(mockedGetSwap).toHaveBeenCalledTimes(1);
+            expect(result).toContain(`Swap failed: Insufficient balance for ${tokenIn.symbol} (${tokenIn.address})`);
+        });
+        it("should not approve if already approved", async () => {
+            const args = {
+                amount: (0, viem_1.formatUnits)(amountIn, tokenIn.decimals),
+                fromAssetAddress: tokenIn.address,
+                toAssetAddress: tokenOut.address,
+                maxSlippage: 0.005,
+            };
+            /*
+             * 1. Mock the readContract which checks the decimals of the fromAssetAddress token (18, default)
+             * 2. Mock the readContract which checks for the balance of the fromAssetAddress token (1000000, enough balance)
+             * 3. Mock the readContract which checks for the approval (1000000, approved)
+             */
+            mockWallet.readContract
+                .mockResolvedValueOnce(tokenIn.decimals)
+                .mockResolvedValueOnce(amountIn)
+                .mockResolvedValueOnce(amountIn);
+            mockWallet.sendTransaction.mockResolvedValue(txHash);
+            // Mock the waitForTransactionReceipt to return success for the swap tx, including the Route log
+            mockWallet.waitForTransactionReceipt.mockResolvedValueOnce({
+                status: "success",
+                logs: getRouteLog({
+                    tokenIn,
+                    tokenOut,
+                    amountIn,
+                    amountOut,
+                }),
+            });
+            mockedGetSwap.mockReturnValue(getSuccessfullSwapResponse({
+                tokenIn,
+                amountIn,
+                tokenOut,
+                amountOut,
+            }));
+            const result = await actionProvider.swap(mockWallet, args);
+            expect(mockWallet.getBalance).toHaveBeenCalledTimes(0);
+            expect(mockWallet.readContract).toHaveBeenCalledTimes(3); // Decimals + Balance + Allowance
+            expect(mockWallet.sendTransaction).toHaveBeenCalledTimes(1); // Swap
+            expect(mockedGetSwap).toHaveBeenCalledTimes(2);
+            expect(result).toContain(`Swapped`);
+        });
+        it("should fail if there's no route", async () => {
+            const args = {
+                amount: (0, viem_1.formatUnits)(amountIn, tokenIn.decimals),
+                fromAssetAddress: tokenIn.address,
+                toAssetAddress: tokenOut.address,
+                maxSlippage: 0.005,
+            };
+            /*
+             * 1. Mock the readContract which checks for decimals of the fromAssetAddress token (18, default)
+             * 2. Mock the readContract which checks for the balance of the fromAssetAddress token (1000000, enough balance)
+             */
+            mockWallet.readContract
+                .mockResolvedValueOnce(tokenIn.decimals)
+                .mockResolvedValueOnce(amountIn);
+            mockedGetSwap.mockReturnValue(new Promise(r => r({
+                status: evm_1.RouteStatus.NoWay,
+            })));
+            const result = await actionProvider.swap(mockWallet, args);
+            expect(mockWallet.getBalance).toHaveBeenCalledTimes(0);
+            expect(mockWallet.readContract).toHaveBeenCalledTimes(1); // Decimals
+            expect(mockWallet.sendTransaction).toHaveBeenCalledTimes(0);
+            expect(mockedGetSwap).toHaveBeenCalledTimes(1);
+            expect(result).toContain(`No route found to swap ${amountIn} of ${tokenIn.address} for ${tokenOut.address}`);
+        });
+    });
+    describe("quote", () => {
+        it("should successfully fetch a quote (token -> token)", async () => {
+            const args = {
+                amount: (0, viem_1.formatUnits)(amountIn, tokenIn.decimals),
+                fromAssetAddress: tokenIn.address,
+                toAssetAddress: tokenOut.address,
+            };
+            mockedGetSwap.mockReturnValue(getSuccessfullSwapResponse({
+                tokenIn,
+                amountIn,
+                tokenOut,
+                amountOut,
+            }));
+            const result = await actionProvider.quote(mockWallet, args);
+            expect(mockedGetSwap).toHaveBeenCalledTimes(1);
+            expect(result).toContain(`Found a quote for ${tokenIn.symbol} (${tokenIn.address}) -> ${tokenOut.symbol} (${tokenOut.address})`);
+            expect(result).toContain(`AmountIn: ${(0, viem_1.formatUnits)(amountIn, tokenIn.decimals)}`);
+            expect(result).toContain(`AmountOut: ${(0, viem_1.formatUnits)(amountOut, tokenOut.decimals)}`);
+        });
+    });
+});

package/dist/action-providers/sushi/sushiRouterSchemas.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+/**
+ * Input schema for asset swap action
+ */
+export declare const SushiSwapSchema: z.ZodObject<{
+    fromAssetAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+    amount: z.ZodString;
+    toAssetAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+    maxSlippage: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    amount: string;
+    fromAssetAddress: `0x${string}`;
+    toAssetAddress: `0x${string}`;
+    maxSlippage: number;
+}, {
+    amount: string;
+    fromAssetAddress: string;
+    toAssetAddress: string;
+    maxSlippage?: number | undefined;
+}>;
+/**
+ * Input schema for quote action
+ */
+export declare const SushiQuoteSchema: z.ZodObject<{
+    fromAssetAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+    amount: z.ZodString;
+    toAssetAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+}, "strip", z.ZodTypeAny, {
+    amount: string;
+    fromAssetAddress: `0x${string}`;
+    toAssetAddress: `0x${string}`;
+}, {
+    amount: string;
+    fromAssetAddress: string;
+    toAssetAddress: string;
+}>;

package/dist/action-providers/sushi/sushiRouterSchemas.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SushiQuoteSchema = exports.SushiSwapSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for asset swap action
+ */
+exports.SushiSwapSchema = zod_1.z
+    .object({
+    fromAssetAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .transform(val => val)
+        .describe("The Ethereum address of the input asset"),
+    amount: zod_1.z
+        .string()
+        .regex(/^\d+(\.\d+)?$/, "Invalid number format")
+        .describe("The amount of the input asset to swap, in the human readable format"),
+    toAssetAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .transform(val => val)
+        .describe("The Ethereum address of the output asset"),
+    maxSlippage: zod_1.z
+        .number()
+        .min(0)
+        .max(1)
+        .optional()
+        .default(0.005) // 0.05%
+        .describe("The maximum slippage allowed for the swap, where 0 is 0% and 1 is 100%"),
+})
+    .strip()
+    .describe("Instructions for trading assets");
+/**
+ * Input schema for quote action
+ */
+exports.SushiQuoteSchema = zod_1.z
+    .object({
+    fromAssetAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .transform(val => val)
+        .describe("The Ethereum address of the input asset"),
+    amount: zod_1.z
+        .string()
+        .regex(/^\d+(\.\d+)?$/, "Invalid number format")
+        .describe("The amount of the input asset to get a quote for"),
+    toAssetAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .transform(val => val)
+        .describe("The Ethereum address of the output asset"),
+})
+    .strip()
+    .describe("Instructions for fetching a quote for a trade");

package/dist/action-providers/vaultsfyi/constants.d.ts

@@ -1,12 +1,8 @@
-export declare const VAULTS_API_URL = "https://api.vaults.fyi/v1";
-export declare const VAULTSFYI_SUPPORTED_CHAINS: {
-    readonly 1: "mainnet";
-    readonly 42161: "arbitrum";
-    readonly 10: "optimism";
-    readonly 137: "polygon";
-    readonly 100: "gnosis";
-    readonly 8453: "base";
-    readonly 130: "unichain";
-    readonly 1923: "swellchain";
-    readonly 42220: "celo";
-};
+export declare const SUPPORTED_CHAIN_IDS: string[];
+/**
+ * Get the network name from a chain id
+ *
+ * @param chainId - The chain id
+ * @returns The network name
+ */
+export declare function getNetworkNameFromChainId(chainId: string): string | undefined;

package/dist/action-providers/vaultsfyi/constants.js

@@ -1,15 +1,49 @@
 "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.VAULTSFYI_SUPPORTED_CHAINS = exports.VAULTS_API_URL = void 0;
-exports.VAULTS_API_URL = "https://api.vaults.fyi/v1";
-exports.VAULTSFYI_SUPPORTED_CHAINS = {
-    1: "mainnet",
-    42161: "arbitrum",
-    10: "optimism",
-    137: "polygon",
-    100: "gnosis",
-    8453: "base",
-    130: "unichain",
-    1923: "swellchain",
-    42220: "celo",
-};
+exports.SUPPORTED_CHAIN_IDS = void 0;
+exports.getNetworkNameFromChainId = getNetworkNameFromChainId;
+const sdk_1 = require("@vaultsfyi/sdk");
+const viemChains = __importStar(require("viem/chains"));
+exports.SUPPORTED_CHAIN_IDS = sdk_1.SUPPORTED_NETWORKS.map(network => viemChains[network]?.id.toString()).filter(id => id !== undefined);
+/**
+ * Get the network name from a chain id
+ *
+ * @param chainId - The chain id
+ * @returns The network name
+ */
+function getNetworkNameFromChainId(chainId) {
+    return sdk_1.SUPPORTED_NETWORKS.find(network => viemChains[network]?.id.toString() === chainId);
+}