@coinbase/agentkit 0.3.0 → 0.5.0

package/dist/wallet-providers/svmWalletProvider.test.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const svmWalletProvider_1 = require("./svmWalletProvider");
+global.fetch = jest.fn(() => Promise.resolve({
+    ok: true,
+    json: () => Promise.resolve({}),
+}));
+jest.mock("../analytics", () => ({
+    sendAnalyticsEvent: jest.fn().mockImplementation(() => Promise.resolve()),
+}));
+describe("SvmWalletProvider", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        if (!svmWalletProvider_1.SvmWalletProvider.prototype.getConnection) {
+            svmWalletProvider_1.SvmWalletProvider.prototype.getConnection = jest.fn();
+        }
+        if (!svmWalletProvider_1.SvmWalletProvider.prototype.getPublicKey) {
+            svmWalletProvider_1.SvmWalletProvider.prototype.getPublicKey = jest.fn();
+        }
+        if (!svmWalletProvider_1.SvmWalletProvider.prototype.signTransaction) {
+            svmWalletProvider_1.SvmWalletProvider.prototype.signTransaction = jest.fn();
+        }
+        if (!svmWalletProvider_1.SvmWalletProvider.prototype.sendTransaction) {
+            svmWalletProvider_1.SvmWalletProvider.prototype.sendTransaction = jest.fn();
+        }
+        if (!svmWalletProvider_1.SvmWalletProvider.prototype.signAndSendTransaction) {
+            svmWalletProvider_1.SvmWalletProvider.prototype.signAndSendTransaction = jest.fn();
+        }
+        if (!svmWalletProvider_1.SvmWalletProvider.prototype.getSignatureStatus) {
+            svmWalletProvider_1.SvmWalletProvider.prototype.getSignatureStatus = jest.fn();
+        }
+        if (!svmWalletProvider_1.SvmWalletProvider.prototype.waitForSignatureResult) {
+            svmWalletProvider_1.SvmWalletProvider.prototype.waitForSignatureResult = jest.fn();
+        }
+    });
+    it("should extend WalletProvider", () => {
+        const proto = Object.getPrototypeOf(svmWalletProvider_1.SvmWalletProvider);
+        const protoName = proto.name;
+        expect(protoName).toBe("WalletProvider");
+    });
+    it("should have consistent method signatures", () => {
+        const signTransactionDescriptor = Object.getOwnPropertyDescriptor(svmWalletProvider_1.SvmWalletProvider.prototype, "signTransaction");
+        expect(signTransactionDescriptor).toBeDefined();
+        expect(typeof signTransactionDescriptor.value).toBe("function");
+        const sendTransactionDescriptor = Object.getOwnPropertyDescriptor(svmWalletProvider_1.SvmWalletProvider.prototype, "sendTransaction");
+        expect(sendTransactionDescriptor).toBeDefined();
+        expect(typeof sendTransactionDescriptor.value).toBe("function");
+        const getPublicKeyDescriptor = Object.getOwnPropertyDescriptor(svmWalletProvider_1.SvmWalletProvider.prototype, "getPublicKey");
+        expect(getPublicKeyDescriptor).toBeDefined();
+        expect(typeof getPublicKeyDescriptor.value).toBe("function");
+        const getConnectionDescriptor = Object.getOwnPropertyDescriptor(svmWalletProvider_1.SvmWalletProvider.prototype, "getConnection");
+        expect(getConnectionDescriptor).toBeDefined();
+        expect(typeof getConnectionDescriptor.value).toBe("function");
+    });
+});

package/dist/wallet-providers/viemWalletProvider.test.d.ts

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

package/dist/wallet-providers/viemWalletProvider.test.js

