emblem-vault-ai-signers 0.1.8-experimental.0 → 0.1.8-experimental.2

package/README.md

@@ -7,8 +7,8 @@ Remote signer adapters for Emblem Vault that plug into popular Ethereum librarie
   - Implements `initialize()`, `getVaultId()`, `setChainId()`, `getChainId()`
   - Adds `signAndBroadcast(tx, waitForReceipt?)` helper (optional)
 - `toWeb3Adapter()` – returns a minimal Web3-style signer adapter (EVM)
-- `toSolanaWeb3Signer()` – returns a stub Solana signer with `publicKey`
-- `toSolanaKitSigner()` – returns a stub Solana signer with `publicKey`
+- `toSolanaWeb3Signer()` – creates a @solana/web3.js compatible signer
+- `toSolanaKitSigner()` – creates a Solana Kit compatible signer
 
 > Note: The ethers adapter targets ethers v6.
 
@@ -20,6 +20,12 @@ See the Changelog for release details: CHANGELOG.md
 npm install emblem-vault-ai-signers
 # and bring your own peers
 npm install ethers viem
+
+# Optional: for Solana support
+npm install @solana/web3.js
+
+# Optional: for SDK integration
+npm install emblem-auth-sdk
 ```
 
 ## Usage
@@ -31,7 +37,11 @@ import { mainnet } from "viem/chains";
 import { JsonRpcProvider } from "ethers";
 
 const client = createEmblemClient({
-  apiKey: "your-x-api-key",
+  apiKey: "your-x-api-key", // traditional API key auth
+  // OR use JWT authentication (see Authentication section below)
+  // jwt: "your-jwt-token",
+  // OR use SDK integration
+  // sdk: yourAuthSDK,
   // baseUrl: "https://api.emblemvault.ai" // optional (tests use https://dev-api.emblemvault.ai)
 });
 
@@ -59,13 +69,182 @@ const txHash = await wallet.signAndBroadcast({ to: "0x...", value: 1n }, true);
 const web3Adapter = await client.toWeb3Adapter();
 await web3Adapter.signMessage("hello");
 
-// Solana stubs (address only; signing not yet implemented)
+// Solana (@solana/web3.js compatible)
 const solWeb3 = await client.toSolanaWeb3Signer();
-console.log(solWeb3.publicKey);
+console.log(solWeb3.publicKey); // base58 Solana address
+
+// Sign a message
+const signature = await solWeb3.signMessage("Hello Solana");
+
+// Sign a transaction
+import { VersionedTransaction, TransactionMessage, SystemProgram, PublicKey } from "@solana/web3.js";
+
+const fromPubkey = new PublicKey(solWeb3.publicKey);
+const toPubkey = new PublicKey("...");
+
+const messageV0 = new TransactionMessage({
+  payerKey: fromPubkey,
+  recentBlockhash: "...", // fetch from connection
+  instructions: [
+    SystemProgram.transfer({
+      fromPubkey,
+      toPubkey,
+      lamports: 1000000,
+    }),
+  ],
+}).compileToV0Message();
+
+const transaction = new VersionedTransaction(messageV0);
+const signedTx = await solWeb3.signTransaction(transaction);
+
+// Sign and broadcast
+const txSignature = await solWeb3.signAndBroadcast(transaction, true);
+
+// Utility methods
+const vaultId = solWeb3.getVaultId();
+const canSign = solWeb3.canSign(solWeb3.publicKey); // true
+
+// Solana Kit compatible signer
 const solKit = await client.toSolanaKitSigner();
-console.log(solKit.publicKey);
+// Same interface as solWeb3
+```
+
+## Authentication
+
+The library supports multiple authentication methods. You only need to provide **one** of the following:
+
+### API Key Authentication (Traditional)
+
+```ts
+const client = createEmblemClient({
+  apiKey: "pk_your_api_key_here"
+});
+```
+
+### JWT Authentication
+
+#### Static JWT Token
+```ts
+const client = createEmblemClient({
+  jwt: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
+});
+```
+
+#### Dynamic JWT Provider
+For tokens that need refreshing or are fetched asynchronously:
+```ts
+const client = createEmblemClient({
+  getJwt: async () => {
+    // Fetch from your auth service, refresh if needed
+    return await authService.getAccessToken();
+  }
+});
+
+// Or synchronous
+const client = createEmblemClient({
+  getJwt: () => localStorage.getItem('authToken')
+});
+```
+
+### SDK Integration
+
+If you're using an authentication SDK that manages sessions:
+```ts
+const client = createEmblemClient({
+  sdk: myAuthSDK  // Must have getSession() method that returns { authToken }
+});
+
+// Example with EmblemAuthSDK:
+import { EmblemAuthSDK } from 'emblem-auth-sdk';
+
+const authSDK = new EmblemAuthSDK({
+  appId: 'your-app-id',
+  apiUrl: 'https://api.emblemvault.ai'
+});
+
+const client = createEmblemClient({
+  sdk: authSDK  // EmblemAuthSDK has getSession() that returns { authToken, user, ... }
+});
+
+// Example with custom auth SDK:
+const client = createEmblemClient({
+  sdk: {
+    getSession: () => ({
+      authToken: auth0.getIdToken(),
+      user: { id: '123' }
+    })
+  }
+});
 ```
 
