@coinbase/agentkit 0.1.2 → 0.2.0

package/dist/action-providers/spl/splActionProvider.js

@@ -0,0 +1,112 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splActionProvider = exports.SplActionProvider = void 0;
+const actionProvider_1 = require("../actionProvider");
+const svmWalletProvider_1 = require("../../wallet-providers/svmWalletProvider");
+const zod_1 = require("zod");
+const actionDecorator_1 = require("../actionDecorator");
+const schemas_1 = require("./schemas");
+const web3_js_1 = require("@solana/web3.js");
+/**
+ * SplActionProvider serves as a provider for SPL token actions.
+ * It provides SPL token transfer functionality.
+ */
+class SplActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Creates a new SplActionProvider instance.
+     */
+    constructor() {
+        super("spl", []);
+    }
+    /**
+     * Transfer SPL tokens to another address.
+     *
+     * @param walletProvider - The wallet provider to use for the transfer
+     * @param args - Transfer parameters including recipient address, mint address, and amount
+     * @returns A message indicating success or failure with transaction details
+     */
+    async transfer(walletProvider, args) {
+        try {
+            const connection = walletProvider.getConnection();
+            const fromPubkey = walletProvider.getPublicKey();
+            const toPubkey = new web3_js_1.PublicKey(args.recipient);
+            const mintPubkey = new web3_js_1.PublicKey(args.mintAddress);
+            const { getMint, getAssociatedTokenAddress, getAccount, createAssociatedTokenAccountInstruction, createTransferCheckedInstruction, } = await import("@solana/spl-token");
+            const mintInfo = await getMint(connection, mintPubkey);
+            const adjustedAmount = args.amount * Math.pow(10, mintInfo.decimals);
+            const sourceAta = await getAssociatedTokenAddress(mintPubkey, fromPubkey);
+            const destinationAta = await getAssociatedTokenAddress(mintPubkey, toPubkey);
+            const instructions = [];
+            const sourceAccount = await getAccount(connection, sourceAta);
+            if (sourceAccount.amount < BigInt(adjustedAmount)) {
+                throw new Error(`Insufficient token balance. Have ${sourceAccount.amount}, need ${adjustedAmount}`);
+            }
+            try {
+                await getAccount(connection, destinationAta);
+            }
+            catch {
+                instructions.push(createAssociatedTokenAccountInstruction(fromPubkey, destinationAta, toPubkey, mintPubkey));
+            }
+            instructions.push(createTransferCheckedInstruction(sourceAta, mintPubkey, destinationAta, fromPubkey, adjustedAmount, mintInfo.decimals));
+            const tx = new web3_js_1.VersionedTransaction(web3_js_1.MessageV0.compile({
+                payerKey: fromPubkey,
+                instructions: instructions,
+                recentBlockhash: (await connection.getLatestBlockhash()).blockhash,
+            }));
+            const signature = await walletProvider.signAndSendTransaction(tx);
+            await walletProvider.waitForSignatureResult(signature);
+            return [
+                `Successfully transferred ${args.amount} tokens to ${args.recipient}`,
+                `Token mint: ${args.mintAddress}`,
+                `Signature: ${signature}`,
+            ].join("\n");
+        }
+        catch (error) {
+            return `Error transferring SPL tokens: ${error}`;
+        }
+    }
+    /**
+     * Checks if the action provider supports the given network.
+     * Only supports Solana networks.
+     *
+     * @param network - The network to check support for
+     * @returns True if the network is a Solana network
+     */
+    supportsNetwork(network) {
+        return network.protocolFamily === "svm";
+    }
+}
+exports.SplActionProvider = SplActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "transfer",
+        description: `
+    This tool will transfer SPL tokens to another address.
+    - Amount should be specified in token units (not raw)
+    - Recipient must be a valid Solana address
+    - Mint address must be a valid SPL token mint
+    - Ensures sufficient token balance before transfer
+    - Returns transaction details
+    `,
+        schema: schemas_1.TransferTokenSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [svmWalletProvider_1.SvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], SplActionProvider.prototype, "transfer", null);
+/**
+ * Factory function to create a new SplActionProvider instance.
+ *
+ * @returns A new SplActionProvider instance
+ */
+const splActionProvider = () => new SplActionProvider();
+exports.splActionProvider = splActionProvider;

