@coinbase/agentkit 0.5.0 → 0.6.1

package/dist/action-providers/flaunch/flaunchActionProvider.test.js

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const flaunchActionProvider_1 = require("./flaunchActionProvider");
+const schemas_1 = require("./schemas");
+const viem_1 = require("viem");
+// Mock the actual contract calls with Jest
+jest.mock("viem", () => {
+    const originalModule = jest.requireActual("viem");
+    return {
+        ...originalModule,
+        createPublicClient: jest.fn().mockReturnValue({
+            simulateContract: jest.fn().mockResolvedValue({
+                result: [BigInt(1000000000000000000)],
+            }),
+        }),
+        decodeEventLog: jest.fn().mockImplementation(() => {
+            return {
+                eventName: "PoolCreated",
+                args: {
+                    _memecoin: "0x1234567890123456789012345678901234567890",
+                },
+            };
+        }),
+        parseEther: jest.fn().mockReturnValue(BigInt(100000000000000000)),
+        zeroAddress: "0x0000000000000000000000000000000000000000",
+    };
+});
+// Mock the utils module
+jest.mock("./utils", () => ({
+    generateTokenUri: jest.fn().mockResolvedValue("ipfs://test-uri"),
+    ethToMemecoin: jest.fn().mockReturnValue({
+        commands: "0x01",
+        inputs: ["0x1234"],
+    }),
+    memecoinToEthWithPermit2: jest.fn().mockReturnValue({
+        commands: "0x02",
+        inputs: ["0x5678"],
+    }),
+    getAmountWithSlippage: jest.fn().mockImplementation(amount => amount),
+    getSwapAmountsFromReceipt: jest.fn().mockImplementation(() => ({
+        coinsBought: BigInt(1000000000000000000),
+        ethSold: BigInt(100000000000000000),
+        coinsSold: BigInt(1000000000000000000),
+        ethBought: BigInt(100000000000000000),
+    })),
+}));
+// Mock the constants used in the test
+jest.mock("./constants", () => {
+    const actualConstants = jest.requireActual("./constants");
+    const baseSepolia = 84532; // Base Sepolia chain ID
+    const baseMainnet = 8453; // Base Mainnet chain ID
+    return {
+        ...actualConstants,
+        // Only override the address mappings
+        FlaunchPositionManagerAddress: {
+            "0x14a34": "0x9A7059cA00dA92843906Cb4bCa1D005cE848AFdC",
+            [baseSepolia]: "0x9A7059cA00dA92843906Cb4bCa1D005cE848AFdC",
+            [baseMainnet]: "0x51Bba15255406Cfe7099a42183302640ba7dAFDC",
+        },
+        FastFlaunchZapAddress: {
+            "0x14a34": "0x251e97446a7019E5DA4860d4CF47291321C693D0",
+            [baseSepolia]: "0x251e97446a7019E5DA4860d4CF47291321C693D0",
+            [baseMainnet]: "0x0000000000000000000000000000000000000000",
+        },
+        FLETHHooksAddress: {
+            ...actualConstants.FLETHHooksAddress,
+            "0x14a34": "0x4bd2ca15286c96e4e731337de8b375da6841e888",
+        },
+        FLETHAddress: {
+            ...actualConstants.FLETHAddress,
+            "0x14a34": "0x79FC52701cD4BE6f9Ba9aDC94c207DE37e3314eb",
+        },
+        QuoterAddress: {
+            ...actualConstants.QuoterAddress,
+            "0x14a34": "0x4a6513c898fe1b2d0e78d3b0e0a4a151589b1cba",
+        },
+        UniversalRouterAddress: {
+            ...actualConstants.UniversalRouterAddress,
+            "0x14a34": "0x492E6456D9528771018DeB9E87ef7750EF184104",
+        },
+        Permit2Address: {
+            ...actualConstants.Permit2Address,
+            "0x14a34": "0x000000000022D473030F116dDEE9F6B43aC78BA3",
+        },
+    };
+});
+describe("FlaunchActionProvider", () => {
+    const provider = new flaunchActionProvider_1.FlaunchActionProvider({ pinataJwt: "test-jwt" });
+    let mockWalletProvider;
+    beforeEach(() => {
+        mockWalletProvider = {
+            getAddress: jest.fn().mockReturnValue("0x1234567890123456789012345678901234567890"),
+            getBalance: jest.fn(),
+            getName: jest.fn(),
+            getNetwork: jest.fn().mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-sepolia",
+                chainId: "0x14a34",
+            }),
+            nativeTransfer: jest.fn(),
+            sendTransaction: jest.fn().mockResolvedValue("0xtxhash"),
+            waitForTransactionReceipt: jest.fn().mockResolvedValue({
+                logs: [
+                    {
+                        address: "0x9A7059cA00dA92843906Cb4bCa1D005cE848AFdC", // FlaunchPositionManagerAddress for base-sepolia
+                        data: "0x0000000000000000000000001234567890123456789012345678901234567890",
+                        topics: ["0x"],
+                    },
+                ],
+            }),
+            readContract: jest.fn().mockImplementation(({ functionName }) => {
+                if (functionName === "symbol")
+                    return "TEST";
+                if (functionName === "allowance")
+                    return [BigInt(0), BigInt(0)];
+                return undefined;
+            }),
+            signTypedData: jest.fn().mockResolvedValue("0xsignature"),
+        };
+    });
+    describe("network support", () => {
+        it("should support the supported networks", () => {
+            expect(provider.supportsNetwork({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            })).toBe(true);
+            expect(provider.supportsNetwork({
+                protocolFamily: "evm",
+                networkId: "base-sepolia",
+            })).toBe(true);
+        });
+        it("should not support other protocol families", () => {
+            expect(provider.supportsNetwork({
+                protocolFamily: "other-protocol-family",
+                networkId: "base-mainnet",
+            })).toBe(false);
+        });
+        it("should not support unsupported networks", () => {
+            expect(provider.supportsNetwork({
+                protocolFamily: "evm",
+                networkId: "ethereum",
+            })).toBe(false);
+        });
+        it("should handle invalid network objects", () => {
+            expect(provider.supportsNetwork({})).toBe(false);
+        });
+    });
+    describe("action validation", () => {
+        it("should validate flaunch schema", () => {
+            const validInput = {
+                name: "Test Token",
+                symbol: "TEST",
+                imageUrl: "https://example.com/image.png",
+                description: "A test token",
+                websiteUrl: "https://example.com",
+            };
+            const parseResult = schemas_1.FlaunchSchema.safeParse(validInput);
+            expect(parseResult.success).toBe(true);
+        });
+        it("should reject invalid flaunch input", () => {
+            const invalidInput = {
+                name: "",
+                symbol: "",
+                imageUrl: "not-a-url",
+                description: "",
+            };
+            const parseResult = schemas_1.FlaunchSchema.safeParse(invalidInput);
+            expect(parseResult.success).toBe(false);
+        });
+        it("should validate buyCoinWithETHInput schema", () => {
+            const validInput = {
+                coinAddress: "0x1234567890123456789012345678901234567890",
+                amountIn: "0.1",
+                slippagePercent: 3,
+            };
+            const parseResult = schemas_1.BuyCoinWithETHInputSchema.safeParse(validInput);
+            expect(parseResult.success).toBe(true);
+        });
+        it("should validate buyCoinWithCoinInput schema", () => {
+            const validInput = {
+                coinAddress: "0x1234567890123456789012345678901234567890",
+                amountOut: "1000",
+                slippagePercent: 3,
+            };
+            const parseResult = schemas_1.BuyCoinWithCoinInputSchema.safeParse(validInput);
+            expect(parseResult.success).toBe(true);
+        });
+        it("should validate sellCoin schema", () => {
+            const validInput = {
+                coinAddress: "0x1234567890123456789012345678901234567890",
+                amountIn: "1000",
+                slippagePercent: 3,
+            };
+            const parseResult = schemas_1.SellCoinSchema.safeParse(validInput);
+            expect(parseResult.success).toBe(true);
+        });
+    });
+    describe("flaunch action", () => {
+        it("should execute flaunch action with wallet provider", async () => {
+            const args = {
+                name: "Test Token",
+                symbol: "TEST",
+                imageUrl: "https://example.com/image.png",
+                description: "A test token",
+                websiteUrl: "https://example.com",
+            };
+            const result = await provider.flaunch(mockWalletProvider, args);
+            console.log("Test result:", result);
+            expect(result).toContain("Flaunched");
+            expect(result).toContain("TEST");
+            expect(mockWalletProvider.getNetwork).toHaveBeenCalled();
+            expect(mockWalletProvider.sendTransaction).toHaveBeenCalled();
+            expect(mockWalletProvider.waitForTransactionReceipt).toHaveBeenCalled();
+        });
+    });
+    describe("buyCoinWithETHInput action", () => {
+        it("should execute buyCoinWithETHInput action with wallet provider", async () => {
+            const args = {
+                coinAddress: "0x1234567890123456789012345678901234567890",
+                amountIn: "0.1",
+                slippagePercent: 3,
+            };
+            const result = await provider.buyCoinWithETHInput(mockWalletProvider, args);
+            expect(result).toContain("Bought");
+            expect(result).toContain("TEST");
+            expect(result).toContain((0, viem_1.formatEther)(BigInt(1000000000000000000)));
+            expect(mockWalletProvider.getNetwork).toHaveBeenCalled();
+            expect(mockWalletProvider.sendTransaction).toHaveBeenCalled();
+            expect(mockWalletProvider.readContract).toHaveBeenCalled();
+            expect(mockWalletProvider.waitForTransactionReceipt).toHaveBeenCalled();
+        });
+        it("should handle errors in buyCoinWithETHInput", async () => {
+            mockWalletProvider.sendTransaction.mockRejectedValueOnce(new Error("Transaction failed"));
+            const args = {
+                coinAddress: "0x1234567890123456789012345678901234567890",
+                amountIn: "0.1",
+                slippagePercent: 3,
+            };
+            const result = await provider.buyCoinWithETHInput(mockWalletProvider, args);
+            expect(result).toContain("Error buying coin");
+        });
+    });
+    describe("buyCoinWithCoinInput action", () => {
+        it("should execute buyCoinWithCoinInput action with wallet provider", async () => {
+            const args = {
+                coinAddress: "0x1234567890123456789012345678901234567890",
+                amountOut: "1000",
+                slippagePercent: 3,
+            };
+            const result = await provider.buyCoinWithCoinInput(mockWalletProvider, args);
+            expect(result).toContain("Bought");
+            expect(result).toContain("TEST");
+            expect(result).toContain((0, viem_1.formatEther)(BigInt(1000000000000000000)));
+            expect(mockWalletProvider.getNetwork).toHaveBeenCalled();
+            expect(mockWalletProvider.sendTransaction).toHaveBeenCalled();
+            expect(mockWalletProvider.readContract).toHaveBeenCalled();
+            expect(mockWalletProvider.waitForTransactionReceipt).toHaveBeenCalled();
+        });
+        it("should handle errors in buyCoinWithCoinInput", async () => {
+            mockWalletProvider.sendTransaction.mockRejectedValueOnce(new Error("Transaction failed"));
+            const args = {
+                coinAddress: "0x1234567890123456789012345678901234567890",
+                amountOut: "1000",
+                slippagePercent: 3,
+            };
+            const result = await provider.buyCoinWithCoinInput(mockWalletProvider, args);
+            expect(result).toContain("Error buying coin");
+        });
+    });
+    describe("sellCoin action", () => {
+        it("should execute sellCoin action with wallet provider", async () => {
+            const args = {
+                coinAddress: "0x1234567890123456789012345678901234567890",
+                amountIn: "1000",
+                slippagePercent: 3,
+            };
+            const result = await provider.sellCoin(mockWalletProvider, args);
+            expect(result).toContain("Sold");
+            expect(result).toContain("TEST");
+            expect(result).toContain((0, viem_1.formatEther)(BigInt(1000000000000000000)));
+            expect(mockWalletProvider.getNetwork).toHaveBeenCalled();
+            expect(mockWalletProvider.sendTransaction).toHaveBeenCalled();
+            expect(mockWalletProvider.readContract).toHaveBeenCalled();
+            expect(mockWalletProvider.waitForTransactionReceipt).toHaveBeenCalled();
+        });
+        it("should handle permit2 approval when allowance is insufficient", async () => {
+            const args = {
+                coinAddress: "0x1234567890123456789012345678901234567890",
+                amountIn: "1000",
+                slippagePercent: 3,
+            };
+            const result = await provider.sellCoin(mockWalletProvider, args);
+            expect(result).toContain("Sold");
+            expect(mockWalletProvider.signTypedData).toHaveBeenCalled();
+        });
+        it("should handle errors in sellCoin", async () => {
+            mockWalletProvider.sendTransaction.mockRejectedValueOnce(new Error("Transaction failed"));
+            const args = {
+                coinAddress: "0x1234567890123456789012345678901234567890",
+                amountIn: "1000",
+                slippagePercent: 3,
+            };
+            const result = await provider.sellCoin(mockWalletProvider, args);
+            expect(result).toContain("Error selling coin");
+        });
+    });
+});