+### Custom Auth Headers
+
+For advanced authentication schemes:
+```ts
+const client = createEmblemClient({
+  getAuthHeaders: async () => ({
+    'Authorization': 'Custom my-custom-token',
+    'X-API-Version': '2.0',
+    'X-Client-ID': 'my-app'
+  })
+});
+```
+
+### Authentication Priority
+
+When multiple auth methods are provided, they're used in this order:
+1. `getAuthHeaders()` (highest priority)
+2. `apiKey`
+3. `jwt` / `getJwt()` / `sdk` (lowest priority)
+
+### Browser vs Server Usage
+
+- **Browser**: JWT/SDK authentication is recommended for client-side apps where users authenticate themselves
+- **Server**: API key authentication is recommended for server-side applications with stored credentials
+
+### Complete SDK Integration Example
+
+Here's a complete example using the EmblemAuthSDK with the signers library:
+
+```ts
+import { EmblemAuthSDK } from 'emblem-auth-sdk';
+import { createEmblemClient } from 'emblem-vault-ai-signers';
+import { JsonRpcProvider, parseEther } from 'ethers';
+
+// 1. Initialize the auth SDK
+const authSDK = new EmblemAuthSDK({
+  appId: 'your-app-id',
+  apiUrl: 'https://api.emblemvault.ai',
+  onSuccess: (session) => {
+    console.log('User authenticated:', session.user);
+  }
+});
+
+// 2. Create the signer client using the SDK
+const client = createEmblemClient({
+  sdk: authSDK  // Pass the SDK instance directly
+});
+
+// 3. Authenticate the user (opens auth modal)
+await authSDK.openAuthModal();
+
+// 4. Once authenticated, create wallets/accounts
+const provider = new JsonRpcProvider(process.env.RPC_URL);
+const wallet = await client.toEthersWallet(provider);
+
+// 5. Sign and send transactions
+const txHash = await wallet.signAndBroadcast({
+  to: "0x...",
+  value: parseEther("0.01")
+});
+```
+
+The SDK integration automatically handles:
+- JWT token management and refresh
+- Session persistence across page reloads
+- Authentication state management
+- Seamless integration with the signers library
+
 ## Replace Private Keys (Examples)
 
 Below are quick swaps showing how to remove local private keys and route signing through Emblem.
@@ -162,20 +341,56 @@ const provider = new JsonRpcProvider(process.env.RPC_URL!);
 await provider.broadcastTransaction(rawTransaction);
 ```
 
-### Solana (stubs)
+### Solana (@solana/web3.js)
 
-These expose the Solana address derived from the vault. Signing is not implemented yet.
+Full Solana signing support with message and transaction signing via remote vault.
 
 ```ts