package/dist/action-providers/spl/splActionProvider.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/action-providers/spl/splActionProvider.test.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const web3_js_1 = require("@solana/web3.js");
+const splActionProvider_1 = require("./splActionProvider");
+jest.mock("@solana/web3.js", () => ({
+    ...jest.requireActual("@solana/web3.js"),
+    Connection: jest.fn(),
+    SendTransactionError: jest.fn().mockReturnValue({
+        message: "Failed to send",
+        toString: () => "Failed to send",
+    }),
+    VersionedTransaction: jest.fn().mockReturnValue({
+        sign: jest.fn(),
+    }),
+    MessageV0: {
+        compile: jest.fn().mockReturnValue({}),
+    },
+}));
+jest.mock("@solana/spl-token", () => ({
+    getAssociatedTokenAddress: jest.fn(),
+    getMint: jest.fn(),
+    getAccount: jest.fn(),
+    createAssociatedTokenAccountInstruction: jest.fn(),
+    createTransferCheckedInstruction: jest.fn(),
+}));
+jest.mock("../../wallet-providers/svmWalletProvider");
+describe("SplActionProvider", () => {
+    let actionProvider;
+    let mockWallet;
+    let mockConnection;
+    let mockGetAssociatedTokenAddress;
+    let mockGetMint;
+    let mockGetAccount;
+    /**
+     * Set up test environment before each test.
+     * Initializes mocks and creates fresh instances of required objects.
+     */
+    beforeEach(() => {
+        jest.clearAllMocks();
+        const mocked = jest.requireMock("@solana/spl-token");
+        mockGetAssociatedTokenAddress = mocked.getAssociatedTokenAddress;
+        mockGetMint = mocked.getMint;
+        mockGetAccount = mocked.getAccount;
+        mockGetMint.mockResolvedValue({ decimals: 6 });
+        mockGetAccount.mockRejectedValue(new Error("getAccount mock not implemented for this test"));
+        actionProvider = new splActionProvider_1.SplActionProvider();
+        mockConnection = {
+            getLatestBlockhash: jest.fn().mockResolvedValue({ blockhash: "mockedBlockhash" }),
+        };
+        const MOCK_SIGNATURE = "mock-signature";
+        const mockSignatureReceipt = {
+            context: { slot: 1234 },
+            value: { err: null },
+        };
+        mockWallet = {
+            getConnection: jest.fn().mockReturnValue(mockConnection),
+            getPublicKey: jest.fn().mockReturnValue(new web3_js_1.PublicKey("11111111111111111111111111111111")),
+            signAndSendTransaction: jest.fn().mockResolvedValue(MOCK_SIGNATURE),
+            waitForSignatureResult: jest.fn().mockResolvedValue(mockSignatureReceipt),
+            getAddress: jest.fn().mockReturnValue("11111111111111111111111111111111"),
+            getNetwork: jest.fn().mockReturnValue({ protocolFamily: "svm", networkId: "mainnet" }),
+            getName: jest.fn().mockReturnValue("mock-wallet"),
+            getBalance: jest.fn().mockResolvedValue(BigInt(1000000000)),
+            nativeTransfer: jest.fn(),
+        };
+    });
+    describe("constructor", () => {
+        /**
+         * Test that the SPL action provider is created with the correct name.
+         */
+        it("should create a provider with correct name", () => {
+            expect(actionProvider["name"]).toBe("spl");
+        });
+    });
+    describe("supportsNetwork", () => {
+        /**
+         * Test that the provider correctly identifies Solana networks as supported.
+         */
+        it("should return true for Solana networks", () => {
+            const network = {
+                protocolFamily: "svm",
+                networkId: "solana-mainnet",
+            };
+            expect(actionProvider.supportsNetwork(network)).toBe(true);
+        });
+        /**
+         * Test that the provider correctly identifies non-Solana networks as unsupported.
+         */
+        it("should return false for non-Solana networks", () => {
+            const network = {
+                protocolFamily: "evm",
+                networkId: "ethereum-mainnet",
+            };
+            expect(actionProvider.supportsNetwork(network)).toBe(false);
+        });
+    });
+    describe("transfer", () => {
+        const MINT_ADDRESS = "So11111111111111111111111111111111111111112";
+        const RECIPIENT_ADDRESS = "DjXsn34uz8yCBQ8bevLrEPYYC1RvhHvjzuVF8opNc4K2";
+        const SENDER_ADDRESS = "11111111111111111111111111111111";
+        const MOCK_SIGNATURE = "mock-signature";
+        const transferArgs = {
+            recipient: RECIPIENT_ADDRESS,
+            mintAddress: MINT_ADDRESS,
+            amount: 100,
+        };
+        const mockTokenAccount = {
+            amount: BigInt(1000000000),
+            address: new web3_js_1.PublicKey(MINT_ADDRESS),
+            mint: new web3_js_1.PublicKey(MINT_ADDRESS),
+            owner: new web3_js_1.PublicKey(RECIPIENT_ADDRESS),
+            delegate: null,
+            delegatedAmount: BigInt(0),
+            closeAuthority: null,
+            isFrozen: false,
+            isNative: false,
+            rentExemptReserve: null,
+            isInitialized: true,
+            tlvData: new Map(),
+        };
+        const mockSignatureReceipt = {
+            context: { slot: 1234 },
+            value: { err: null },
+        };
+        beforeEach(() => {
+            mockWallet.getPublicKey.mockReturnValue(new web3_js_1.PublicKey(SENDER_ADDRESS));
+            mockWallet.getAddress.mockReturnValue(SENDER_ADDRESS);
+            mockWallet.signAndSendTransaction.mockResolvedValue(MOCK_SIGNATURE);
+            mockWallet.waitForSignatureResult.mockResolvedValue(mockSignatureReceipt);
+        });
+        /**
+         * Test successful SPL token transfer with all required steps:
+         * - Account validation
+         * - Instruction creation
+         * - Signing
+         * - Sending
+         * - Receipt confirmation
+         */
+        it("should successfully transfer SPL tokens", async () => {
+            mockGetAccount.mockResolvedValue(mockTokenAccount);
+            const result = await actionProvider.transfer(mockWallet, transferArgs);
+            expect(mockGetAssociatedTokenAddress).toHaveBeenNthCalledWith(1, new web3_js_1.PublicKey(transferArgs.mintAddress), new web3_js_1.PublicKey(SENDER_ADDRESS));
+            expect(mockGetAssociatedTokenAddress).toHaveBeenNthCalledWith(2, new web3_js_1.PublicKey(transferArgs.mintAddress), new web3_js_1.PublicKey(transferArgs.recipient));
+            expect(mockGetMint).toHaveBeenCalledWith(mockConnection, new web3_js_1.PublicKey(transferArgs.mintAddress));
+            expect(mockGetAccount).toHaveBeenCalled();
+            expect(mockWallet.signAndSendTransaction).toHaveBeenCalled();
+            expect(mockWallet.waitForSignatureResult).toHaveBeenCalledWith(MOCK_SIGNATURE);
+            expect(result).toContain(`Successfully transferred ${transferArgs.amount} tokens`);
+            expect(result).toContain(`to ${transferArgs.recipient}`);
+            expect(result).toContain(`Token mint: ${transferArgs.mintAddress}`);
+            expect(result).toContain(`Signature: ${MOCK_SIGNATURE}`);
+        });
+        /**
+         * Test handling of insufficient balance.
+         * Verifies that the provider properly checks token balances and prevents transfers when funds are insufficient.
+         */
+        it("should handle insufficient balance", async () => {
+            mockGetAccount.mockResolvedValue({
+                ...mockTokenAccount,
+                amount: BigInt(10000000),
+            });
+            const result = await actionProvider.transfer(mockWallet, transferArgs);
+            expect(result).toBe("Error transferring SPL tokens: Error: Insufficient token balance. Have 10000000, need 100000000");
+        });
+        /**
+         * Test handling of Solana-specific send errors.
+         * Verifies that the provider properly handles and reports SendTransactionError instances.
+         */
+        it("should handle SendTransactionError", async () => {
+            mockGetAccount.mockResolvedValue(mockTokenAccount);
+            const error = new web3_js_1.SendTransactionError({
+                logs: [],
+                action: "send",
+                signature: "mock-signature",
+                transactionMessage: "Failed to send",
+            });
+            mockWallet.signAndSendTransaction.mockRejectedValue(error);
+            const result = await actionProvider.transfer(mockWallet, transferArgs);
+            expect(result).toBe("Error transferring SPL tokens: Failed to send");
+        });
+        /**
+         * Test handling of general errors during transfer.
+         * Verifies that the provider properly handles and reports unexpected errors.
+         */
+        it("should handle regular errors", async () => {
+            mockGetAccount.mockResolvedValue(mockTokenAccount);
+            const error = new Error("Regular error message");
+            mockWallet.signAndSendTransaction.mockRejectedValue(error);
+            const result = await actionProvider.transfer(mockWallet, transferArgs);
+            expect(result).toBe("Error transferring SPL tokens: Error: Regular error message");
+        });
+        /**
+         * Test that ATA is created by default when missing
+         */
+        it("should create ATA by default when missing", async () => {
+            mockGetAccount
+                .mockResolvedValueOnce(mockTokenAccount)
+                .mockRejectedValueOnce(new Error("Account does not exist"))
+                .mockResolvedValue(mockTokenAccount);
+            const result = await actionProvider.transfer(mockWallet, transferArgs);
+            const { createAssociatedTokenAccountInstruction } = jest.requireMock("@solana/spl-token");
+            expect(createAssociatedTokenAccountInstruction).toHaveBeenCalled();
+            expect(result).toContain(`Successfully transferred ${transferArgs.amount} tokens`);
+        });
+    });
+});