package/dist/action-providers/flaunch/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Exports for flaunch action provider
+ *
+ * @module flaunch
+ */
+export * from "./flaunchActionProvider";
+export * from "./schemas";

package/dist/action-providers/flaunch/index.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * Exports for flaunch action provider
+ *
+ * @module flaunch
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./flaunchActionProvider"), exports);
+__exportStar(require("./schemas"), exports);

package/dist/action-providers/flaunch/schemas.d.ts

@@ -0,0 +1,77 @@
+import { z } from "zod";
+/**
+ * Action schemas for the flaunch action provider.
+ *
+ * This file contains the Zod schemas that define the shape and validation
+ * rules for action parameters in the flaunch action provider.
+ */
+/**
+ * Schema for Flaunch token creation
+ */
+export declare const FlaunchSchema: z.ZodObject<{
+    name: z.ZodString;
+    symbol: z.ZodString;
+    imageUrl: z.ZodString;
+    description: z.ZodString;
+    websiteUrl: z.ZodOptional<z.ZodString>;
+    discordUrl: z.ZodOptional<z.ZodString>;
+    twitterUrl: z.ZodOptional<z.ZodString>;
+    telegramUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    symbol: string;
+    name: string;
+    description: string;
+    imageUrl: string;
+    websiteUrl?: string | undefined;
+    discordUrl?: string | undefined;
+    twitterUrl?: string | undefined;
+    telegramUrl?: string | undefined;
+}, {
+    symbol: string;
+    name: string;
+    description: string;
+    imageUrl: string;
+    websiteUrl?: string | undefined;
+    discordUrl?: string | undefined;
+    twitterUrl?: string | undefined;
+    telegramUrl?: string | undefined;
+}>;
+export declare const BuyCoinWithETHInputSchema: z.ZodObject<{
+    coinAddress: z.ZodString;
+    amountIn: z.ZodString;
+    slippagePercent: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    amountIn: string;
+    coinAddress: string;
+    slippagePercent: number;
+}, {
+    amountIn: string;
+    coinAddress: string;
+    slippagePercent?: number | undefined;
+}>;
+export declare const BuyCoinWithCoinInputSchema: z.ZodObject<{
+    coinAddress: z.ZodString;
+    amountOut: z.ZodString;
+    slippagePercent: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    amountOut: string;
+    coinAddress: string;
+    slippagePercent: number;
+}, {
+    amountOut: string;
+    coinAddress: string;
+    slippagePercent?: number | undefined;
+}>;
+export declare const SellCoinSchema: z.ZodObject<{
+    coinAddress: z.ZodString;
+    amountIn: z.ZodString;
+    slippagePercent: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    amountIn: string;
+    coinAddress: string;
+    slippagePercent: number;
+}, {
+    amountIn: string;
+    coinAddress: string;
+    slippagePercent?: number | undefined;
+}>;

