gora8-signer 0.1.2 → 0.1.3

package/README.md

@@ -33,10 +33,12 @@ npm install gora8-signer
 ## Quick start — standalone signer process
 
 ```bash
-# Generate a key (encrypted-file store shown here; OS keychain is used
-# automatically instead when available — see Storage below)
+# Generate both keys — EVM and Solana — together (encrypted-file store
+# shown here; OS keychain is used automatically instead when available —
+# see Storage below)
 export GORA8_SIGNER_KEK=$(openssl rand -hex 32)   # dev only — see Storage
 npx gora8-signer init my-agent-id
+# {"evmAddress":"0x...","solanaAddress":"..."}
 
 # Run the signer as its own process
 npx gora8-signer start my-agent-id
@@ -48,9 +50,16 @@ Your agent's own code then talks to it over the socket:
 import { SignerIpcClient } from "gora8-signer";
 
 const signer = new SignerIpcClient("~/.gora8/signer/my-agent-id/signer.sock");
-const address = await signer.address();
+const evmAddress = await signer.address();
+const solanaAddress = await signer.solanaAddress();
 ```
 
+Both keys are entirely independent secrets — different curves
+(secp256k1 vs. Ed25519), different storage entries — generated,
+stored, and used the same way, on the same storage backends. An
+agent that only ever transacts on one chain still gets both; the
+unused one simply never gets asked to sign anything.
+
 ## Storage
 
 Defaults to the OS-native keychain (macOS Keychain, Windows Credential

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { join } from "node:path";
 import { homedir } from "node:os";
-import { defaultKeyStore, EnvKekProvider } from "./keystore.js";
+import { defaultKeyStore, defaultSolanaKeyStore, EnvKekProvider } from "./keystore.js";
 import { PolicyEngine } from "./policy.js";
 import { AuditLog } from "./audit-log.js";
 import { Signer, SlidingWindowRateLimiter } from "./signer.js";
@@ -30,18 +30,28 @@ async function main() {
         process.exit(1);
     }
     const dir = dataDir(agentId);
-    const keyStore = await defaultKeyStore(agentId, join(dir, "key.enc.json"), new EnvKekProvider());
+    const kek = new EnvKekProvider();
+    const keyStore = await defaultKeyStore(agentId, join(dir, "key.enc.json"), kek);
+    const solanaKeyStore = await defaultSolanaKeyStore(agentId, join(dir, "solana-key.enc.json"), kek);
     const auditLog = new AuditLog(join(dir, "audit.jsonl"));
     switch (command) {
         case "init": {
-            if (await keyStore.hasKey()) {
-                console.error(`A key already exists for agent "${agentId}". Not generating a new one.`);
-                const address = await keyStore.address();
-                console.log(address);
-                process.exit(1);
-            }
-            const address = await keyStore.generateAndStore();
-            console.log(address);
+            // Both keys generated together, same as `gora8 deploy` provisions
+            // both an EVM and a Solana wallet for every agent today — two
+            // entirely independent secrets (different curves, different
+            // storage entries), not one key used two ways. Each is checked and
+            // reported separately so a partial prior init (e.g. EVM exists,
+            // Solana doesn't yet — the state every pre-Solana-self-custody
+            // agent is in) doesn't block generating just the missing one.
+            const hasEvm = await keyStore.hasKey();
+            const evmAddress = hasEvm ? await keyStore.address() : await keyStore.generateAndStore();
+            if (hasEvm)
+                console.error(`An EVM key already exists for agent "${agentId}". Not generating a new one.`);
+            const hasSolana = await solanaKeyStore.hasKey();
+            const solanaAddress = hasSolana ? await solanaKeyStore.address() : await solanaKeyStore.generateAndStore();
+            if (hasSolana)
+                console.error(`A Solana key already exists for agent "${agentId}". Not generating a new one.`);
+            console.log(JSON.stringify({ evmAddress, solanaAddress }));
             break;
         }
         case "start": {
@@ -63,6 +73,7 @@ async function main() {
             const policyEngine = new PolicyEngine({ fetchMandate: () => fetchMandate(mandateAgentId, apiBase) }, auditLog);
             const signer = new Signer({
                 keyStore,
+                solanaKeyStore,
                 policyEngine,
                 auditLog,
                 rateLimiter: new SlidingWindowRateLimiter(30, 60_000), // 30 signatures/min sanity backstop

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export { OsKeychainStore, EncryptedFileStore, EnvKekProvider, defaultKeyStore } from "./keystore.js";
-export type { KeyStore, KekProvider } from "./keystore.js";
+export { OsKeychainSecretStore, EncryptedFileSecretStore, EnvKekProvider, defaultKeyStore, defaultSolanaKeyStore } from "./keystore.js";
+export type { KeyStore, SolanaKeyStore, SecretStore, KekProvider } from "./keystore.js";
 export { PolicyEngine } from "./policy.js";
 export type { Mandate, SigningRequest, PolicyDecision, PolicyEngineOptions, SpendTracker } from "./policy.js";
 export { AuditLog } from "./audit-log.js";

package/dist/index.js

@@ -1,4 +1,4 @@
-export { OsKeychainStore, EncryptedFileStore, EnvKekProvider, defaultKeyStore } from "./keystore.js";
+export { OsKeychainSecretStore, EncryptedFileSecretStore, EnvKekProvider, defaultKeyStore, defaultSolanaKeyStore } from "./keystore.js";
 export { PolicyEngine } from "./policy.js";
 export { AuditLog } from "./audit-log.js";
 export { Signer, SlidingWindowRateLimiter } from "./signer.js";

package/dist/ipc-client.d.ts

@@ -42,9 +42,20 @@ export declare class SignerIpcClient {
             to: `0x${string}`;
             value: bigint;
             data: `0x${string}`;
+            nonce: number;
+            gas?: bigint;
+            gasPrice?: bigint;
         };
         chainId: number;
     }): Promise<{
         signedTransaction: `0x${string}`;
     }>;
+    solanaAddress(): Promise<string>;
+    signSolanaTransaction(params: {
+        serializedTransaction: string;
+        amount: number | null;
+        counterparty: string | null;
+    }): Promise<{
+        signature: string;
+    }>;
 }

package/dist/ipc-client.js

@@ -50,4 +50,10 @@ export class SignerIpcClient {
     signWithdrawal(params) {
         return this.call("signWithdrawal", params);
     }
+    solanaAddress() {
+        return this.call("solanaAddress");
+    }
+    signSolanaTransaction(params) {
+        return this.call("signSolanaTransaction", params);
+    }
 }

package/dist/ipc-server.js

@@ -70,6 +70,10 @@ export class SignerIpcServer {
                 return this.signer.signAgreementTerms(params);
             case "signWithdrawal":
                 return this.signer.signWithdrawal(params);
+            case "solanaAddress":
+                return this.signer.solanaAddress();
+            case "signSolanaTransaction":
+                return this.signer.signSolanaTransaction(params);
             default:
                 throw new Error(`Unknown method: ${method}`);
         }

package/dist/keystore.d.ts

@@ -1,33 +1,44 @@
 import type { Address, Hex } from "viem";
+export interface SecretStore {
+    hasSecret(): Promise<boolean>;
+    /** Persists `secret` — throws if one is already stored; callers must
+     *  not use this to overwrite an existing secret. */
+    store(secret: string): Promise<void>;
+    /** The only way to read the secret. `fn`'s return value escapes this
+     *  scope; the raw secret string itself never does. */
+    withSecret<T>(fn: (secret: string) => Promise<T> | T): Promise<T>;
+}
 export interface KeyStore {
-    /** True once a key has been generated and stored — callers check this
-     *  before generateAndStore() to avoid silently overwriting an existing
-     *  key (which would orphan whatever address was already registered
-     *  on-chain). */
     hasKey(): Promise<boolean>;
-    /** Generates a fresh key, persists it, and returns only the derived
-     *  address — never the key itself. Throws if a key already exists;
-     *  callers must not call this to "reset" a store. */
     generateAndStore(): Promise<Address>;
-    /** The only way to use the key. `fn`'s return value escapes this
-     *  scope; the raw private key string itself never does. */
     withPrivateKey<T>(fn: (privateKey: Hex) => Promise<T> | T): Promise<T>;
     address(): Promise<Address>;
 }
-export declare class OsKeychainStore implements KeyStore {
+export interface SolanaKeyStore {
+    hasKey(): Promise<boolean>;
+    generateAndStore(): Promise<string>;
+    /** `fn` receives the raw 64-byte Solana secret key, matching
+     *  `@solana/web3.js`'s `Keypair.fromSecretKey()` input — same scoped-
+     *  access discipline as EVM's `withPrivateKey`. */
+    withSecretKey<T>(fn: (secretKey: Uint8Array) => Promise<T> | T): Promise<T>;
+    address(): Promise<string>;
+}
+export declare class OsKeychainSecretStore implements SecretStore {
     private readonly service;
     private readonly account;
-    constructor(agentId: string);
+    /** `account` should be unique per (agentId, key kind) pair — e.g.
+     *  `"<agentId>"` for the EVM key, `"<agentId>:solana"` for Solana —
+     *  so the two keys never collide in the same OS keychain. */
+    constructor(account: string, service?: string);
     private entry;
-    hasKey(): Promise<boolean>;
-    generateAndStore(): Promise<Address>;
-    withPrivateKey<T>(fn: (privateKey: Hex) => Promise<T> | T): Promise<T>;
-    address(): Promise<Address>;
+    hasSecret(): Promise<boolean>;
+    store(secret: string): Promise<void>;
+    withSecret<T>(fn: (secret: string) => Promise<T> | T): Promise<T>;
 }
 export interface KekProvider {
-    /** Returns a 32-byte key-encryption key. Called once per
-     *  generateAndStore()/withPrivateKey() — implementations are expected
-     *  to cache/memoize their own upstream fetch if it's expensive. */
+    /** Returns a 32-byte key-encryption key. Called once per store()/
+     *  withSecret() — implementations are expected to cache/memoize their
+     *  own upstream fetch if it's expensive. */
     getKek(): Promise<Buffer>;
 }
 /** Development/local-only KEK provider — reads a hex-encoded 32-byte key
@@ -36,25 +47,26 @@ export interface KekProvider {
  *  cloud account, and so self-hosted deployments have something to point
  *  at before wiring up their own KMS-backed provider (see this file's
  *  doc comment on KekProvider — implement one against AWS KMS/GCP KMS/
- *  age and pass it to EncryptedFileStore instead, for anything real). */
+ *  age and pass it to EncryptedFileSecretStore instead, for anything real). */
 export declare class EnvKekProvider implements KekProvider {
     private readonly envVar;
     constructor(envVar?: string);
     getKek(): Promise<Buffer>;
 }
-export declare class EncryptedFileStore implements KeyStore {
+export declare class EncryptedFileSecretStore implements SecretStore {
     private readonly filePath;
     private readonly kek;
     constructor(filePath: string, kek: KekProvider);
-    hasKey(): Promise<boolean>;
-    generateAndStore(): Promise<Address>;
-    withPrivateKey<T>(fn: (privateKey: Hex) => Promise<T> | T): Promise<T>;
-    address(): Promise<Address>;
+    hasSecret(): Promise<boolean>;
+    store(secret: string): Promise<void>;
+    withSecret<T>(fn: (secret: string) => Promise<T> | T): Promise<T>;
     private writeEncrypted;
     private readEncrypted;
 }
-/** Picks OS keychain by default, falling back to the encrypted file
- *  store only when the OS keychain genuinely isn't available (headless
- *  container with no Secret Service, etc.) — never silently prefers the
- *  weaker option. */
 export declare function defaultKeyStore(agentId: string, fallbackFilePath: string, kek: KekProvider): Promise<KeyStore>;
+/** Same defaulting behavior as `defaultKeyStore`, for the Solana key —
+ *  `fallbackFilePath` must be a different path than the EVM store's
+ *  (e.g. `solana-key.enc.json` next to `key.enc.json`), and the OS
+ *  keychain account is automatically suffixed so the two never collide
+ *  under the same service/account pair. */
+export declare function defaultSolanaKeyStore(agentId: string, fallbackFilePath: string, kek: KekProvider): Promise<SolanaKeyStore>;

package/dist/keystore.js

@@ -1,8 +1,9 @@
 import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+import { Keypair } from "@solana/web3.js";
 import { randomBytes, createCipheriv, createDecipheriv, scryptSync } from "node:crypto";
 import { readFile, writeFile, mkdir } from "node:fs/promises";
 import { dirname } from "node:path";
-function deriveAddress(privateKey) {
+function deriveEvmAddress(privateKey) {
     return privateKeyToAccount(privateKey).address;
 }
 // ── OS-native keychain store (default) ─────────────────────────────────
@@ -13,54 +14,46 @@ function deriveAddress(privateKey) {
 // because it's the closest local equivalent to what a TEE-based vendor
 // gives you: the OS, not this process's own memory or a plain file, is
 // what actually guards the secret at rest.
-export class OsKeychainStore {
+export class OsKeychainSecretStore {
     service;
     account;
-    constructor(agentId) {
-        this.service = "gora8-signer";
-        this.account = agentId;
+    /** `account` should be unique per (agentId, key kind) pair — e.g.
+     *  `"<agentId>"` for the EVM key, `"<agentId>:solana"` for Solana —
+     *  so the two keys never collide in the same OS keychain. */
+    constructor(account, service = "gora8-signer") {
+        this.service = service;
+        this.account = account;
     }
     async entry() {
         const { Entry } = await import("@napi-rs/keyring");
         return new Entry(this.service, this.account);
     }
-    async hasKey() {
+    async hasSecret() {
         try {
             const entry = await this.entry();
             // @napi-rs/keyring's getPassword() returns null for a missing entry
-            // rather than throwing — treating "didn't throw" as "key exists"
-            // (the previous implementation here) is a false positive on every
-            // backend that behaves this way: hasKey() would report true for an
-            // agent that has never had a key generated, and the subsequent
-            // withPrivateKey()/address() call would then try to derive an
-            // address from null and crash. A missing entry is only genuinely
-            // "no key" when the returned password is a non-empty string.
+            // rather than throwing — treating "didn't throw" as "secret exists"
+            // is a false positive on every backend that behaves this way.
             return typeof entry.getPassword() === "string";
         }
         catch {
             return false;
         }
     }
-    async generateAndStore() {
-        if (await this.hasKey()) {
-            throw new Error(`A key already exists for agent "${this.account}" in the OS keychain. ` +
-                "Refusing to overwrite — generating a new key would orphan the address already registered on-chain.");
+    async store(secret) {
+        if (await this.hasSecret()) {
+            throw new Error(`A secret already exists for "${this.account}" in the OS keychain. Refusing to overwrite.`);
         }
-        const privateKey = generatePrivateKey();
         const entry = await this.entry();
-        entry.setPassword(privateKey);
-        return deriveAddress(privateKey);
+        entry.setPassword(secret);
     }
-    async withPrivateKey(fn) {
+    async withSecret(fn) {
         const entry = await this.entry();
-        const privateKey = entry.getPassword();
-        if (typeof privateKey !== "string") {
-            throw new Error(`No key found for agent "${this.account}" in the OS keychain — run \`gora8-signer init\` first.`);
+        const secret = entry.getPassword();
+        if (typeof secret !== "string") {
+            throw new Error(`No secret found for "${this.account}" in the OS keychain — run \`gora8-signer init\` first.`);
         }
-        return fn(privateKey);
-    }
-    async address() {
-        return this.withPrivateKey((pk) => deriveAddress(pk));
+        return fn(secret);
     }
 }
 /** Development/local-only KEK provider — reads a hex-encoded 32-byte key
@@ -69,7 +62,7 @@ export class OsKeychainStore {
  *  cloud account, and so self-hosted deployments have something to point
  *  at before wiring up their own KMS-backed provider (see this file's
  *  doc comment on KekProvider — implement one against AWS KMS/GCP KMS/
- *  age and pass it to EncryptedFileStore instead, for anything real). */
+ *  age and pass it to EncryptedFileSecretStore instead, for anything real). */
 export class EnvKekProvider {
     envVar;
     constructor(envVar = "GORA8_SIGNER_KEK") {
@@ -78,7 +71,7 @@ export class EnvKekProvider {
     async getKek() {
         const hex = process.env[this.envVar];
         if (!hex) {
-            throw new Error(`${this.envVar} is not set. EncryptedFileStore needs a 32-byte hex-encoded key-encryption ` +
+            throw new Error(`${this.envVar} is not set. EncryptedFileSecretStore needs a 32-byte hex-encoded key-encryption ` +
                 "key — generate one with `openssl rand -hex 32` for local/dev use, or implement a real " +
                 "KekProvider against your own KMS for production (see keystore.ts's doc comment).");
         }
@@ -89,14 +82,14 @@ export class EnvKekProvider {
         return buf;
     }
 }
-export class EncryptedFileStore {
+export class EncryptedFileSecretStore {
     filePath;
     kek;
     constructor(filePath, kek) {
         this.filePath = filePath;
         this.kek = kek;
     }
-    async hasKey() {
+    async hasSecret() {
         try {
             await readFile(this.filePath);
             return true;
@@ -105,23 +98,17 @@ export class EncryptedFileStore {
             return false;
         }
     }
-    async generateAndStore() {
-        if (await this.hasKey()) {
-            throw new Error(`A key already exists at ${this.filePath}. Refusing to overwrite — generating a new key ` +
-                "would orphan the address already registered on-chain.");
+    async store(secret) {
+        if (await this.hasSecret()) {
+            throw new Error(`A secret already exists at ${this.filePath}. Refusing to overwrite.`);
         }
-        const privateKey = generatePrivateKey();
-        await this.writeEncrypted(privateKey);
-        return deriveAddress(privateKey);
-    }
-    async withPrivateKey(fn) {
-        const privateKey = await this.readEncrypted();
-        return fn(privateKey);
+        await this.writeEncrypted(secret);
     }
-    async address() {
-        return this.withPrivateKey((pk) => deriveAddress(pk));
+    async withSecret(fn) {
+        const secret = await this.readEncrypted();
+        return fn(secret);
     }
-    async writeEncrypted(privateKey) {
+    async writeEncrypted(secret) {
         const salt = randomBytes(16);
         const kekMaterial = await this.kek.getKek();
         // scrypt-derive a per-store encryption key from the raw KEK + a
@@ -131,7 +118,7 @@ export class EncryptedFileStore {
         const derivedKey = scryptSync(kekMaterial, salt, 32);
         const iv = randomBytes(12);
         const cipher = createCipheriv("aes-256-gcm", derivedKey, iv);
-        const ciphertext = Buffer.concat([cipher.update(privateKey, "utf8"), cipher.final()]);
+        const ciphertext = Buffer.concat([cipher.update(secret, "utf8"), cipher.final()]);
         const authTag = cipher.getAuthTag();
         const payload = {
             version: 1,
@@ -157,18 +144,80 @@ export class EncryptedFileStore {
 /** Picks OS keychain by default, falling back to the encrypted file
  *  store only when the OS keychain genuinely isn't available (headless
  *  container with no Secret Service, etc.) — never silently prefers the
- *  weaker option. */
-export async function defaultKeyStore(agentId, fallbackFilePath, kek) {
+ *  weaker option. Shared by both EVM's and Solana's key stores below —
+ *  `account`/`fallbackFilePath` must already be kind-specific (see
+ *  OsKeychainSecretStore's doc comment). */
+async function defaultSecretStore(account, fallbackFilePath, kek) {
     try {
         await import("@napi-rs/keyring");
-        const store = new OsKeychainStore(agentId);
+        const store = new OsKeychainSecretStore(account);
         // Probe for a usable keychain backend (this throws on headless Linux
         // hosts with no Secret Service daemon running) without touching any
         // real credential.
-        await store.hasKey();
+        await store.hasSecret();
         return store;
     }
     catch {
-        return new EncryptedFileStore(fallbackFilePath, kek);
+        return new EncryptedFileSecretStore(fallbackFilePath, kek);
+    }
+}
+/** EVM (secp256k1) key store — the original `KeyStore`, now a thin
+ *  curve-specific wrapper over the generic `SecretStore` above rather
+ *  than owning its own storage logic. */
+class EvmKeyStore {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    hasKey() {
+        return this.store.hasSecret();
+    }
+    async generateAndStore() {
+        const privateKey = generatePrivateKey();
+        await this.store.store(privateKey);
+        return deriveEvmAddress(privateKey);
+    }
+    withPrivateKey(fn) {
+        return this.store.withSecret((secret) => fn(secret));
+    }
+    address() {
+        return this.withPrivateKey((pk) => deriveEvmAddress(pk));
+    }
+}
+/** Solana (Ed25519) key store — same storage backends as `EvmKeyStore`,
+ *  a completely separate secret (never derived from or related to the
+ *  EVM key), stored under its own account/file so the two can be
+ *  generated, rotated, or lost independently. The secret key is
+ *  persisted base64-encoded (`Keypair.secretKey` is a raw 64-byte
+ *  buffer, not directly JSON/string-safe). */
+class Ed25519SolanaKeyStore {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    hasKey() {
+        return this.store.hasSecret();
+    }
+    async generateAndStore() {
+        const keypair = Keypair.generate();
+        await this.store.store(Buffer.from(keypair.secretKey).toString("base64"));
+        return keypair.publicKey.toBase58();
+    }
+    withSecretKey(fn) {
+        return this.store.withSecret((secret) => fn(Buffer.from(secret, "base64")));
+    }
+    address() {
+        return this.withSecretKey((sk) => Keypair.fromSecretKey(sk).publicKey.toBase58());
     }
 }
+export async function defaultKeyStore(agentId, fallbackFilePath, kek) {
+    return new EvmKeyStore(await defaultSecretStore(agentId, fallbackFilePath, kek));
+}
+/** Same defaulting behavior as `defaultKeyStore`, for the Solana key —
+ *  `fallbackFilePath` must be a different path than the EVM store's
+ *  (e.g. `solana-key.enc.json` next to `key.enc.json`), and the OS
+ *  keychain account is automatically suffixed so the two never collide
+ *  under the same service/account pair. */
+export async function defaultSolanaKeyStore(agentId, fallbackFilePath, kek) {
+    return new Ed25519SolanaKeyStore(await defaultSecretStore(`${agentId}:solana`, fallbackFilePath, kek));
+}

package/dist/policy.d.ts

@@ -19,7 +19,7 @@ export interface SigningRequest {
      *  operations that don't move value (identity registration, the
      *  EIP-7702 delegation itself). */
     amount: number | null;
-    counterparty: Address | null;
+    counterparty: string | null;
     /** Contract + 4-byte selector, for a MandateEnforcer.execute()-shaped
      *  call — checked against an allowlist if one is configured (see
      *  PolicyEngine's constructor). Mandate.spending/counterpartyRequirements

package/dist/signer.d.ts

@@ -1,5 +1,5 @@
 import { type Address, type Hex } from "viem";
-import type { KeyStore } from "./keystore.js";
+import type { KeyStore, SolanaKeyStore } from "./keystore.js";
 import type { PolicyEngine } from "./policy.js";
 import { AuditLog } from "./audit-log.js";
 interface RateLimiter {
@@ -22,11 +22,14 @@ export interface SignerOptions {
     policyEngine: PolicyEngine;
     auditLog: AuditLog;
     rateLimiter?: RateLimiter;
+    solanaKeyStore?: SolanaKeyStore;
 }
 export declare class Signer {
     private readonly options;
     constructor(options: SignerOptions);
     address(): Promise<Address>;
+    private requireSolanaKeyStore;
+    solanaAddress(): Promise<string>;
     private logAndEnforce;
     /** One-time: signs the register() call that mints this agent's
      *  ERC-8004 identity, owned by this signer's own address. Takes an
@@ -36,7 +39,22 @@ export declare class Signer {
      *  already exists in erc8004-client.ts's server-side counterpart) and
      *  to keep this signer's own network surface at zero: it never makes
      *  an RPC call, only signs exactly what it's handed. `agentURI` is
-     *  accepted for the audit log entry, not used to build the call. */
+     *  accepted for the audit log entry, not used to build the call.
+     *
+     *  Signs via `account.signTransaction()` directly, not a WalletClient —
+     *  a real bug, found live: `createWalletClient(...).signTransaction()`
+     *  silently calls its transport for `eth_chainId` (and, once that's
+     *  reachable, fee-market data) whenever the tx is missing a `type` or
+     *  fee fields, which the offline placeholder above can never answer —
+     *  contradicting this method's own "never makes an RPC call" claim.
+     *  `viem/accounts`' local account type has no such dependency; the
+     *  trade-off is that a caller-omitted fee/gas field now needs an
+     *  explicit local default (below) instead of network-derived current
+     *  values — correct for keeping this signer's network surface at
+     *  zero, but the caller (erc8004-client.ts) supplying real values,
+     *  which it already has the RPC access to compute, remains the better
+     *  long-term fix; these defaults are a safe fallback, not a reason not
+     *  to. */
     signRegisterIdentity(params: {
         agentURI: string;
         unsignedTx: {
@@ -44,6 +62,7 @@ export declare class Signer {
             nonce: number;
             data: Hex;
             gas?: bigint;
+            gasPrice?: bigint;
         };
         chainId: number;
     }): Promise<{
@@ -103,7 +122,22 @@ export declare class Signer {
     }>;
     /** Owner-initiated funds-out — same policy checks apply (a withdrawal
      *  is still constrained by the Mandate's spend limits and, if
-     *  configured, allowed-counterparty list). */
+     *  configured, allowed-counterparty list).
+     *
+     *  Checked against the actual caller before fixing, not assumed: as of
+     *  this writing, gora8's own server never sends this operation —
+     *  services/payment/onchain.ts's withdrawEvm() routes a withdrawal
+     *  through executeViaMandate() (signMandateExecute, unaffected by this
+     *  bug) instead, since a withdrawal is exactly the kind of spend
+     *  Authority already has to constrain. This method is nonetheless real
+     *  public API surface (agent-ts's sign-handler.ts routes to it) a
+     *  third-party integration could call directly, so it gets the same
+     *  fix as signRegisterIdentity above rather than being left broken
+     *  because gora8's own server happens not to exercise it. Adds a
+     *  required `nonce` (this method cannot produce a valid signed
+     *  transaction without one, whichever caller eventually supplies it)
+     *  and optional gas/fee fields, same shape and defaulting as
+     *  signRegisterIdentity. */
     signWithdrawal(params: {
         to: Address;
         amount: number;
@@ -111,10 +145,36 @@ export declare class Signer {
             to: Address;
             value: bigint;
             data: Hex;
+            nonce: number;
+            gas?: bigint;
+            gasPrice?: bigint;
         };
         chainId: number;
     }): Promise<{
         signedTransaction: Hex;
     }>;
+    /** Signs this agent's own required-signer slot in a pre-built Solana
+     *  transaction — the same "server builds it, signer only authorizes"
+     *  division as the EVM Mandate-execute path (signMandateExecute
+     *  above). The caller (gora8's server) already set the transaction's
+     *  recent blockhash and fee payer (gora8's own fee-payer wallet, a
+     *  separate signer this package never touches) before serializing it
+     *  with `requireAllSignatures: false` — so signing here needs no RPC
+     *  call either, the same zero-network-surface property every other
+     *  method in this file holds to (unlike the EVM signTransaction bug
+     *  fixed elsewhere in this file, Solana's `Transaction.partialSign()`
+     *  has no such hidden network dependency — verified by construction:
+     *  it operates purely on the already-deserialized message). Returns
+     *  only this signer's own signature, base64-encoded; the caller
+     *  merges it into the full transaction and adds the fee payer's
+     *  signature before broadcasting — this package still never
+     *  broadcasts anything, same discipline as the EVM side. */
+    signSolanaTransaction(params: {
+        serializedTransaction: string;
+        amount: number | null;
+        counterparty: string | null;
+    }): Promise<{
+        signature: string;
+    }>;
 }
 export {};

package/dist/signer.js

@@ -1,4 +1,5 @@
 import { createWalletClient, http, defineChain } from "viem";
+import { Transaction, Keypair } from "@solana/web3.js";
 /** Simple sliding-window limiter — no external dependency needed for
  *  something this small. */
 export class SlidingWindowRateLimiter {
@@ -26,6 +27,17 @@ export class SlidingWindowRateLimiter {
 // access is needed or granted here; broadcasting is gora8's relay
 // wallet's job, not this signer's — see this file's own doc comment.
 const OFFLINE_PLACEHOLDER_RPC_URL = "http://127.0.0.1:0";
+// Safe, deliberately generous offline defaults for a legacy-type
+// transaction whose caller didn't supply gas/fee fields — a real
+// per-chain current price would be lower on every chain this signer
+// targets today (all low-fee L2s), so overpaying trivially here is the
+// safe failure direction; underpricing (or a gas limit too low for a
+// contract call to complete) is the unsafe one. Deliberately not
+// fetched from a real RPC, per this file's zero-network-surface design —
+// see signRegisterIdentity's doc comment for why a caller-supplied real
+// value should be preferred once available.
+const DEFAULT_GAS_PRICE = 1000000000n; // 1 gwei
+const DEFAULT_GAS_LIMIT = 300000n; // generous for a simple contract call (e.g. ERC-8004 register())
 function genericChain(chainId) {
     return defineChain({
         id: chainId,
@@ -42,6 +54,15 @@ export class Signer {
     async address() {
         return this.options.keyStore.address();
     }
+    requireSolanaKeyStore() {
+        if (!this.options.solanaKeyStore) {
+            throw new Error("No Solana key configured for this signer — run `gora8-signer init <agent-id>` with Solana support, or pass solanaKeyStore explicitly.");
+        }
+        return this.options.solanaKeyStore;
+    }
+    async solanaAddress() {
+        return this.requireSolanaKeyStore().address();
+    }
     async logAndEnforce(operation, request) {
         this.options.rateLimiter?.checkAndRecord();
         const decision = await this.options.policyEngine.evaluate(request);
@@ -66,20 +87,35 @@ export class Signer {
      *  already exists in erc8004-client.ts's server-side counterpart) and
      *  to keep this signer's own network surface at zero: it never makes
      *  an RPC call, only signs exactly what it's handed. `agentURI` is
-     *  accepted for the audit log entry, not used to build the call. */
+     *  accepted for the audit log entry, not used to build the call.
+     *
+     *  Signs via `account.signTransaction()` directly, not a WalletClient —
+     *  a real bug, found live: `createWalletClient(...).signTransaction()`
+     *  silently calls its transport for `eth_chainId` (and, once that's
+     *  reachable, fee-market data) whenever the tx is missing a `type` or
+     *  fee fields, which the offline placeholder above can never answer —
+     *  contradicting this method's own "never makes an RPC call" claim.
+     *  `viem/accounts`' local account type has no such dependency; the
+     *  trade-off is that a caller-omitted fee/gas field now needs an
+     *  explicit local default (below) instead of network-derived current
+     *  values — correct for keeping this signer's network surface at
+     *  zero, but the caller (erc8004-client.ts) supplying real values,
+     *  which it already has the RPC access to compute, remains the better
+     *  long-term fix; these defaults are a safe fallback, not a reason not
+     *  to. */
     async signRegisterIdentity(params) {
         await this.logAndEnforce("signRegisterIdentity", { amount: null, counterparty: null, contract: null, selector: null });
         return this.options.keyStore.withPrivateKey(async (privateKey) => {
             const { privateKeyToAccount } = await import("viem/accounts");
             const account = privateKeyToAccount(privateKey);
-            const walletClient = createWalletClient({ account, chain: genericChain(params.chainId), transport: http(OFFLINE_PLACEHOLDER_RPC_URL) });
-            const signedTransaction = await walletClient.signTransaction({
-                account,
-                chain: genericChain(params.chainId),
+            const signedTransaction = await account.signTransaction({
+                type: "legacy",
+                chainId: params.chainId,
                 to: params.unsignedTx.to,
                 nonce: params.unsignedTx.nonce,
                 data: params.unsignedTx.data,
-                gas: params.unsignedTx.gas,
+                gas: params.unsignedTx.gas ?? DEFAULT_GAS_LIMIT,
+                gasPrice: params.unsignedTx.gasPrice ?? DEFAULT_GAS_PRICE,
             });
             return { signedTransaction };
         });
@@ -152,21 +188,68 @@ export class Signer {
     }
     /** Owner-initiated funds-out — same policy checks apply (a withdrawal
      *  is still constrained by the Mandate's spend limits and, if
-     *  configured, allowed-counterparty list). */
+     *  configured, allowed-counterparty list).
+     *
+     *  Checked against the actual caller before fixing, not assumed: as of
+     *  this writing, gora8's own server never sends this operation —
+     *  services/payment/onchain.ts's withdrawEvm() routes a withdrawal
+     *  through executeViaMandate() (signMandateExecute, unaffected by this
+     *  bug) instead, since a withdrawal is exactly the kind of spend
+     *  Authority already has to constrain. This method is nonetheless real
+     *  public API surface (agent-ts's sign-handler.ts routes to it) a
+     *  third-party integration could call directly, so it gets the same
+     *  fix as signRegisterIdentity above rather than being left broken
+     *  because gora8's own server happens not to exercise it. Adds a
+     *  required `nonce` (this method cannot produce a valid signed
+     *  transaction without one, whichever caller eventually supplies it)
+     *  and optional gas/fee fields, same shape and defaulting as
+     *  signRegisterIdentity. */
     async signWithdrawal(params) {
         await this.logAndEnforce("signWithdrawal", { amount: params.amount, counterparty: params.to, contract: null, selector: null });
         return this.options.keyStore.withPrivateKey(async (privateKey) => {
             const { privateKeyToAccount } = await import("viem/accounts");
             const account = privateKeyToAccount(privateKey);
-            const walletClient = createWalletClient({ account, chain: genericChain(params.chainId), transport: http(OFFLINE_PLACEHOLDER_RPC_URL) });
-            const signedTransaction = await walletClient.signTransaction({
-                account,
+            const signedTransaction = await account.signTransaction({
+                type: "legacy",
+                chainId: params.chainId,
                 to: params.unsignedTx.to,
                 value: params.unsignedTx.value,
                 data: params.unsignedTx.data,
-                chain: genericChain(params.chainId),
+                nonce: params.unsignedTx.nonce,
+                gas: params.unsignedTx.gas ?? DEFAULT_GAS_LIMIT,
+                gasPrice: params.unsignedTx.gasPrice ?? DEFAULT_GAS_PRICE,
             });
             return { signedTransaction };
         });
     }
+    /** Signs this agent's own required-signer slot in a pre-built Solana
+     *  transaction — the same "server builds it, signer only authorizes"
+     *  division as the EVM Mandate-execute path (signMandateExecute
+     *  above). The caller (gora8's server) already set the transaction's
+     *  recent blockhash and fee payer (gora8's own fee-payer wallet, a
+     *  separate signer this package never touches) before serializing it
+     *  with `requireAllSignatures: false` — so signing here needs no RPC
+     *  call either, the same zero-network-surface property every other
+     *  method in this file holds to (unlike the EVM signTransaction bug
+     *  fixed elsewhere in this file, Solana's `Transaction.partialSign()`
+     *  has no such hidden network dependency — verified by construction:
+     *  it operates purely on the already-deserialized message). Returns
+     *  only this signer's own signature, base64-encoded; the caller
+     *  merges it into the full transaction and adds the fee payer's
+     *  signature before broadcasting — this package still never
+     *  broadcasts anything, same discipline as the EVM side. */
+    async signSolanaTransaction(params) {
+        await this.logAndEnforce("signSolanaTransaction", { amount: params.amount, counterparty: params.counterparty, contract: null, selector: null });
+        const solanaKeyStore = this.requireSolanaKeyStore();
+        return solanaKeyStore.withSecretKey(async (secretKey) => {
+            const keypair = Keypair.fromSecretKey(secretKey);
+            const transaction = Transaction.from(Buffer.from(params.serializedTransaction, "base64"));
+            transaction.partialSign(keypair);
+            const entry = transaction.signatures.find((s) => s.publicKey.equals(keypair.publicKey));
+            if (!entry?.signature) {
+                throw new Error("Signing produced no signature for this agent's Solana public key — the transaction doesn't name it as a required signer.");
+            }
+            return { signature: Buffer.from(entry.signature).toString("base64") };
+        });
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gora8-signer",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Local, self-custodied key signing for gora8 agents — the key is generated and used wherever your agent runs, never inside gora8's own infrastructure. See SELF_CUSTODY_ARCHITECTURE.md in the gora8 monorepo for the full design.",
   "license": "MIT",
   "type": "module",
@@ -15,7 +15,11 @@
   "bin": {
     "gora8-signer": "./dist/cli.js"
   },
-  "files": ["dist", "README.md", "LICENSE"],
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
     "build": "tsc",
     "prepublishOnly": "npm run build"
@@ -24,11 +28,12 @@
     "node": ">=18"
   },
   "devDependencies": {
-    "typescript": "^5.6.0",
-    "@types/node": "^20.0.0"
+    "@types/node": "^20.0.0",
+    "typescript": "^5.6.0"
   },
   "dependencies": {
-    "viem": "^2.21.0",
-    "@napi-rs/keyring": "^1.3.0"
+    "@napi-rs/keyring": "^1.3.0",
+    "@solana/web3.js": "^1.98.4",
+    "viem": "^2.21.0"
   }
 }