package/dist/action-providers/wallet/walletActionProvider.d.ts

@@ -20,7 +20,7 @@ export declare class WalletActionProvider extends ActionProvider {
      */
     getWalletDetails(walletProvider: WalletProvider, _: z.infer<typeof GetWalletDetailsSchema>): Promise<string>;
     /**
-     * Transfers a specified amount of an asset to a destination onchain.
+     * Transfers a specified amount of native currency to a destination onchain.
      *
      * @param walletProvider - The wallet provider to transfer from.
      * @param args - The input arguments for the action.

package/dist/action-providers/wallet/walletActionProvider.js

@@ -10,12 +10,16 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.walletActionProvider = exports.WalletActionProvider = void 0;
-const decimal_js_1 = require("decimal.js");
 const zod_1 = require("zod");
 const actionDecorator_1 = require("../actionDecorator");
 const actionProvider_1 = require("../actionProvider");
 const wallet_providers_1 = require("../../wallet-providers");
 const schemas_1 = require("./schemas");
+const PROTOCOL_FAMILY_TO_TERMINOLOGY = {
+    evm: { unit: "WEI", displayUnit: "ETH", type: "Transaction hash", verb: "transaction" },
+    svm: { unit: "LAMPORTS", displayUnit: "SOL", type: "Signature", verb: "transfer" },
+};
+const DEFAULT_TERMINOLOGY = { unit: "", displayUnit: "", type: "Hash", verb: "transfer" };
 /**
  * WalletActionProvider provides actions for getting basic wallet information.
  */
@@ -47,24 +51,24 @@ class WalletActionProvider extends actionProvider_1.ActionProvider {
             const network = walletProvider.getNetwork();
             const balance = await walletProvider.getBalance();
             const name = walletProvider.getName();
-            // Convert balance from Wei to ETH using Decimal for precision
-            const ethBalance = new decimal_js_1.Decimal(balance.toString()).div(new decimal_js_1.Decimal(10).pow(18));
-            return `Wallet Details:
-- Provider: ${name}
-- Address: ${address}
-- Network: 
-  * Protocol Family: ${network.protocolFamily}
-  * Network ID: ${network.networkId || "N/A"}
-  * Chain ID: ${network.chainId || "N/A"}
-- ETH Balance: ${ethBalance.toFixed(6)} ETH
-- Native Balance: ${balance.toString()} WEI`;
+            const terminology = PROTOCOL_FAMILY_TO_TERMINOLOGY[network.protocolFamily] || DEFAULT_TERMINOLOGY;
+            return [
+                "Wallet Details:",
+                `- Provider: ${name}`,
+                `- Address: ${address}`,
+                "- Network:",
+                `  * Protocol Family: ${network.protocolFamily}`,
+                `  * Network ID: ${network.networkId || "N/A"}`,
+                `  * Chain ID: ${network.chainId || "N/A"}`,
+                `- Native Balance: ${balance.toString()} ${terminology.unit}`,
+            ].join("\n");
         }
         catch (error) {
             return `Error getting wallet details: ${error}`;
         }
     }
     /**
-     * Transfers a specified amount of an asset to a destination onchain.
+     * Transfers a specified amount of native currency to a destination onchain.
      *
      * @param walletProvider - The wallet provider to transfer from.
      * @param args - The input arguments for the action.
@@ -72,11 +76,21 @@ class WalletActionProvider extends actionProvider_1.ActionProvider {
      */
     async nativeTransfer(walletProvider, args) {
         try {
+            const { protocolFamily } = walletProvider.getNetwork();
+            const terminology = PROTOCOL_FAMILY_TO_TERMINOLOGY[protocolFamily] || DEFAULT_TERMINOLOGY;
+            if (protocolFamily === "evm" && !args.to.startsWith("0x")) {
+                args.to = `0x${args.to}`;
+            }
             const result = await walletProvider.nativeTransfer(args.to, args.value);
-            return `Transferred ${args.value} ETH to ${args.to}.\nTransaction hash: ${result}`;
+            return [
+                `Transferred ${args.value} ${terminology.displayUnit} to ${args.to}`,
+                `${terminology.type}: ${result}`,
+            ].join("\n");
         }
         catch (error) {
-            return `Error transferring the asset: ${error}`;
+            const { protocolFamily } = walletProvider.getNetwork();
+            const terminology = PROTOCOL_FAMILY_TO_TERMINOLOGY[protocolFamily] || DEFAULT_TERMINOLOGY;
+            return `Error during ${terminology.verb}: ${error}`;
         }
     }
 }