package/dist/action-providers/flaunch/schemas.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SellCoinSchema = exports.BuyCoinWithCoinInputSchema = exports.BuyCoinWithETHInputSchema = exports.FlaunchSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Action schemas for the flaunch action provider.
+ *
+ * This file contains the Zod schemas that define the shape and validation
+ * rules for action parameters in the flaunch action provider.
+ */
+/**
+ * Schema for Flaunch token creation
+ */
+exports.FlaunchSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1).describe("The name of the token"),
+    symbol: zod_1.z.string().min(1).describe("The symbol of the token"),
+    imageUrl: zod_1.z.string().url().describe("The URL to the token image"),
+    description: zod_1.z.string().describe("The description of the token"),
+    websiteUrl: zod_1.z.string().url().optional().describe("The (optional) URL to the token website"),
+    discordUrl: zod_1.z.string().url().optional().describe("The (optional) URL to the token Discord"),
+    twitterUrl: zod_1.z.string().url().optional().describe("The (optional) URL to the token Twitter"),
+    telegramUrl: zod_1.z.string().url().optional().describe("The (optional) URL to the token Telegram"),
+});
+exports.BuyCoinWithETHInputSchema = zod_1.z.object({
+    coinAddress: zod_1.z
+        .string()
+        .describe("The address of the flaunch coin to buy")
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format"),
+    amountIn: zod_1.z
+        .string()
+        .regex(/^\d+(\.\d+)?$/, "Must be a valid integer or decimal value")
+        .describe("The quantity of ETH to spend on the flaunch coin, in whole units"),
+    slippagePercent: zod_1.z
+        .number()
+        .min(0)
+        .max(100)
+        .default(5)
+        .describe("The slippage percentage. Default to 5%"),
+});
+exports.BuyCoinWithCoinInputSchema = zod_1.z.object({
+    coinAddress: zod_1.z
+        .string()
+        .describe("The address of the flaunch coin to buy")
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format"),
+    amountOut: zod_1.z
+        .string()
+        .regex(/^\d+(\.\d+)?$/, "Must be a valid integer or decimal value")
+        .describe("The quantity of the flaunch coin to buy, in whole units"),
+    slippagePercent: zod_1.z
+        .number()
+        .min(0)
+        .max(100)
+        .default(5)
+        .describe("The slippage percentage. Default to 5%"),
+});
+exports.SellCoinSchema = zod_1.z.object({
+    coinAddress: zod_1.z
+        .string()
+        .describe("The address of the flaunch coin to sell")
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format"),
+    amountIn: zod_1.z
+        .string()
+        .regex(/^\d+(\.\d+)?$/, "Must be a valid integer or decimal value")
+        .describe("The quantity of the flaunch coin to sell, in whole units"),
+    slippagePercent: zod_1.z
+        .number()
+        .min(0)
+        .max(100)
+        .default(5)
+        .describe("The slippage percentage. Default to 5%"),
+});