-const solWeb3 = await client.toSolanaWeb3Signer();
-console.log(solWeb3.publicKey);
+const client = createEmblemClient({ apiKey: process.env.EMBLEM_API_KEY! });
+
+// Create Solana signer
+const solSigner = await client.toSolanaWeb3Signer();
+console.log(solSigner.publicKey); // Base58 Solana address
+
+// Sign messages
+const message = "Hello Solana";
+const signature = await solSigner.signMessage(message);
+console.log(signature); // Uint8Array signature
+
+// Sign transactions
+const transaction = new Transaction()
+  .add(SystemProgram.transfer({
+    fromPubkey: new PublicKey(solSigner.publicKey),
+    toPubkey: new PublicKey("recipient-address"),
+    lamports: 1000000 // 0.001 SOL
+  }));
+
+// Option 1: Sign only
+const signedTx = await solSigner.signTransaction(transaction);
+
+// Option 2: Sign and broadcast
+const txSignature = await solSigner.signAndBroadcast(transaction, true);
+console.log("Transaction signature:", txSignature);
+
+// Utility methods
+console.log("Vault ID:", solSigner.getVaultId());
+console.log("Can sign for this key?", solSigner.canSign(solSigner.publicKey));
+
+// Both @solana/web3.js and Solana Kit compatible
+const solKit = await client.toSolanaKitSigner(); // Same interface
 ```
 
 ## API
 
 ```ts
 type EmblemRemoteConfig = {
-  apiKey: string;
+  // Authentication (pick one method):
+  apiKey?: string;                    // traditional x-api-key header
+  jwt?: string;                       // static JWT for Authorization: Bearer
+  getJwt?: () => Promise<string> | string; // dynamic JWT provider
+  getAuthHeaders?: () => Promise<Record<string, string>> | Record<string, string>; // custom auth headers
+  sdk?: { getSession: () => { authToken?: string } | null }; // SDK integration (e.g., EmblemAuthSDK)
+
   baseUrl?: string; // default https://api.emblemvault.ai
 };
 
@@ -183,8 +398,8 @@ createEmblemClient(config): EmblemVaultClient
 EmblemVaultClient#toViemAccount(): Promise<Account>
 EmblemVaultClient#toEthersWallet(provider?): Promise<Signer>
 EmblemVaultClient#toWeb3Adapter(): Promise<{ address, signMessage, signTypedData, signTransaction }>
-EmblemVaultClient#toSolanaWeb3Signer(): Promise<{ publicKey }>
-EmblemVaultClient#toSolanaKitSigner(): Promise<{ publicKey }>
+EmblemVaultClient#toSolanaWeb3Signer(): Promise<{ publicKey, signMessage, signTransaction, signAndBroadcast, getVaultId, canSign, signAllTransactions }>
+EmblemVaultClient#toSolanaKitSigner(): Promise<{ publicKey, signMessage, signTransaction, signAndBroadcast, getVaultId, canSign, signAllTransactions }>
 
 Ethers wallet (v6) adds:
 - initialize(): Promise<void>
@@ -196,11 +411,16 @@ Ethers wallet (v6) adds:
 
 Adapters POST to the Emblem API endpoints:
 
+**EVM:**
 - `POST /sign-eth-message` – `{ vaultId, message }`
 - `POST /sign-typed-message` – `{ vaultId, domain, types, message }`
 - `POST /sign-eth-tx` – `{ vaultId, transaction }` (expects ethers-serializable fields)
 
-On first use, both adapters query `GET /vault/info` with header `x-api-key` to obtain:
+**Solana:**
+- `POST /sign-solana-message` – `{ vaultId, message }` (base64 encoded)
+- `POST /sign-solana-transaction` – `{ vaultId, transactionToSign, broadcast, versionedTransaction }` (base64 serialized)
+
+On first use, both adapters query `POST /vault/info` with authentication headers to obtain:
 
 - Vault ID
 - Solana Address
@@ -208,6 +428,42 @@ On first use, both adapters query `GET /vault/info` with header `x-api-key` to o
 
 Transactions are normalized to hex/number-like fields before submission.
 
+### Solana
+
+Old (local keypair):
+```ts
+import { Keypair, Transaction } from "@solana/web3.js";
+
+const keypair = Keypair.fromSecretKey(bs58.decode(process.env.PRIVATE_KEY!));
+const transaction = new Transaction().add(...);
+transaction.sign(keypair);
+```
+
+New (Emblem remote signer):
+```ts
+import { createEmblemClient } from "emblem-vault-ai-signers";
+import { VersionedTransaction, TransactionMessage } from "@solana/web3.js";
+
+const client = createEmblemClient({ apiKey: process.env.EMBLEM_API_KEY! });
+const signer = await client.toSolanaWeb3Signer();
+
+// Sign messages
+const msgSignature = await signer.signMessage("Hello Solana");
+
+// Sign versioned transactions
+const messageV0 = new TransactionMessage({
+  payerKey: new PublicKey(signer.publicKey),
+  recentBlockhash: "...",
+  instructions: [...]
+}).compileToV0Message();
+
+const transaction = new VersionedTransaction(messageV0);
+const signedTx = await signer.signTransaction(transaction);
+
+// Sign and broadcast
+const txSig = await signer.signAndBroadcast(transaction, true);
+```
+
 ## Security Considerations
 
 ### Client-Side Usage
