emblem-vault-ai-signers 0.1.8-experimental.1 → 0.2.0

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.
 
@@ -21,6 +21,9 @@ 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
 ```
@@ -66,11 +69,44 @@ 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
@@ -305,13 +341,43 @@ 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
@@ -332,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>
@@ -345,10 +411,15 @@ 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)
 
+**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
@@ -357,6 +428,42 @@ On first use, both adapters query `POST /vault/info` with authentication headers
 
 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

package/dist/ethers.d.ts

@@ -1,13 +1,13 @@
 import type { EmblemRemoteConfig, VaultInfo } from "./types.js";
 import { AbstractSigner } from "ethers";
-import type { Provider, TransactionLike, TransactionRequest, TransactionResponse, TypedDataDomain, TypedDataField } from "ethers";
+import type { AbstractProvider, TransactionLike, TransactionRequest, TransactionResponse, TypedDataDomain, TypedDataField } from "ethers";
 export declare class EmblemEthersWallet extends AbstractSigner {
     private readonly _config;
     private _address;
     private _vaultId;
     private _chainId;
     private _initPromise?;
-    constructor(config: EmblemRemoteConfig, provider?: Provider | null, seed?: {
+    constructor(config: EmblemRemoteConfig, provider?: AbstractProvider | null, seed?: {
         address?: `0x${string}`;
         vaultId?: string;
         chainId?: number;
@@ -17,7 +17,7 @@ export declare class EmblemEthersWallet extends AbstractSigner {
     getVaultId(): string;
     setChainId(chainId: number): void;
     getChainId(): number;
-    connect(provider: Provider): EmblemEthersWallet;
+    connect(provider: AbstractProvider): EmblemEthersWallet;
     signMessage(message: string | Uint8Array): Promise<string>;
     signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, value: Record<string, any>): Promise<string>;
     _signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, value: Record<string, any>): Promise<string>;
@@ -26,4 +26,4 @@ export declare class EmblemEthersWallet extends AbstractSigner {
     populateTransaction(transaction: TransactionRequest): Promise<TransactionLike<string>>;
     signAndBroadcast(transaction: TransactionRequest, waitForReceipt?: boolean): Promise<string>;
 }
-export declare function toEthersWallet(config: EmblemRemoteConfig, provider?: Provider | null, infoOverride?: VaultInfo): Promise<EmblemEthersWallet>;
+export declare function toEthersWallet(config: EmblemRemoteConfig, provider?: AbstractProvider | null, infoOverride?: VaultInfo): Promise<EmblemEthersWallet>;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import type { Provider } from "ethers";
+import type { AbstractProvider } from "ethers";
 import type { EmblemRemoteConfig } from "./types.js";
 export type { EmblemRemoteConfig, Hex, VaultInfo } from "./types.js";
 export type { EmblemSecurityConfig } from "./validation.js";
@@ -31,7 +31,7 @@ export declare class EmblemVaultClient {
         source: string;
         type: "local";
     }>;
-    toEthersWallet(provider?: Provider | null): Promise<EmblemEthersWallet>;
+    toEthersWallet(provider?: AbstractProvider | null): Promise<EmblemEthersWallet>;
     toSolanaWeb3Signer(): Promise<EmblemSolanaSigner>;
     toSolanaKitSigner(): Promise<EmblemSolanaSigner>;
     toWeb3Adapter(): Promise<EmblemWeb3Adapter>;

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.1",
+  "version": "0.2.0",
   "description": "Emblem Vault remote signer adapters for viem and ethers",
   "type": "module",
   "main": "dist/index.js",
@@ -33,19 +33,29 @@
     "vault",
     "signer",
     "ethers",
-    "viem"
+    "viem",
+    "solana"
   ],
   "author": "",
   "license": "MIT",
   "peerDependencies": {
     "ethers": "^6.10.0",
-    "viem": "^2.0.0"
+    "viem": "^2.0.0",
+    "@solana/web3.js": "^1.95.0"
+  },
+  "peerDependenciesMeta": {
+    "ethers": { "optional": true },
+    "viem": { "optional": true },
+    "@solana/web3.js": { "optional": true }
   },
   "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"
   }
 }