package/dist/action-providers/flaunch/types.d.ts

@@ -0,0 +1,64 @@
+import { Address } from "viem";
+import { PERMIT_TYPES } from "./constants";
+export interface Addresses {
+    [chainId: number]: Address;
+}
+type BuyCoinBase = {
+    coinAddress: Address;
+    slippagePercent: number;
+    referrer?: Address;
+};
+export type BuyCoinExactInParams = BuyCoinBase & {
+    swapType: "EXACT_IN";
+    amountIn: bigint;
+    amountOutMin?: bigint;
+};
+export type BuyCoinExactOutParams = BuyCoinBase & {
+    swapType: "EXACT_OUT";
+    amountOut: bigint;
+    amountInMax?: bigint;
+};
+export type PoolSwapEventArgs = {
+    flAmount0: bigint;
+    flAmount1: bigint;
+    flFee0: bigint;
+    flFee1: bigint;
+    ispAmount0: bigint;
+    ispAmount1: bigint;
+    ispFee0: bigint;
+    ispFee1: bigint;
+    uniAmount0: bigint;
+    uniAmount1: bigint;
+    uniFee0: bigint;
+    uniFee1: bigint;
+};
+export type BuySwapAmounts = {
+    coinsBought: bigint;
+    ethSold: bigint;
+};
+export type SellSwapAmounts = {
+    coinsSold: bigint;
+    ethBought: bigint;
+};
+export type PermitDetails = {
+    token: Address;
+    amount: bigint;
+    expiration: number;
+    nonce: number;
+};
+export type PermitSingle = {
+    details: PermitDetails;
+    spender: Address;
+    sigDeadline: bigint;
+};
+export type PermitTypedData = {
+    primaryType: string;
+    domain: {
+        name: string;
+        chainId: number;
+        verifyingContract: Address;
+    };
+    types: typeof PERMIT_TYPES;
+    message: PermitSingle;
+};
+export {};