@@ -222,15 +478,20 @@ This library is designed for environments where **users provide their own API ke
 
 #### What This Means
 ```javascript
-// Users provide their OWN API keys to YOUR dApp
+// Users provide their OWN credentials to YOUR dApp
 const client = createEmblemClient({
+  // Traditional API key
   apiKey: userApiKey, // User's key, not yours
+  // OR JWT token from user's authentication
+  jwt: userJwtToken, // User's JWT, not yours
+  // OR SDK integration
+  sdk: userAuthSDK, // User's auth SDK
   baseUrl: "https://api.emblemvault.ai"
 });
 ```
 
-If a user runs your dApp code, they are trusting it with their API key and signing authority. There is no way to prevent malicious dApp code from:
-- Logging API keys
+If a user runs your dApp code, they are trusting it with their authentication credentials and signing authority. There is no way to prevent malicious dApp code from:
+- Logging API keys or JWT tokens
 - Intercepting `fetch()` calls
 - Changing the `baseUrl`
 - Making unauthorized signing requests
@@ -241,9 +502,10 @@ If a user runs your dApp code, they are trusting it with their API key and signi
 
 1. **Only use trusted dApps** - Verify the source and reputation
 2. **Review open source code** when possible
-3. **Use separate API keys** for different dApps
+3. **Use separate credentials** for different dApps (API keys, JWT tokens)
 4. **Monitor signing activity** in your Emblem dashboard
-5. **Test with staging keys first** before using production
+5. **Test with staging credentials first** before using production
+6. **Understand token expiration** - JWT tokens expire and may need refresh
 
 ### Best Practices for Implementers
 
@@ -251,16 +513,20 @@ If a user runs your dApp code, they are trusting it with their API key and signi
 2. **Document your security model** - Be transparent about API key handling
 3. **Minimize dependencies** - Reduce supply chain attack surface
 4. **Use Content Security Policy** - Add CSP headers to protect against XSS
-5. **Never log or store user API keys** - Only use them in-memory for signing
-6. **Implement proper error handling** - Don't expose API keys in error messages
+5. **Never log or store user credentials** - Only use API keys/JWTs in-memory for signing
+6. **Implement proper error handling** - Don't expose credentials in error messages
+7. **Handle JWT expiration gracefully** - Implement token refresh when using dynamic JWTs
+8. **Prefer JWT auth for client-side apps** - More secure than exposing long-lived API keys
 
 ### Server-Side Usage
 
 When used server-side (Node.js):
 - Store API keys in environment variables
-- Never expose keys to client-side code
+- Never expose credentials to client-side code
 - Use proper access controls and authentication
 - Implement rate limiting if exposing signing endpoints
+- Consider API key auth for server-to-server communication
+- Use JWT auth when proxying user authentication
 
 ### Development vs Production
 
@@ -273,14 +539,20 @@ const devClient = createEmblemClient({
   baseUrl: "https://dev-api.emblemvault.ai"
 });
 
-// Production
+// Production with API key
 const prodClient = createEmblemClient({
   apiKey: process.env.PROD_API_KEY,
   baseUrl: "https://api.emblemvault.ai"
 });