@@ -0,0 +1,338 @@
+"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 });
+const viemWalletProvider_1 = require("./viemWalletProvider");
+const viem = __importStar(require("viem"));
+global.fetch = jest.fn(() => Promise.resolve({
+    ok: true,
+    json: () => Promise.resolve({}),
+}));
+jest.mock("../analytics", () => ({
+    sendAnalyticsEvent: jest.fn().mockImplementation(() => Promise.resolve()),
+}));
+// =========================================================
+// consts
+// =========================================================
+const MOCK_CHAIN_ID = 84532;
+const MOCK_ADDRESS = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e";
+const MOCK_ADDRESS_TO = "0x1234567890123456789012345678901234567890";
+const MOCK_TRANSACTION_HASH = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+const MOCK_SIGNATURE = "0x123456789abcdef";
+const MOCK_BALANCE = 10000000000000000000n;
+const MOCK_BLOCK_NUMBER = 12345n;
+const MOCK_MESSAGE = "Hello, World!";
+const MOCK_MAX_FEE_PER_GAS = BigInt(1000000000);
+const MOCK_MAX_PRIORITY_FEE_PER_GAS = BigInt(100000000);
+const MOCK_CHAIN = {
+    id: MOCK_CHAIN_ID,
+    name: "Base Sepolia",
+    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
+    rpcUrls: {
+        default: {
+            http: ["https://sepolia.base.org"],
+        },
+    },
+};
+const MOCK_DATA = {
+    domain: {
+        name: "Example",
+        version: "1",
+        chainId: 1,
+        verifyingContract: "0x0000000000000000000000000000000000000000",
+    },
+    types: {
+        Person: [
+            { name: "name", type: "string" },
+            { name: "wallet", type: "address" },
+        ],
+    },
+    primaryType: "Person",
+    message: {
+        name: "John Doe",
+        wallet: "0x0000000000000000000000000000000000000000",
+    },
+};
+// =========================================================
+// mocks
+// =========================================================
+jest.mock("../network/network", () => ({
+    CHAIN_ID_TO_NETWORK_ID: {
+        1: "mainnet",
+        5: "goerli",
+        11155111: "sepolia",
+    },
+}));
+jest.mock("viem", () => {
+    return {
+        createPublicClient: jest.fn(),
+        createWalletClient: jest.fn(),
+        http: jest.fn(() => jest.fn()),
+        parseEther: jest.fn(() => BigInt(1000000000000000000)),
+        hexToString: jest.fn(),
+        fromHex: jest.fn(),
+        formatEther: jest.fn(),
+        privateKeyToAccount: jest.fn(),
+    };
+});
+jest.mock("viem/accounts", () => {
+    return {
+        privateKeyToAccount: jest.fn(),
+    };
+});
+describe("ViemWalletProvider", () => {
+    let provider;
+    let mockPublicClient;
+    let mockWalletClient;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        const mockAccount = {
+            address: MOCK_ADDRESS,
+        };
+        mockPublicClient = {
+            chain: MOCK_CHAIN,
+            getBalance: jest.fn(),
+            getChainId: jest.fn(),
+            waitForTransactionReceipt: jest.fn(),
+            readContract: jest.fn(),
+            estimateFeesPerGas: jest.fn(),
+            estimateGas: jest.fn(),
+        };
+        mockPublicClient.getBalance.mockResolvedValue(MOCK_BALANCE);
+        mockPublicClient.getChainId.mockResolvedValue(MOCK_CHAIN_ID);
+        mockPublicClient.waitForTransactionReceipt.mockResolvedValue({
+            transactionHash: MOCK_TRANSACTION_HASH,
+            blockNumber: MOCK_BLOCK_NUMBER,
+            status: "success",
+        });
+        mockPublicClient.readContract.mockResolvedValue("mock_result");
+        mockPublicClient.estimateFeesPerGas.mockResolvedValue({
+            maxFeePerGas: MOCK_MAX_FEE_PER_GAS,
+            maxPriorityFeePerGas: MOCK_MAX_PRIORITY_FEE_PER_GAS,
+        });
+        mockPublicClient.estimateGas.mockResolvedValue(BigInt(21000));
+        mockWalletClient = {
+            chain: MOCK_CHAIN,
+            transport: {
+                name: "HTTP JSON-RPC",
+                request: jest.fn(),
+                value: { url: "https://ethereum.example.com" },
+            },
+            account: mockAccount,
+            signMessage: jest.fn(),
+            signTypedData: jest.fn(),
+            signTransaction: jest.fn(),
+            sendTransaction: jest.fn(),
+        };
+        mockWalletClient.signMessage.mockResolvedValue(MOCK_SIGNATURE);
+        mockWalletClient.signTypedData.mockResolvedValue(MOCK_SIGNATURE);
+        mockWalletClient.signTransaction.mockResolvedValue(MOCK_SIGNATURE);
+        mockWalletClient.sendTransaction.mockResolvedValue(MOCK_TRANSACTION_HASH);
+        viem.createPublicClient.mockReturnValue(mockPublicClient);
+        viem.createWalletClient.mockReturnValue(mockWalletClient);
+        viem.http.mockReturnValue(jest.fn());
+        provider = new viemWalletProvider_1.ViemWalletProvider(mockWalletClient);
+    });
+    describe("configuration and initialization", () => {
+        it("should create a provider with default gas multipliers", () => {
+            const provider = new viemWalletProvider_1.ViemWalletProvider(mockWalletClient);
+            expect(provider).toBeInstanceOf(viemWalletProvider_1.ViemWalletProvider);
+            expect(viem.createPublicClient).toHaveBeenCalledWith({
+                chain: MOCK_CHAIN,
+                transport: expect.any(Function),
+            });
+        });
+        it("should create a provider with custom gas multipliers", () => {
+            const gasConfig = {
+                gasLimitMultiplier: 1.5,
+                feePerGasMultiplier: 1.2,
+            };
+            const provider = new viemWalletProvider_1.ViemWalletProvider(mockWalletClient, gasConfig);
+            expect(provider).toBeInstanceOf(viemWalletProvider_1.ViemWalletProvider);
+        });
+    });
+    describe("basic wallet methods", () => {
+        it("should get wallet address", () => {
+            const address = provider.getAddress();
+            expect(address).toBe(MOCK_ADDRESS);
+        });
+        it("should get network", () => {
+            const network = provider.getNetwork();
+            expect(network.chainId).toBe(String(MOCK_CHAIN_ID));
+            expect(network.protocolFamily).toBe("evm");
+        });
+        it("should get wallet name", () => {
+            const name = provider.getName();
+            expect(name).toBe("viem_wallet_provider");
+        });
+        it("should get balance", async () => {
+            const balance = await provider.getBalance();
+            expect(balance).toBe(MOCK_BALANCE);
+            expect(mockPublicClient.getBalance).toHaveBeenCalledWith({
+                address: MOCK_ADDRESS,
+            });
+        });
+        it("should handle connection errors during balance check", async () => {
+            mockPublicClient.getBalance.mockRejectedValueOnce(new Error("Network connection error"));
+            await expect(provider.getBalance()).rejects.toThrow("Network connection error");
+        });
+    });
+    describe("signing operations", () => {
+        it("should sign a message", async () => {
+            const signature = await provider.signMessage(MOCK_MESSAGE);
+            expect(mockWalletClient.signMessage).toHaveBeenCalledWith({
+                account: mockWalletClient.account,
+                message: MOCK_MESSAGE,
+            });
+            expect(signature).toBe(MOCK_SIGNATURE);
+        });
+        it("should sign typed data", async () => {
+            const signature = await provider.signTypedData(MOCK_DATA);
+            expect(mockWalletClient.signTypedData).toHaveBeenCalledWith({
+                account: mockWalletClient.account,
+                ...MOCK_DATA,
+            });
+            expect(signature).toBe(MOCK_SIGNATURE);
+        });
+        it("should sign a transaction", async () => {
+            const transaction = {
+                to: MOCK_ADDRESS_TO,
+                value: BigInt(1000000000000000000),
+            };
+            await provider.signTransaction(transaction);
+            expect(mockWalletClient.signTransaction).toHaveBeenCalledWith({
+                account: mockWalletClient.account,
+                chain: mockWalletClient.chain,
+                to: transaction.to,
+                value: transaction.value,
+                data: transaction.data,
+            });
+        });
+        it("should handle signing errors", async () => {
+            mockWalletClient.signMessage.mockRejectedValueOnce(new Error("Signing failed"));
+            await expect(provider.signMessage("test message")).rejects.toThrow("Signing failed");
+        });
+        it("should handle typed data signing errors", async () => {
+            mockWalletClient.signTypedData.mockRejectedValueOnce(new Error("Signing failed"));
+            await expect(provider.signTypedData(MOCK_DATA)).rejects.toThrow("Signing failed");
+        });
+    });
+    describe("transaction operations", () => {
+        it("should send a transaction", async () => {
+            const transaction = {
+                to: MOCK_ADDRESS_TO,
+                value: BigInt(1000000000000000000),
+            };
+            const hash = await provider.sendTransaction(transaction);
+            expect(mockWalletClient.sendTransaction).toHaveBeenCalled();
+            expect(hash).toBe(MOCK_TRANSACTION_HASH);
+        });
+        it("should wait for a transaction receipt", async () => {
+            const receipt = await provider.waitForTransactionReceipt(MOCK_TRANSACTION_HASH);
+            expect(mockPublicClient.waitForTransactionReceipt).toHaveBeenCalledWith({
+                hash: MOCK_TRANSACTION_HASH,
+            });
+            expect(receipt).toEqual({
+                transactionHash: MOCK_TRANSACTION_HASH,
+                blockNumber: MOCK_BLOCK_NUMBER,
+                status: "success",
+            });
+        });
+        it("should handle transaction send errors", async () => {
+            mockWalletClient.sendTransaction.mockRejectedValueOnce(new Error("Transaction failed"));
+            const transaction = {
+                to: MOCK_ADDRESS_TO,
+                value: BigInt(1000000000000000000),
+            };
+            await expect(provider.sendTransaction(transaction)).rejects.toThrow("Transaction failed");
+        });
+        it("should handle transaction receipt wait errors", async () => {
+            mockPublicClient.waitForTransactionReceipt.mockRejectedValueOnce(new Error("Receipt retrieval failed"));
+            await expect(provider.waitForTransactionReceipt(MOCK_TRANSACTION_HASH)).rejects.toThrow("Receipt retrieval failed");
+        });
+    });
+    describe("native token operations", () => {
+        it("should transfer native tokens", async () => {
+            viem.parseEther.mockReturnValueOnce(BigInt(1000000000000000000));
+            const hash = await provider.nativeTransfer(MOCK_ADDRESS_TO, "1.0");
+            expect(viem.parseEther).toHaveBeenCalledWith("1.0");
+            expect(mockWalletClient.sendTransaction).toHaveBeenCalled();
+            expect(hash).toBe(MOCK_TRANSACTION_HASH);
+        });
+        it("should handle native transfer errors", async () => {
+            mockWalletClient.sendTransaction.mockRejectedValueOnce(new Error("Transaction failed"));
+            await expect(provider.nativeTransfer(MOCK_ADDRESS_TO, "1.0")).rejects.toThrow("Transaction failed");
+        });
+        it("should handle invalid address in native transfer", async () => {
+            const invalidAddress = "not_a_valid_address";
+            mockWalletClient.sendTransaction.mockImplementationOnce(() => {
+                throw new Error("Invalid address");
+            });
+            await expect(provider.nativeTransfer(invalidAddress, "1.0")).rejects.toThrow();
+        });
+    });
+    describe("contract interactions", () => {
+        it("should read contract data", async () => {
+            const contractParams = {
+                address: MOCK_ADDRESS_TO,
+                abi: [],
+                functionName: "balanceOf",
+                args: [MOCK_ADDRESS],
+            };
+            const result = await provider.readContract(contractParams);
+            expect(mockPublicClient.readContract).toHaveBeenCalledWith(contractParams);
+            expect(result).toBe("mock_result");
+        });
+        it("should handle contract read errors", async () => {
+            mockPublicClient.readContract.mockRejectedValueOnce(new Error("Contract read failed"));
+            const contractParams = {
+                address: MOCK_ADDRESS_TO,
+                abi: [],
+                functionName: "balanceOf",
+                args: [MOCK_ADDRESS],
+            };
+            await expect(provider.readContract(contractParams)).rejects.toThrow("Contract read failed");
+        });
+        it("should handle invalid ABI in contract read", async () => {
+            mockPublicClient.readContract.mockRejectedValueOnce(new TypeError("Invalid ABI format"));
+            const contractParams = {
+                address: MOCK_ADDRESS_TO,
+                abi: "invalid abi",
+                functionName: "balanceOf",
+                args: [MOCK_ADDRESS],
+            };
+            await expect(provider.readContract(contractParams)).rejects.toThrow("Invalid ABI format");
+        });
+    });
+});