package/dist/action-providers/flaunch/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/action-providers/flaunch/utils.d.ts

@@ -0,0 +1,60 @@
+import { Address, Hex, TransactionReceipt } from "viem";
+import { BuySwapAmounts, SellSwapAmounts, PermitSingle, PoolSwapEventArgs } from "./types";
+/**
+ * Configuration for Pinata
+ */
+interface PinataConfig {
+    jwt: string;
+}
+interface TokenUriParams {
+    metadata: {
+        imageUrl: string;
+        description: string;
+        websiteUrl?: string;
+        discordUrl?: string;
+        twitterUrl?: string;
+        telegramUrl?: string;
+    };
+    pinataConfig: PinataConfig;
+}
+export declare const generateTokenUri: (name: string, params: TokenUriParams) => Promise<string>;
+export declare const getAmountWithSlippage: (amount: bigint | undefined, slippage: string, swapType: "EXACT_IN" | "EXACT_OUT") => bigint;
+export declare const ethToMemecoin: (params: {
+    sender: Address;
+    memecoin: Address;
+    chainId: number;
+    referrer: Address | null;
+    swapType: "EXACT_IN" | "EXACT_OUT";
+    amountIn?: bigint;
+    amountOutMin?: bigint;
+    amountOut?: bigint;
+    amountInMax?: bigint;
+}) => {
+    calldata: `0x${string}`;
+    commands: `0x${string}`;
+    inputs: `0x${string}`[];
+};
+export declare const memecoinToEthWithPermit2: (params: {
+    chainId: number;
+    memecoin: Address;
+    amountIn: bigint;
+    ethOutMin: bigint;
+    permitSingle: PermitSingle | undefined;
+    signature: Hex | undefined;
+    referrer: Address | null;
+}) => {
+    calldata: `0x${string}`;
+    commands: `0x${string}`;
+    inputs: `0x${string}`[];
+};
+export declare const getSwapAmountsFromLog: ({ filteredPoolSwapEvent, coinAddress, chainId, }: {
+    filteredPoolSwapEvent: PoolSwapEventArgs;
+    coinAddress: Address;
+    chainId: number;
+}) => BuySwapAmounts | SellSwapAmounts;
+export declare const getSwapAmountsFromReceipt: ({ receipt, coinAddress, chainId, }: {
+    receipt: TransactionReceipt;
+    coinAddress: Address;
+    chainId: number;
+}) => BuySwapAmounts | SellSwapAmounts;
+export {};