@@ -88,8 +102,7 @@ __decorate([
     This tool will return the details of the connected wallet including:
     - Wallet address
     - Network information (protocol family, network ID, chain ID)
-    - ETH token balance
-    - Native token balance
+    - Native token balance (ETH for EVM networks, SOL for Solana networks)
     - Wallet provider name
     `,
         schema: schemas_1.GetWalletDetailsSchema,
@@ -105,7 +118,7 @@ __decorate([
 This tool will transfer native tokens from the wallet to another onchain address.
 
 It takes the following inputs:
-- amount: The amount to transfer in whole units e.g. 1 ETH or 0.00001 ETH
+- amount: The amount to transfer in whole units (e.g. 1 ETH, 0.1 SOL)
 - destination: The address to receive the funds
 
 Important notes:

package/dist/action-providers/wallet/walletActionProvider.test.js

@@ -4,41 +4,82 @@ const walletActionProvider_1 = require("./walletActionProvider");
 const schemas_1 = require("./schemas");
 describe("Wallet Action Provider", () => {
     const MOCK_ADDRESS = "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83";
-    const MOCK_BALANCE = 1000000000000000000n; // 1 ETH in wei
-    const MOCK_NETWORK = {
+    const MOCK_ETH_BALANCE = 1000000000000000000n;
+    const MOCK_SOL_BALANCE = 1000000000n;
+    const MOCK_EVM_NETWORK = {
         protocolFamily: "evm",
         networkId: "base-sepolia",
         chainId: "123",
     };
+    const MOCK_SOLANA_NETWORK = {
+        protocolFamily: "svm",
+        networkId: "mainnet",
+    };
+    const MOCK_UNKNOWN_NETWORK = {
+        protocolFamily: "unknown",
+        networkId: "testnet",
+    };
     const MOCK_PROVIDER_NAME = "TestWallet";
     const MOCK_TRANSACTION_HASH = "0xghijkl987654321";
+    const MOCK_SIGNATURE = "mock-signature";
     let mockWallet;
     const actionProvider = (0, walletActionProvider_1.walletActionProvider)();
     beforeEach(() => {
         mockWallet = {
             getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
-            getNetwork: jest.fn().mockReturnValue(MOCK_NETWORK),
-            getBalance: jest.fn().mockResolvedValue(MOCK_BALANCE),
+            getNetwork: jest.fn().mockReturnValue(MOCK_EVM_NETWORK),
+            getBalance: jest.fn().mockResolvedValue(MOCK_ETH_BALANCE),
             getName: jest.fn().mockReturnValue(MOCK_PROVIDER_NAME),
             nativeTransfer: jest.fn().mockResolvedValue(MOCK_TRANSACTION_HASH),
         };
     });
     describe("getWalletDetails", () => {
-        it("should successfully get wallet details", async () => {
+        it("should show WEI balance for EVM networks", async () => {
+            mockWallet.getNetwork.mockReturnValue(MOCK_EVM_NETWORK);
+            mockWallet.getBalance.mockResolvedValue(MOCK_ETH_BALANCE);
+            const response = await actionProvider.getWalletDetails(mockWallet, {});
+            const expectedResponse = [
+                "Wallet Details:",
+                `- Provider: ${MOCK_PROVIDER_NAME}`,
+                `- Address: ${MOCK_ADDRESS}`,
+                "- Network:",
+                `  * Protocol Family: ${MOCK_EVM_NETWORK.protocolFamily}`,
+                `  * Network ID: ${MOCK_EVM_NETWORK.networkId}`,
+                `  * Chain ID: ${MOCK_EVM_NETWORK.chainId}`,
+                `- Native Balance: ${MOCK_ETH_BALANCE.toString()} WEI`,
+            ].join("\n");
+            expect(response).toBe(expectedResponse);
+        });
+        it("should show LAMPORTS balance for Solana networks", async () => {
+            mockWallet.getNetwork.mockReturnValue(MOCK_SOLANA_NETWORK);
+            mockWallet.getBalance.mockResolvedValue(MOCK_SOL_BALANCE);
+            const response = await actionProvider.getWalletDetails(mockWallet, {});
+            const expectedResponse = [
+                "Wallet Details:",
+                `- Provider: ${MOCK_PROVIDER_NAME}`,
+                `- Address: ${MOCK_ADDRESS}`,
+                "- Network:",
+                `  * Protocol Family: ${MOCK_SOLANA_NETWORK.protocolFamily}`,
+                `  * Network ID: ${MOCK_SOLANA_NETWORK.networkId}`,
+                `  * Chain ID: N/A`,
+                `- Native Balance: ${MOCK_SOL_BALANCE.toString()} LAMPORTS`,
+            ].join("\n");
+            expect(response).toBe(expectedResponse);
+        });
+        it("should handle unknown protocol families", async () => {
+            mockWallet.getNetwork.mockReturnValue(MOCK_UNKNOWN_NETWORK);
+            mockWallet.getBalance.mockResolvedValue(MOCK_ETH_BALANCE);
             const response = await actionProvider.getWalletDetails(mockWallet, {});
-            expect(mockWallet.getAddress).toHaveBeenCalled();
-            expect(mockWallet.getNetwork).toHaveBeenCalled();
-            expect(mockWallet.getBalance).toHaveBeenCalled();
-            expect(mockWallet.getName).toHaveBeenCalled();
-            const expectedResponse = `Wallet Details:
-- Provider: ${MOCK_PROVIDER_NAME}
-- Address: ${MOCK_ADDRESS}
-- Network: 
-  * Protocol Family: ${MOCK_NETWORK.protocolFamily}
-  * Network ID: ${MOCK_NETWORK.networkId}
-  * Chain ID: ${MOCK_NETWORK.chainId}
-- ETH Balance: 1.000000 ETH
-- Native Balance: ${MOCK_BALANCE.toString()} WEI`;
+            const expectedResponse = [
+                "Wallet Details:",
+                `- Provider: ${MOCK_PROVIDER_NAME}`,
+                `- Address: ${MOCK_ADDRESS}`,
+                "- Network:",
+                `  * Protocol Family: ${MOCK_UNKNOWN_NETWORK.protocolFamily}`,
+                `  * Network ID: ${MOCK_UNKNOWN_NETWORK.networkId}`,
+                `  * Chain ID: N/A`,
+                `- Native Balance: ${MOCK_ETH_BALANCE.toString()} `,
+            ].join("\n");
             expect(response).toBe(expectedResponse);
         });
         it("should handle missing network IDs gracefully", async () => {
@@ -48,6 +89,7 @@ describe("Wallet Action Provider", () => {
             const response = await actionProvider.getWalletDetails(mockWallet, {});
             expect(response).toContain("Network ID: N/A");
             expect(response).toContain("Chain ID: N/A");
+            expect(response).toContain(`Native Balance: ${MOCK_ETH_BALANCE.toString()} WEI`);
         });
         it("should handle errors when getting wallet details", async () => {
             const error = new Error("Failed to get wallet details");
@@ -57,7 +99,7 @@ describe("Wallet Action Provider", () => {
         });
     });
     describe("Native Transfer", () => {
-        const MOCK_AMOUNT = "1.5"; // 1.5 ETH
+        const MOCK_AMOUNT = "1.5"; // 1.5 ETH/SOL
         const MOCK_DESTINATION = "0x321";
         it("should successfully parse valid input", () => {
             const validInput = {
@@ -75,16 +117,52 @@ describe("Wallet Action Provider", () => {
             const result = schemas_1.NativeTransferSchema.safeParse(emptyInput);
             expect(result.success).toBe(false);
         });
-        it("should successfully transfer assets", async () => {
+        it("should successfully transfer ETH", async () => {
+            mockWallet.getNetwork.mockReturnValue(MOCK_EVM_NETWORK);
+            mockWallet.nativeTransfer.mockResolvedValue(MOCK_TRANSACTION_HASH);
             const args = {
                 to: MOCK_DESTINATION,
                 value: MOCK_AMOUNT,
             };
             const response = await actionProvider.nativeTransfer(mockWallet, args);
             expect(mockWallet.nativeTransfer).toHaveBeenCalledWith(MOCK_DESTINATION, MOCK_AMOUNT);
-            expect(response).toBe(`Transferred ${MOCK_AMOUNT} ETH to ${MOCK_DESTINATION}.\nTransaction hash: ${MOCK_TRANSACTION_HASH}`);
+            expect(response).toBe(`Transferred ${MOCK_AMOUNT} ETH to ${MOCK_DESTINATION}\nTransaction hash: ${MOCK_TRANSACTION_HASH}`);
+        });
+        it("should successfully transfer SOL", async () => {
+            mockWallet.getNetwork.mockReturnValue(MOCK_SOLANA_NETWORK);
+            mockWallet.nativeTransfer.mockResolvedValue(MOCK_SIGNATURE);
+            const args = {
+                to: MOCK_DESTINATION,
+                value: MOCK_AMOUNT,
+            };
+            const response = await actionProvider.nativeTransfer(mockWallet, args);
+            expect(mockWallet.nativeTransfer).toHaveBeenCalledWith(MOCK_DESTINATION, MOCK_AMOUNT);
+            expect(response).toBe(`Transferred ${MOCK_AMOUNT} SOL to ${MOCK_DESTINATION}\nSignature: ${MOCK_SIGNATURE}`);
+        });
+        it("should handle ETH transfer errors", async () => {
+            mockWallet.getNetwork.mockReturnValue(MOCK_EVM_NETWORK);
+            const args = {
+                to: MOCK_DESTINATION,
+                value: MOCK_AMOUNT,
+            };
+            const error = new Error("Failed to execute transfer");
+            mockWallet.nativeTransfer.mockRejectedValue(error);
+            const response = await actionProvider.nativeTransfer(mockWallet, args);
+            expect(response).toBe(`Error during transaction: ${error}`);
+        });
+        it("should handle SOL transfer errors", async () => {
+            mockWallet.getNetwork.mockReturnValue(MOCK_SOLANA_NETWORK);
+            const args = {
+                to: MOCK_DESTINATION,
+                value: MOCK_AMOUNT,
+            };
+            const error = new Error("Failed to execute transfer");
+            mockWallet.nativeTransfer.mockRejectedValue(error);
+            const response = await actionProvider.nativeTransfer(mockWallet, args);
+            expect(response).toBe(`Error during transfer: ${error}`);
         });
-        it("should handle transfer errors", async () => {
+        it("should handle unknown protocol family transfer errors", async () => {
+            mockWallet.getNetwork.mockReturnValue(MOCK_UNKNOWN_NETWORK);
             const args = {
                 to: MOCK_DESTINATION,
                 value: MOCK_AMOUNT,
@@ -92,7 +170,7 @@ describe("Wallet Action Provider", () => {
             const error = new Error("Failed to execute transfer");
             mockWallet.nativeTransfer.mockRejectedValue(error);
             const response = await actionProvider.nativeTransfer(mockWallet, args);
-            expect(response).toBe(`Error transferring the asset: ${error}`);
+            expect(response).toBe(`Error during transfer: ${error}`);
         });
     });
     describe("supportsNetwork", () => {

package/dist/network/index.d.ts

@@ -1,2 +1,3 @@
-export * from "./types";
 export * from "./network";
+export * from "./svm";
+export * from "./types";

package/dist/network/index.js

@@ -14,5 +14,6 @@ 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("./types"), exports);
 __exportStar(require("./network"), exports);
+__exportStar(require("./svm"), exports);
+__exportStar(require("./types"), exports);

package/dist/network/network.d.ts

@@ -11,3 +11,10 @@ export declare const NETWORK_ID_TO_CHAIN_ID: Record<string, string>;
  * Maps Coinbase network IDs to Viem chain objects
  */
 export declare const NETWORK_ID_TO_VIEM_CHAIN: Record<string, Chain>;
+/**
+ * Get a chain from the viem chains object
+ *
+ * @param id - The chain ID
+ * @returns The chain
+ */
+export declare const getChain: (id: string) => Chain;