init

Author: ponderingdemocritus

packages/adapter-supabase/package.json

@@ -12,7 +12,7 @@
         "tsup": "^8.3.5"
     },
     "scripts": {
-        "build": "echo 'No build step required'",
+        "build": "tsup --format esm --dts",
         "dev": "tsup --watch"
     },
     "peerDependencies": {

packages/plugin-starknet/package.json

@@ -0,0 +1,20 @@
+{
+    "name": "@ai16z/plugin-starknet",
+    "version": "0.0.1",
+    "main": "dist/index.js",
+    "type": "module",
+    "types": "dist/index.d.ts",
+    "dependencies": {
+        "@ai16z/eliza": "workspace:*",
+        "starknet": "^6.11.0",
+        "tsup": "^8.3.5",
+        "vitest": "^2.1.4"
+    },
+    "scripts": {
+        "build": "tsup --format esm --dts",
+        "test": "vitest"
+    },
+    "peerDependencies": {
+        "whatwg-url": "7.1.0"
+    }
+}

packages/plugin-starknet/readme.md

@@ -0,0 +1,126 @@
+import {
+    fetchAvnuQuote,
+    buildAvnuCallData,
+    executeAvnuSwap,
+} from "../providers/avnu.ts";
+import { AvnuQuoteParams } from "../types/token";
+import {
+    ActionExample,
+    HandlerCallback,
+    IAgentRuntime,
+    Memory,
+    ModelClass,
+    State,
+    type Action,
+} from "@ai16z/eliza/src/types.ts";
+import { composeContext } from "@ai16z/eliza/src/context.ts";
+import { generateObject } from "@ai16z/eliza/src/generation.ts";
+
+const swapTemplate = `Respond with a JSON markdown block containing only the extracted values. Use null for any values that cannot be determined.
+
+Example response:
+\`\`\`json
+{
+    "sellTokenAddress": "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7",
+    "buyTokenAddress": "0x053c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8",
+    "sellAmount": "1000000000000000000"
+}
+\`\`\`
+
+{{recentMessages}}
+
+Extract the following information about the requested token swap:
+- Sell token address
+- Buy token address  
+- Amount to sell (in wei)
+
+Respond with a JSON markdown block containing only the extracted values. Use null for any values that cannot be determined.`;
+
+export const executeSwap: Action = {
+    name: "EXECUTE_SWAP",
+    similes: ["SWAP_TOKENS", "TOKEN_SWAP", "TRADE_TOKENS", "EXCHANGE_TOKENS"],
+    validate: async (runtime: IAgentRuntime, message: Memory) => {
+        console.log("Message:", message);
+        return true;
+    },
+    description: "Perform a token swap using Avnu.",
+    handler: async (
+        runtime: IAgentRuntime,
+        message: Memory,
+        state: State,
+        _options: { [key: string]: unknown },
+        callback?: HandlerCallback
+    ): Promise<boolean> => {
+        if (!state) {
+            state = (await runtime.composeState(message)) as State;
+        } else {
+            state = await runtime.updateRecentMessageState(state);
+        }
+
+        const swapContext = composeContext({
+            state,
+            template: swapTemplate,
+        });
+
+        const response = await generateObject({
+            runtime,
+            context: swapContext,
+            modelClass: ModelClass.LARGE,
+        });
+
+        console.log("Response:", response);
+
+        try {
+            // Get quote
+            const quoteParams: AvnuQuoteParams = {
+                sellTokenAddress: response.sellTokenAddress,
+                buyTokenAddress: response.buyTokenAddress,
+                sellAmount: response.sellAmount,
+            };
+
+            const quote = await fetchAvnuQuote(quoteParams);
+
+            // Build call data
+            const callData = await buildAvnuCallData({
+                quoteId: quote.quoteId,
+                slippage: 0.05, // 5% slippage
+            });
+
+            // Execute swap
+            const swapResult = await executeAvnuSwap({
+                quoteId: quote.quoteId,
+                calldata: callData.calldata,
+            });
+
+            console.log("Swap completed successfully!");
+            callback?.({
+                text:
+                    "Swap completed successfully! tx: " +
+                    swapResult.transactionHash,
+            });
+
+            return true;
+        } catch (error) {
+            console.error("Error during token swap:", error);
+            callback?.({ text: `Error during swap: ${error.message}` });
+            return false;
+        }
+    },
+    examples: [
+        [
+            {
+                user: "{{user1}}",
+                content: {
+                    text: "Swap 1 ETH for USDC",
+                },
+            },
+            {
+                user: "{{user2}}",
+                content: {
+                    text: "Executing swap...",
+                    action: "TOKEN_SWAP",
+                },
+            },
+        ],
+    ] as ActionExample[][],
+} as Action;

packages/plugin-starknet/src/actions/swap.ts

@@ -0,0 +1,23 @@
+import { Plugin } from "@ai16z/eliza";
+// import { executeSwap } from "./actions/swap.ts";
+// import take_order from "./actions/takeOrder";
+// import pumpfun from "./actions/pumpfun";
+// import { executeSwapForDAO } from "./actions/swapDao";
+// import { walletProvider } from "./providers/wallet.ts";
+// import { trustScoreProvider } from "./providers/trustScoreProvider.ts";
+// import { trustEvaluator } from "./evaluators/trust.ts";
+
+export const starknetPlugin: Plugin = {
+    name: "Starknet",
+    description: "Starknet Plugin for Eliza",
+    actions: [
+        // executeSwap,
+        // pumpfun,
+        // executeSwapForDAO,
+        // take_order,
+    ],
+    evaluators: [],
+    providers: [],
+};
+
+export default starknetPlugin;

packages/plugin-starknet/src/index.ts

@@ -0,0 +1,136 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { fetchAvnuQuote } from "./avnu";
+
+describe("fetchAvnuQuote", () => {
+    const mockRuntime = {
+        getSetting: vi.fn().mockReturnValue("test-api-key"),
+    };
+
+    const mockQuoteResponse = {
+        quoteId: "test-quote-id",
+        sellTokenAddress: "0x123",
+        sellAmount: "1000000000000000000",
+        sellAmountInUsd: 100,
+        buyTokenAddress: "0x456",
+        buyAmount: "2000000000000000000",
+        buyAmountInUsd: 200,
+        buyAmountWithoutFees: "1950000000000000000",
+        buyAmountWithoutFeesInUsd: 195,
+        estimatedAmount: true,
+        chainId: "1",
+        blockNumber: "123456",
+        expiry: 1234567890,
+        routes: [],
+        gasFees: "1000000",
+        gasFeesInUsd: 1,
+        avnuFees: "500000",
+        avnuFeesInUsd: 0.5,
+        avnuFeesBps: "10",
+        integratorFees: "0",
+        integratorFeesInUsd: 0,
+        integratorFeesBps: "0",
+        priceRatioUsd: 2,
+        liquiditySource: "test-source",
+        sellTokenPriceInUsd: 100,
+        buyTokenPriceInUsd: 200,
+        gasless: {
+            active: false,
+            gasTokenPrices: [],
+        },
+    };
+
+    beforeEach(() => {
+        // Clear all mocks before each test
+        vi.clearAllMocks();
+        // Reset fetch mock
+        global.fetch = vi.fn();
+    });
+
+    it("should successfully fetch a quote", async () => {
+        // Mock the fetch response
+        global.fetch = vi.fn().mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve(mockQuoteResponse),
+        });
+
+        const params = {
+            sellTokenAddress: "0x123",
+            buyTokenAddress: "0x456",
+            sellAmount: "1000000000000000000",
+        };
+
+        const result = await fetchAvnuQuote(params);
+
+        // Verify the fetch was called with correct parameters
+        expect(fetch).toHaveBeenCalledWith(
+            expect.stringContaining(
+                "https://starknet.api.avnu.fi/swap/v2/quotes"
+            ),
+            expect.objectContaining({
+                method: "GET",
+                headers: {
+                    Accept: "application/json",
+                    Authorization: "Bearer test-api-key",
+                },
+            })
+        );
+
+        // Verify the URL contains the correct query parameters
+        const fetchCall = (fetch as unknown as { mock: { calls: string[][] } })
+            .mock.calls[0][0];
+        expect(fetchCall).toContain(
+            `sellTokenAddress=${params.sellTokenAddress}`
+        );
+        expect(fetchCall).toContain(
+            `buyTokenAddress=${params.buyTokenAddress}`
+        );
+        expect(fetchCall).toContain(`sellAmount=${params.sellAmount}`);
+
+        // Verify the response
+        expect(result).toEqual(mockQuoteResponse);
+    });
+
+    it("should handle API errors", async () => {
+        // Mock a failed response
+        global.fetch = vi.fn().mockResolvedValueOnce({
+            ok: false,
+            text: () => Promise.resolve("API Error"),
+        });
+
+        const params = {
+            sellTokenAddress: "0x123",
+            buyTokenAddress: "0x456",
+        };
+
+        await expect(fetchAvnuQuote(params)).rejects.toThrow(
+            "Failed to fetch Avnu quote: API Error"
+        );
+    });
+
+    it("should include optional parameters when provided", async () => {
+        global.fetch = vi.fn().mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve(mockQuoteResponse),
+        });
+
+        const params = {
+            sellTokenAddress: "0x123",
+            buyTokenAddress: "0x456",
+            takerAddress: "0x789",
+            excludeSources: ["source1", "source2"],
+            size: 5,
+            integratorName: "test-integrator",
+        };
+
+        await fetchAvnuQuote(params);
+
+        const fetchCall = (fetch as unknown as { mock: { calls: string[][] } })
+            .mock.calls[0][0];
+        expect(fetchCall).toContain(`takerAddress=${params.takerAddress}`);
+        expect(fetchCall).toContain(
+            `excludeSources=${encodeURIComponent(params.excludeSources.join(","))}`
+        );
+        expect(fetchCall).toContain(`size=${params.size}`);
+        expect(fetchCall).toContain(`integratorName=${params.integratorName}`);
+    });
+});