package/dist/wallet-providers/walletProvider.test.d.ts

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

package/dist/wallet-providers/walletProvider.test.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const walletProvider_1 = require("./walletProvider");
+const analytics_1 = require("../analytics");
+// Mock fetch globally to prevent any actual network requests
+global.fetch = jest.fn(() => Promise.resolve({
+    ok: true,
+    json: () => Promise.resolve({}),
+}));
+jest.mock("../analytics", () => ({
+    sendAnalyticsEvent: jest.fn().mockImplementation(() => Promise.resolve()),
+}));
+const MOCK_ADDRESS = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e";
+const MOCK_NETWORK_ID = "mainnet";
+const MOCK_CHAIN_ID = "1";
+const MOCK_PROTOCOL_FAMILY = "evm";
+const MOCK_WALLET_NAME = "test_wallet_provider";
+const MOCK_NETWORK = {
+    protocolFamily: MOCK_PROTOCOL_FAMILY,
+    networkId: MOCK_NETWORK_ID,
+    chainId: MOCK_CHAIN_ID,
+};
+describe("WalletProvider", () => {
+    /**
+     *
+     */
+    class MockWalletProvider extends walletProvider_1.WalletProvider {
+        /**
+         * Returns the wallet address.
+         *
+         * @returns The wallet address as a string.
+         */
+        getAddress() {
+            return MOCK_ADDRESS;
+        }
+        /**
+         * Returns the network information.
+         *
+         * @returns The network details.
+         */
+        getNetwork() {
+            return MOCK_NETWORK;
+        }
+        /**
+         * Returns the wallet provider name.
+         *
+         * @returns The wallet provider name as a string.
+         */
+        getName() {
+            return MOCK_WALLET_NAME;
+        }
+        /**
+         * Returns the wallet balance.
+         *
+         * @returns A promise resolving to the wallet balance as a bigint.
+         */
+        getBalance() {
+            return Promise.resolve(BigInt(1000000000000000000));
+        }
+        /**
+         * Transfers native tokens.
+         *
+         * @param _to - The recipient address.
+         * @param _value - The amount to transfer.
+         * @returns A promise resolving to the transaction hash as a string.
+         */
+        nativeTransfer(_to, _value) {
+            return Promise.resolve("0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef");
+        }
+    }
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it("should define abstract methods (TypeScript only - not a runtime check)", () => { });
+    it("should track initialization via analytics", () => {
+        new MockWalletProvider();
+        return new Promise(resolve => setTimeout(() => {
+            expect(analytics_1.sendAnalyticsEvent).toHaveBeenCalledWith({
+                name: "agent_initialization",
+                action: "initialize_wallet_provider",
+                component: "wallet_provider",
+                wallet_provider: MOCK_WALLET_NAME,
+                wallet_address: MOCK_ADDRESS,
+                network_id: MOCK_NETWORK_ID,
+                chain_id: MOCK_CHAIN_ID,
+                protocol_family: MOCK_PROTOCOL_FAMILY,
+            });
+            resolve(null);
+        }, 0));
+    });
+    it("should handle tracking failures gracefully", () => {
+        analytics_1.sendAnalyticsEvent.mockImplementationOnce(() => {
+            throw new Error("Test error");
+        });
+        const consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation(() => { });
+        new MockWalletProvider();
+        return new Promise(resolve => setTimeout(() => {
+            expect(consoleWarnSpy).toHaveBeenCalledWith("Failed to track wallet provider initialization:", expect.any(Error));
+            consoleWarnSpy.mockRestore();
+            resolve(null);
+        }, 0));
+    });
+});