+
+// Production with JWT (client-side)
+const jwtClient = createEmblemClient({
+  getJwt: async () => await auth.getAccessToken(),
+  baseUrl: "https://api.emblemvault.ai"
+});
 ```
 
-API keys from one environment do not work in another, providing natural isolation.
+Credentials from one environment do not work in another, providing natural isolation.
 
 ---
 

package/dist/solana.d.ts

@@ -1,9 +1,31 @@
 import type { EmblemRemoteConfig, VaultInfo } from "./types.js";
-export declare class EmblemSolanaSigner {
+export interface SolanaSignerInterface {
+    publicKey: string;
+    signMessage(message: Uint8Array | string): Promise<Uint8Array>;
+    signTransaction(transaction: any): Promise<any>;
+}
+export interface SolanaKitSignerInterface {
+    publicKey: string;
+    signMessage(message: Uint8Array | string): Promise<Uint8Array>;
+    signTransaction(transaction: any): Promise<any>;
+}
+export declare class EmblemSolanaSigner implements SolanaSignerInterface, SolanaKitSignerInterface {
     readonly publicKey: string;
-    constructor(publicKey: string);
-    signMessage(_message: Uint8Array | string): Promise<string>;
-    signTransaction(_tx: unknown): Promise<string>;
+    private readonly config;
+    private readonly vaultId;
+    constructor(config: EmblemRemoteConfig, vaultInfo: VaultInfo);
+    signMessage(message: Uint8Array | string): Promise<Uint8Array>;
+    signTransaction(transaction: any): Promise<any>;
+    private serializeTransaction;
+    private deserializeTransaction;
+    /** Get the vault ID for this signer */
+    getVaultId(): string;
+    /** Sign multiple transactions in batch */
+    signAllTransactions(transactions: any[]): Promise<any[]>;
+    /** Check if this signer can sign for a given public key */
+    canSign(publicKey: string): boolean;
+    /** Sign and optionally broadcast a transaction */
+    signAndBroadcast(transaction: any, broadcast?: boolean): Promise<string>;
 }
 export declare function toSolanaWeb3Signer(config: EmblemRemoteConfig, infoOverride?: VaultInfo): Promise<EmblemSolanaSigner>;
 export declare function toSolanaKitSigner(config: EmblemRemoteConfig, infoOverride?: VaultInfo): Promise<EmblemSolanaSigner>;

package/dist/solana.js

@@ -1,20 +1,149 @@
+import { emblemPost } from "./http.js";
 import { fetchVaultInfo } from "./vault.js";
 export class EmblemSolanaSigner {
-    constructor(publicKey) {
-        this.publicKey = publicKey;
+    constructor(config, vaultInfo) {
+        this.publicKey = vaultInfo.address;
+        this.config = config;
+        this.vaultId = vaultInfo.vaultId;
     }
-    async signMessage(_message) {
-        throw new Error("Solana signing via Emblem is not implemented yet");
+    async signMessage(message) {
+        // Convert message to bytes if it's a string
+        const messageBytes = typeof message === 'string'
+            ? new TextEncoder().encode(message)
+            : message;
+        // Convert to base64 for API transmission
+        const messageBase64 = btoa(String.fromCharCode(...messageBytes));
+        const response = await emblemPost("/sign-solana-message", { vaultId: this.vaultId, message: messageBase64 }, this.config);
+        // The server returns a signature - could be base64, base58, or hex
+        // Let's check what format we're getting and handle accordingly
+        // Try to decode as base58 first (Solana standard)
+        try {
+            // Use @solana/web3.js bs58 decoder if available, otherwise fallback
+            if (typeof window !== 'undefined' && window.bs58) {
+                return window.bs58.decode(response.signature);
+            }
+            // For Node.js environments or if bs58 is not globally available
+            // The signature might be base64 encoded
+            const signatureBytes = Uint8Array.from(atob(response.signature), c => c.charCodeAt(0));
+            return signatureBytes;
+        }
+        catch (e) {
+            // If base64 decode fails, try treating as hex
+            if (response.signature.startsWith('0x')) {
+                const hex = response.signature.slice(2);
+                const bytes = new Uint8Array(hex.length / 2);
+                for (let i = 0; i < hex.length; i += 2) {
+                    bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
+                }
+                return bytes;
+            }
+            throw new Error(`Unable to decode signature format: ${e}`);
+        }
     }
-    async signTransaction(_tx) {
-        throw new Error("Solana transaction signing via Emblem is not implemented yet");
+    async signTransaction(transaction) {
+        // Serialize transaction for API transmission
+        const serializedTransaction = this.serializeTransaction(transaction);
+        const response = await emblemPost("/sign-solana-transaction", {
+            vaultId: this.vaultId,
+            transactionToSign: serializedTransaction, // Pass the base64 string directly
+            broadcast: false, // Don't broadcast, just sign
+            versionedTransaction: true // Match API test format
+        }, this.config);
+        // Parse the signed transaction response - handle both response formats
+        const signedTxData = response.serializedSignedTransaction || response.signedTransaction;
+        if (!signedTxData) {
+            throw new Error('No signed transaction data received from server');
+        }
+        return this.deserializeTransaction(signedTxData);
+    }
+    serializeTransaction(tx) {
+        // Handle different transaction formats from @solana/web3.js
+        if (tx && typeof tx === 'object') {
+            // For VersionedTransaction or Transaction objects
+            if (tx.serialize) {
+                // Server expects just the base64 string, not an object
+                const serialized = tx.serialize();
+                const base64 = btoa(String.fromCharCode(...serialized));
+                return base64;
+            }
+            // For transaction objects with instructions
+            if (tx.instructions || tx.recentBlockhash) {
+                throw new Error('Cannot serialize unsigned transaction objects. Please use VersionedTransaction.');
+            }
+        }
+        // Fallback: assume it's already a string
+        return tx;
+    }
+    deserializeTransaction(signedTxData) {
+        // If it's already an object (shouldn't happen based on type), handle it
+        if (typeof signedTxData === 'object' && signedTxData.serializedSignedTransaction) {
+            signedTxData = signedTxData.serializedSignedTransaction;
+        }
+        // If it's a string, decode from base64
+        if (typeof signedTxData === 'string') {
+            try {
+                // The server returns base64, so decode it
+                const decoded = atob(signedTxData);
+                return new Uint8Array(decoded.split('').map(c => c.charCodeAt(0)));
+            }
+            catch (e) {
+                console.error('Failed to decode transaction:', e);
+                throw new Error(`Unable to deserialize transaction response: ${e}`);
+            }
+        }
+        // If it's already a Uint8Array or other type, return as-is
+        return signedTxData;
+    }
+    // Additional utility methods for @solana/web3.js compatibility
+    /** Get the vault ID for this signer */
+    getVaultId() {
+        return this.vaultId;
+    }
+    /** Sign multiple transactions in batch */
+    async signAllTransactions(transactions) {
+        // Sign each transaction individually for now
+        // Could be optimized with a batch API endpoint in the future
+        const results = [];
+        for (const tx of transactions) {
+            results.push(await this.signTransaction(tx));
+        }
+        return results;
+    }
+    /** Check if this signer can sign for a given public key */
+    canSign(publicKey) {
+        return publicKey === this.publicKey;
+    }
+    /** Sign and optionally broadcast a transaction */
+    async signAndBroadcast(transaction, broadcast = true) {
+        // Serialize transaction for API transmission
+        const serializedTransaction = this.serializeTransaction(transaction);
+        const response = await emblemPost("/sign-solana-transaction", {
+            vaultId: this.vaultId,
+            transactionToSign: serializedTransaction, // Pass the base64 string directly
+            broadcast: broadcast,
+            versionedTransaction: true // Match API test format
+        }, this.config);
+        if (broadcast) {
+            // Return the transaction signature
+            if (!response.transactionSignature) {
+                throw new Error('No transaction signature received from broadcast');
+            }
+            return response.transactionSignature;
+        }
+        else {
+            // Return the signed transaction data
+            if (!response.serializedSignedTransaction) {
+                throw new Error('No signed transaction data received from server');
+            }
+            return response.serializedSignedTransaction;
+        }
     }
 }
 export async function toSolanaWeb3Signer(config, infoOverride) {
     const info = infoOverride ?? (await fetchVaultInfo(config));
-    return new EmblemSolanaSigner(info.address);
+    return new EmblemSolanaSigner(config, info);
 }
 export async function toSolanaKitSigner(config, infoOverride) {
     const info = infoOverride ?? (await fetchVaultInfo(config));
-    return new EmblemSolanaSigner(info.address);
+    return new EmblemSolanaSigner(config, info);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "emblem-vault-ai-signers",
-  "version": "0.1.8-experimental.0",
+  "version": "0.1.8-experimental.2",
   "description": "Emblem Vault remote signer adapters for viem and ethers",
   "type": "module",
   "main": "dist/index.js",
@@ -42,10 +42,13 @@
     "viem": "^2.0.0"
   },
   "devDependencies": {
-    "typescript": "^5.3.3",
-    "vitest": "^1.6.0",
+    "@solana/web3.js": "^1.95.0",
+    "bs58": "^6.0.0",
     "dotenv": "^16.4.5",
     "ethers": "^6.10.0",
-    "viem": "^2.0.0"
+    "tweetnacl": "^1.0.3",
+    "typescript": "^5.3.3",
+    "viem": "^2.0.0",
+    "vitest": "^1.6.0"
   }
 }