package/package.json

@@ -2,7 +2,7 @@
   "name": "@coinbase/agentkit",
   "description": "Coinbase AgentKit core primitives",
   "repository": "https://github.com/coinbase/agentkit",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "author": "Coinbase Inc.",
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -10,24 +10,6 @@
   "files": [
     "dist"
   ],
-  "scripts": {
-    "build": "tsc",
-    "lint": "eslint -c .eslintrc.json \"src/**/*.ts\"",
-    "lint:fix": "eslint -c .eslintrc.json \"src/**/*.ts\" --fix",
-    "format": "prettier -c .prettierrc --write \"**/*.{ts,js,cjs,json,md}\"",
-    "format:check": "prettier -c .prettierrc --check \"**/*.{ts,js,cjs,json,md}\"",
-    "check": "tsc --noEmit",
-    "test": "npx jest --no-cache --testMatch='**/*.test.ts'",
-    "test:dry-run": "npm install && npm ci && npm publish --dry-run",
-    "test:e2e": "npx jest --no-cache --testMatch=**/e2e.ts --coverageThreshold '{}'",
-    "test:types": "tsd --files src/tests/types.test-d.ts",
-    "clean": "rm -rf dist/*",
-    "prepack": "tsc",
-    "docs": "typedoc --entryPoints ./src --entryPointStrategy expand --exclude ./src/tests/**/*.ts",
-    "docs:serve": "http-server ./docs",
-    "dev": "tsc --watch",
-    "generate:action-provider": "tsx ./scripts/generate-action-provider/main.ts"
-  },
   "keywords": [
     "coinbase",
     "sdk",
@@ -40,12 +22,17 @@
     "typescript"
   ],
   "dependencies": {
+    "@across-protocol/app-sdk": "^0.2.0",
     "@alloralabs/allora-sdk": "^0.1.0",
     "@coinbase/coinbase-sdk": "^0.20.0",
     "@jup-ag/api": "^6.0.39",
     "@privy-io/server-auth": "^1.18.4",
     "@solana/spl-token": "^0.4.12",
     "@solana/web3.js": "^1.98.0",
+    "bs58": "^4.0.1",
+    "canonicalize": "^2.1.0",
+    "decimal.js": "^10.5.0",
+    "ethers": "^6.13.5",
     "md5": "^2.3.0",
     "opensea-js": "^7.1.18",
     "reflect-metadata": "^0.2.2",
@@ -59,6 +46,7 @@
     "@types/ora": "^3.2.0",
     "@types/prompts": "^2.4.9",
     "@types/secp256k1": "^4.0.6",
+    "abitype": "^1.0.8",
     "http-server": "^14.1.1",
     "jest": "^29.7.0",
     "mock-fs": "^5.2.0",
@@ -76,5 +64,21 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     }
+  },
+  "scripts": {
+    "build": "tsc",
+    "lint": "eslint -c .eslintrc.json \"src/**/*.ts\"",
+    "lint:fix": "eslint -c .eslintrc.json \"src/**/*.ts\" --fix",
+    "format": "prettier -c .prettierrc --write \"**/*.{ts,js,cjs,json,md}\"",
+    "format:check": "prettier -c .prettierrc --check \"**/*.{ts,js,cjs,json,md}\"",
+    "check": "tsc --noEmit",
+    "test": "jest --no-cache --testMatch='**/*.test.ts'",
+    "test:e2e": "jest --no-cache --testMatch=**/e2e.ts --coverageThreshold '{}'",
+    "test:types": "tsd --files src/tests/types.test-d.ts",
+    "clean": "rm -rf dist/*",
+    "docs": "typedoc --entryPoints ./src --entryPointStrategy expand --exclude ./src/tests/**/*.ts",
+    "docs:serve": "http-server ./docs",
+    "dev": "tsc --watch",
+    "generate:action-provider": "tsx ./scripts/generate-action-provider/main.ts"
   }
-}
+}