@bounded-sh/server 0.0.67 → 0.0.69

package/README.md

@@ -1,6 +1,6 @@
 # @bounded-sh/server
 
-Server SDK for the Bounded API. It provides explicit, isolated Solana-keypair or EVM-private-key clients for backend applications; no signer is loaded from ambient process state.
+Server SDK for the Bounded API. It provides explicit, isolated Solana-keypair clients for backend applications; no signer is loaded from ambient process state.
 
 ## Installation
 
@@ -16,7 +16,7 @@ yarn add @bounded-sh/server
 
 ## Features
 
-- Server-side authentication using Solana keypairs or EVM private keys (SIWS/SIWE)
+- Server-side authentication using Solana keypairs (SIWS)
 - In-memory session management (no cookies or local storage required)
 - Support for all Tarobase data operations (get, getMany, set, query)
 - Real-time subscriptions
@@ -86,27 +86,6 @@ const signature = await wallet.signMessage("Hello, world!");
 // const signature = await wallet.signAndSubmitTransaction(transaction);
 ```
 
-### EVM Keypair Client
-
-EVM clients require a trusted RPC and deployed `BoundedRuntime` address. A write response can select only an explicitly configured chain/runtime pair, and the SDK verifies the returned `setDocuments` calldata against the requested app, paths, actions, and values before signing.
-
-```typescript
-import { init, createWalletClient } from '@bounded-sh/server';
-
-await init({ appId: 'your-app-id', chain: 'base' });
-
-const wallet = await createWalletClient({
-  evmPrivateKey: process.env.EVM_PRIVATE_KEY!,
-  chainId: 8453,
-  rpcUrl: process.env.BASE_RPC_URL!,
-  runtimeAddress: process.env.BOUNDED_RUNTIME_BASE!,
-});
-
-await wallet.set('todos/123', { text: 'Buy milk', completed: false });
-```
-
-For deliberate multi-chain use, provide `chains: { [chainId]: { rpcUrl, runtimeAddress } }`. There is no implicit RPC, runtime address, or chain switch.
-
 ### Subscriptions
 
 ```typescript
@@ -138,16 +117,7 @@ function getWebhookKeysUrl(): string | undefined;
 ### Authentication
 
 ```typescript
-function createWalletClient(options:
-  | { keypair: string }
-  | {
-      evmPrivateKey: string;
-      chainId: number;
-      rpcUrl?: string;
-      runtimeAddress?: string;
-      chains?: Record<string, { rpcUrl: string; runtimeAddress: string; name?: string }>;
-    }
-): Promise<WalletClient>;
+function createWalletClient(options: { keypair: string }): Promise<WalletClient>;
 function getAuthProvider(): Promise<AuthProvider>; // always rejects; no process-global provider
 function getIdToken(): Promise<string | null>; // always rejects; no process-global session
 ```
@@ -182,15 +152,13 @@ class SolanaKeypairProvider implements AuthProvider {
   login(): Promise<User | null>;
   logout(): Promise<void>;
   signMessage(message: string): Promise<string>;
-  runTransaction(evmTransactionData?: EVMTransaction, solTransactionData?: SolTransaction, options?: SetOptions): Promise<TransactionResult>;
   restoreSession(): Promise<User | null>;
   getNativeMethods(): Promise<any>;
 }
 ```
 
-`runTransaction` requires an explicit provider `rpcUrl` plus `solTransactionData.network`
-set to `solana_devnet` or `solana_mainnet`; missing RPCs and unknown/missing
-networks fail closed.
+`signAndSubmitTransaction` requires an explicit provider `rpcUrl`; a missing RPC
+fails closed.
 
 ## Types
 
@@ -242,7 +210,7 @@ Please see the main repository for contribution guidelines.
 
 This server-side SDK differs from the web SDK in several important ways:
 
-1. **Authentication Method**: Uses explicit Solana or EVM keys instead of browser wallets
+1. **Authentication Method**: Uses explicit Solana keys instead of browser wallets
 2. **Storage Strategy**: Uses in-memory storage instead of localStorage/sessionStorage 
 3. **Environment**: Optimized for Node.js/backend environments rather than browsers
 4. **Session Management**: Does not rely on browser-specific APIs

package/dist/auth/providers/offchain-auth-provider.d.ts

@@ -18,5 +18,4 @@ export declare class OffchainAuthProvider implements AuthProvider {
      * for the full implementation with blockhash handling and feePayer support.
      */
     signAndSubmitTransaction(_transaction: Transaction | VersionedTransaction, _feePayer?: any): Promise<string>;
-    runTransaction(evmTransactionData?: any, solTransactionData?: any, options?: any): Promise<any>;
 }

package/dist/auth/providers/solana-keypair-provider.d.ts

@@ -1,6 +1,6 @@
 import { Keypair, Transaction, VersionedTransaction } from '@solana/web3.js';
 import * as anchor from '@coral-xyz/anchor';
-import type { AuthProvider, EVMTransaction, SolTransaction, TransactionResult, User, SetOptions } from '@bounded-sh/core';
+import type { AuthProvider, User } from '@bounded-sh/core';
 export declare class SolanaKeypairProvider implements AuthProvider {
     private readonly rpcUrl;
     private readonly serverKeypair;
@@ -32,7 +32,6 @@ export declare class SolanaKeypairProvider implements AuthProvider {
      */
     private submitAndConfirmTransaction;
     private getRpcUrl;
-    runTransaction(_evmTransactionData?: EVMTransaction, _solTransactionData?: SolTransaction, _options?: SetOptions): Promise<TransactionResult>;
     getNativeMethods(): Promise<{
         keypair: Keypair;
     }>;

package/dist/index.d.ts

@@ -5,12 +5,10 @@ export type { BoundedDecline, DeclineReason, DeclineBoundary } from '@bounded-sh
 export { getAuthProvider } from './auth';
 export { get, getMany, set, setMany, setFile, getFiles, search, queryAggregate, runQuery, runQueryMany, runExpression, runExpressionMany, signMessage, signTransaction, signAndSubmitTransaction, count, aggregate, subscribe, functions, invokeFunction, live, liveIntent, liveStatus, } from './explicit-client-only';
 export { reconcileSetResult, waitForSetResult } from '@bounded-sh/core';
-export type { SetResult, SetEntry, SetDocuments, MirrorSync, SolanaFence, EvmFence, ChainTag, SolanaChainTag, EvmChainTag, CommittedSetResult, ConfirmedSetResult, SolanaConfirmedSetResult, EvmConfirmedSetResult, SubmittedSetResult, SolanaSubmittedSetResult, EvmFencedSubmittedSetResult, EvmHashKnownSubmittedSetResult, EvmIrreconcilableSubmittedSetResult, SolanaExpiredNotLandedSetResult, SolanaSignedSetResult, TransactionResult, TransactionReconciliation, EvmReconcileRequest, ReconcileSetResultOptions, WaitForSetResultOptions, FileUploadResult, FileDeleteResult, } from '@bounded-sh/core';
+export type { SetResult, SetEntry, SetDocuments, MirrorSync, SolanaFence, ChainTag, SolanaChainTag, CommittedSetResult, ConfirmedSetResult, SolanaConfirmedSetResult, SubmittedSetResult, SolanaSubmittedSetResult, SolanaExpiredNotLandedSetResult, SolanaSignedSetResult, TransactionResult, TransactionReconciliation, ReconcileSetResultOptions, WaitForSetResultOptions, FileUploadResult, FileDeleteResult, } from '@bounded-sh/core';
 export type { AuthProvider, ClientConfig, User, GetOptions, SearchOptions, SetOptions, CountOptions, AggregateOptions, AggregateOperation, AggregateResult, AggregateSpec, AggregateRow, QueryAggregateOptions, GetManyResult, RunExpressionOptions, RunExpressionResult, RequestOverrides, RunQueryOptions, InvokeOptions, LiveIntentOptions, LiveStatus, LiveStatusOptions, } from '@bounded-sh/core';
 export { getIdToken } from './utils';
 export { createWalletClient, WalletClient } from './wallet-client';
 export type { CreateWalletClientOptions } from './wallet-client';
-export { EvmKeypairProvider } from './auth/providers/evm-keypair-provider';
-export type { EvmKeypairChainConfig } from './auth/providers/evm-keypair-provider';
 export { verifyWebhook, clearWebhookKeyCache, clearWebhookReplayCache, WebhookVerificationError, DEFAULT_WEBHOOK_KEYS_URL, InMemoryReplayStore, } from './webhooks';
 export type { WebhookPayload, WebhookPublicKey, WebhookOperation, VerifyWebhookOptions, WebhookHeaders, WebhookReplayStore, } from './webhooks';

package/dist/index.js

@@ -5,8 +5,6 @@ var web3_js = require('@solana/web3.js');
 var bs58 = require('bs58');
 var buffer = require('buffer');
 var nacl = require('tweetnacl');
-var viem = require('viem');
-var accounts = require('viem/accounts');
 
 async function init(newConfig) {
     await core.init(Object.assign(Object.assign({}, newConfig), { authProvider: null, isServer: true, skipBackendInit: true }));
@@ -53,6 +51,20 @@ async function getIdToken() {
     throw new Error('getIdToken is not available as a tarobase-server top-level auth operation. Use createWalletClient({ keypair }) and call the returned client methods.');
 }
 
+/**
+ * DS3-0414: does the transaction already carry a REAL signer signature? A Solana
+ * signature is computed over the compiled message, which INCLUDES recentBlockhash, so
+ * the blockhash must not be rewritten once any signer (sponsor / multisig / co-signer)
+ * has signed - a rewrite silently invalidates their signature. Legacy signatures are
+ * `{ signature: Buffer | null }` entries; versioned signatures are 64-byte arrays that
+ * stay all-zero placeholders until a signer fills them. Mirrors turnkey-signer-bridge.ts.
+ */
+function transactionHasSignature(transaction) {
+    if ('serializeMessage' in transaction) {
+        return transaction.signatures.some((s) => s.signature != null);
+    }
+    return transaction.signatures.some((sig) => sig.some((b) => b !== 0));
+}
 class SolanaKeypairProvider {
     constructor(rpcUrl, serverKeypair) {
         this.rpcUrl = rpcUrl;
@@ -109,25 +121,34 @@ class SolanaKeypairProvider {
         // 1. Get RPC URL and create connection
         const rpcUrl = this.getRpcUrl();
         const connection = new web3_js.Connection(rpcUrl, 'confirmed');
-        // 2. Get fresh blockhash and set it on the transaction before signing
-        const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
-        // Use duck typing instead of instanceof to handle multiple @solana/web3.js versions
-        const isLegacyTransaction = 'recentBlockhash' in transaction && !('message' in transaction && 'staticAccountKeys' in transaction.message);
-        if (isLegacyTransaction) {
-            const legacyTx = transaction;
-            legacyTx.recentBlockhash = blockhash;
-            legacyTx.lastValidBlockHeight = lastValidBlockHeight;
-            // Set feePayer if not already set
-            if (!legacyTx.feePayer) {
-                legacyTx.feePayer = feePayer !== null && feePayer !== void 0 ? feePayer : this.keypair.publicKey;
+        // 2. Get fresh blockhash and set it on the transaction before signing.
+        // DS3-0414: a Solana signature covers the compiled message (recentBlockhash included),
+        // so refreshing the blockhash after a sponsor / co-signer has already signed silently
+        // invalidates their signature - and this is the sponsored/fee-payer submit path, where a
+        // co-signed transaction is exactly what arrives. signTransaction only ADDS this keypair's
+        // signature (partialSign), it never re-signs the others. So only refresh the blockhash
+        // while the transaction is still unsigned; once a real signature is present, sign and
+        // submit the caller's message verbatim.
+        if (!transactionHasSignature(transaction)) {
+            const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
+            // Use duck typing instead of instanceof to handle multiple @solana/web3.js versions
+            const isLegacyTransaction = 'recentBlockhash' in transaction && !('message' in transaction && 'staticAccountKeys' in transaction.message);
+            if (isLegacyTransaction) {
+                const legacyTx = transaction;
+                legacyTx.recentBlockhash = blockhash;
+                legacyTx.lastValidBlockHeight = lastValidBlockHeight;
+                // Set feePayer if not already set
+                if (!legacyTx.feePayer) {
+                    legacyTx.feePayer = feePayer !== null && feePayer !== void 0 ? feePayer : this.keypair.publicKey;
+                }
+            }
+            else {
+                // VersionedTransaction
+                const versionedTx = transaction;
+                versionedTx.message.recentBlockhash = blockhash;
+                // Note: VersionedTransaction feePayer is set in the message at creation time
+                // and cannot be modified after creation
             }
-        }
-        else {
-            // VersionedTransaction
-            const versionedTx = transaction;
-            versionedTx.message.recentBlockhash = blockhash;
-            // Note: VersionedTransaction feePayer is set in the message at creation time
-            // and cannot be modified after creation
         }
         // 3. Sign the transaction
         const signedTx = await this.signTransaction(transaction);
@@ -189,16 +210,6 @@ class SolanaKeypairProvider {
         }
         throw new Error('Solana RPC URL is required for server keypair transaction submission; pass an explicit rpcUrl when creating SolanaKeypairProvider.');
     }
-    /* ----------------------------------------------------------- *
-     * Transaction runner
-     * ----------------------------------------------------------- */
-    async runTransaction(_evmTransactionData, _solTransactionData, _options) {
-        // Client-side Solana transaction building is retired: the realtime worker
-        // returns a fully-built (and, when sponsored, partially-signed) transaction
-        // on its 202, which the SDK validates and signs via signTransaction /
-        // signAndSubmitTransaction. This provider serves no EVM payload either.
-        throw new Error('runTransaction is not supported by this provider; Bounded returns pre-built Solana transactions that are signed with signTransaction/signAndSubmitTransaction.');
-    }
     async getNativeMethods() {
         return { keypair: this.keypair };
     }
@@ -237,312 +248,6 @@ class OffchainAuthProvider {
     async signAndSubmitTransaction(_transaction, _feePayer) {
         throw new Error('Poofnet does not support real Solana transactions. Deploy your project to mainnet to use this feature.');
     }
-    async runTransaction(evmTransactionData, solTransactionData, options) {
-        return this.wrappedProvider.runTransaction(evmTransactionData, solTransactionData, options);
-    }
-}
-
-function evmErrorText(error) {
-    const message = error === null || error === void 0 ? void 0 : error.message;
-    return typeof message === 'string' && message.length > 0 ? message : String(error);
-}
-/**
- * Whether a broadcast failure PROVES the transaction never entered the network.
- * A node-level validation rejection is definitive and keeps throwing; a
- * transport failure (timeout, socket reset, aborted request) is ambiguous — the
- * node may hold the bytes — and must resolve as `submitted`.
- *
- * "already known"/"already imported" is deliberately NOT definitive: it means
- * the node already has these exact bytes, which is success, not failure.
- */
-const DEFINITIVE_EVM_SEND_MARKERS = [
-    'nonce too low',
-    'insufficient funds',
-    'intrinsic gas too low',
-    'gas required exceeds',
-    'exceeds block gas limit',
-    'invalid sender',
-    'invalid signature',
-    'execution reverted',
-    'transaction underpriced',
-    'oversized data',
-];
-function isDefinitiveEvmSendFailure(error) {
-    var _a, _b;
-    const message = String((_b = (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : error) !== null && _b !== void 0 ? _b : '').toLowerCase();
-    if (!message)
-        return false;
-    if (message.includes('already known') || message.includes('already imported'))
-        return false;
-    return DEFINITIVE_EVM_SEND_MARKERS.some(marker => message.includes(marker));
-}
-/** viem raises a dedicated not-found error when a receipt simply is not mined yet. */
-function isReceiptNotFound(error) {
-    var _a, _b;
-    const name = String((_a = error === null || error === void 0 ? void 0 : error.name) !== null && _a !== void 0 ? _a : '');
-    if (name === 'TransactionReceiptNotFoundError')
-        return true;
-    return String((_b = error === null || error === void 0 ? void 0 : error.message) !== null && _b !== void 0 ? _b : '').toLowerCase().includes('could not be found');
-}
-const NO_SOLANA = 'An EVM keypair client cannot sign Solana transactions.';
-function normalizeChainConfig(input) {
-    var _a;
-    if (!Number.isSafeInteger(input.chainId) || input.chainId <= 0)
-        throw new Error('EVM chainId must be a positive safe integer');
-    let rpc;
-    try {
-        rpc = new URL(input.rpcUrl);
-    }
-    catch (_b) {
-        throw new Error(`EVM RPC URL is invalid for chain ${input.chainId}`);
-    }
-    if (rpc.protocol !== 'https:' && !(rpc.protocol === 'http:' && (rpc.hostname === 'localhost' || rpc.hostname === '127.0.0.1' || rpc.hostname === '[::1]'))) {
-        throw new Error(`EVM RPC URL must use HTTPS for chain ${input.chainId}`);
-    }
-    const runtimeAddress = core.normalizeEvmAddress(input.runtimeAddress);
-    if (!runtimeAddress)
-        throw new Error(`BoundedRuntime address is invalid for chain ${input.chainId}`);
-    return { chainId: input.chainId, rpcUrl: rpc.toString(), runtimeAddress, name: ((_a = input.name) === null || _a === void 0 ? void 0 : _a.trim()) || `EVM ${input.chainId}` };
-}
-function asViemChain(config) {
-    return viem.defineChain({
-        id: config.chainId,
-        name: config.name,
-        nativeCurrency: { name: 'Native token', symbol: 'NATIVE', decimals: 18 },
-        rpcUrls: { default: { http: [config.rpcUrl] } },
-    });
-}
-class EvmKeypairProvider {
-    constructor(privateKey, defaultChainId, chainConfigs) {
-        this.chains = new Map();
-        if (!/^0x[0-9a-fA-F]{64}$/.test(privateKey))
-            throw new Error('Invalid EVM private key: expected 0x followed by 64 hex characters.');
-        this.account = accounts.privateKeyToAccount(privateKey);
-        const address = core.normalizeEvmAddress(this.account.address);
-        if (!address)
-            throw new Error('Could not derive a valid EVM address from the private key');
-        this.address = address;
-        for (const raw of chainConfigs) {
-            const chain = normalizeChainConfig(raw);
-            if (this.chains.has(chain.chainId))
-                throw new Error(`Duplicate EVM chain configuration: ${chain.chainId}`);
-            this.chains.set(chain.chainId, chain);
-        }
-        if (!this.chains.has(defaultChainId))
-            throw new Error(`Default EVM chain ${defaultChainId} is not configured`);
-        this.defaultChainId = defaultChainId;
-    }
-    user() {
-        return { id: this.address, address: null, evmAddress: this.address, provider: this };
-    }
-    async createBoundedSession(sessionConfig) {
-        var _a, _b, _c, _d;
-        // Bind the SIWE nonce/message/session to the snapshotted app+issuer when a
-        // wallet client supplies one, so a later global init() cannot retarget this
-        // session mint (CTA-05); otherwise read the mutable global init() config.
-        const nonce = await core.genAuthNonce(sessionConfig);
-        const appId = (_a = sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.appId) !== null && _a !== void 0 ? _a : (await core.getConfig()).appId;
-        const message = core.genSiweMessage(this.address, nonce, appId, 'server', 'https://server/login', { chainId: this.defaultChainId });
-        const signature = await this.account.signMessage({ message });
-        const session = await core.createSessionWithSignature(this.address, message, signature, 'siwe', sessionConfig);
-        return {
-            address: this.address,
-            accessToken: String((_b = session.accessToken) !== null && _b !== void 0 ? _b : ''),
-            idToken: String((_c = session.idToken) !== null && _c !== void 0 ? _c : ''),
-            refreshToken: String((_d = session.refreshToken) !== null && _d !== void 0 ? _d : ''),
-        };
-    }
-    async login() { return this.user(); }
-    async restoreSession() { return this.user(); }
-    async logout() { }
-    async signMessage(message) {
-        return this.account.signMessage({ message });
-    }
-    async signTransaction(_transaction) {
-        throw new Error(NO_SOLANA);
-    }
-    async signAndSubmitTransaction(_transaction, _feePayer) {
-        throw new Error(NO_SOLANA);
-    }
-    async runTransaction(evm, sol, options) {
-        var _a;
-        if (evm && sol)
-            throw new Error('A transaction cannot target EVM and Solana at the same time.');
-        if (!evm || !evm.chainId || !evm.to || !evm.data)
-            throw new Error('A complete EVM transaction is required');
-        if ((options === null || options === void 0 ? void 0 : options.shouldSubmitTx) === false)
-            throw new Error('EVM keypair writes submit atomically; shouldSubmitTx:false is unsupported.');
-        const config = this.chains.get(evm.chainId);
-        if (!config)
-            throw new Error(`EVM chain ${evm.chainId} is not configured for this wallet client`);
-        if (core.normalizeEvmAddress(evm.to) !== config.runtimeAddress)
-            throw new Error('EVM transaction target is not the configured BoundedRuntime');
-        if (evm.nonce !== undefined)
-            throw new Error('Server-supplied EVM nonces are not accepted');
-        try {
-            if (BigInt((_a = evm.value) !== null && _a !== void 0 ? _a : '0') !== BigInt(0))
-                throw new Error('BoundedRuntime.setDocuments cannot transfer native value');
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.includes('cannot transfer'))
-                throw error;
-            throw new Error('Invalid EVM transaction value');
-        }
-        // The shared decoder accepts only canonical ordinary/attested document
-        // writes and rejects selector-prefix smuggling, aliases and trailing bytes.
-        core.assertCanonicalBoundedRuntimeWriteCalldata(evm.data);
-        // A server key can safely switch between explicitly configured chains: each
-        // tx selects its own immutable viem client/RPC/runtime tuple. No untrusted
-        // server response may introduce a new chain or RPC endpoint.
-        const chain = asViemChain(config);
-        const transport = viem.http(config.rpcUrl);
-        const wallet = viem.createWalletClient({ account: this.account, chain, transport });
-        const publicClient = viem.createPublicClient({ chain, transport });
-        // Unlike a browser wallet this provider OWNS the private key, so it prepares
-        // and signs locally with an EXPLICIT nonce and derives the hash before the
-        // transaction is ever broadcast. Learning the hash only from
-        // `sendTransaction()` discards an identifier we could have known, so an
-        // accepted-but-lost response would strand a landed write.
-        let request;
-        let signedTransaction;
-        let hash;
-        let nonce;
-        try {
-            request = await wallet.prepareTransactionRequest({
-                account: this.account,
-                chain,
-                to: config.runtimeAddress,
-                data: evm.data,
-                value: BigInt(0),
-            });
-            nonce = Number(request.nonce);
-            if (!Number.isSafeInteger(nonce) || nonce < 0)
-                throw new Error('the prepared transaction carries no usable nonce');
-            signedTransaction = await wallet.signTransaction(request);
-            hash = viem.keccak256(signedTransaction);
-        }
-        catch (error) {
-            // Preparation and local signing happen entirely before broadcast, so any
-            // failure here is definitive.
-            throw error;
-        }
-        const fence = {
-            chainId: config.chainId,
-            sender: this.address,
-            nonce,
-            signedTransaction,
-        };
-        try {
-            await publicClient.sendRawTransaction({ serializedTransaction: signedTransaction });
-        }
-        catch (error) {
-            if (isDefinitiveEvmSendFailure(error))
-                throw error;
-            // Ambiguous transport outcome: the node may already hold these exact
-            // bytes. Report the pre-derived hash and the fence so reconciliation can
-            // poll it, or rebroadcast the byte-identical bytes while the nonce is
-            // unused — which cannot produce a second execution.
-            return {
-                outcome: 'submitted',
-                lane: 'evm',
-                transactionSignature: hash,
-                fence,
-                reason: `Broadcast response was lost or inconclusive: ${evmErrorText(error)}`,
-            };
-        }
-        let receipt;
-        try {
-            receipt = await publicClient.waitForTransactionReceipt({ hash });
-        }
-        catch (error) {
-            // The bytes were accepted; only the confirmation outcome is unknown.
-            return {
-                outcome: 'submitted',
-                lane: 'evm',
-                transactionSignature: hash,
-                fence,
-                reason: `Confirmation outcome unknown: ${evmErrorText(error)}`,
-            };
-        }
-        if (receipt.status !== 'success')
-            throw new Error(`EVM transaction ${hash} reverted on-chain`);
-        if (receipt.blockNumber > BigInt(Number.MAX_SAFE_INTEGER))
-            throw new Error('EVM receipt block number exceeds the SDK safe-integer range');
-        return {
-            outcome: 'confirmed',
-            lane: 'evm',
-            transactionSignature: hash,
-            blockNumber: Number(receipt.blockNumber),
-            gasUsed: receipt.gasUsed.toString(),
-            data: receipt,
-        };
-    }
-    /**
-     * Poll the SAME hash, and — only while the fenced nonce is still unused — put
-     * the byte-identical signed transaction back on the wire. Same nonce, same
-     * signature, so a rebroadcast can never produce a second execution.
-     *
-     * It NEVER reports a retry-safe terminal state. Nonce advancement is not proof
-     * the write did not execute: a replacement can occupy the same sender and
-     * nonce carrying identical Bounded calldata under a different hash, and plain
-     * JSON-RPC offers no transaction-by-sender-and-nonce lookup to identify it.
-     */
-    async reconcileEvmTransaction(request) {
-        var _a, _b;
-        const chainId = (_b = (_a = request.fence) === null || _a === void 0 ? void 0 : _a.chainId) !== null && _b !== void 0 ? _b : this.defaultChainId;
-        const config = this.chains.get(chainId);
-        if (!config)
-            return { state: 'unknown', reason: `EVM chain ${chainId} is not configured for this wallet client` };
-        const chain = asViemChain(config);
-        const transport = viem.http(config.rpcUrl);
-        const publicClient = viem.createPublicClient({ chain, transport });
-        try {
-            const receipt = await publicClient.getTransactionReceipt({ hash: request.transactionHash });
-            if (receipt) {
-                if (receipt.status !== 'success') {
-                    return { state: 'failed', reason: `EVM transaction ${request.transactionHash} reverted on-chain` };
-                }
-                if (receipt.blockNumber > BigInt(Number.MAX_SAFE_INTEGER)) {
-                    return { state: 'unknown', reason: 'EVM receipt block number exceeds the SDK safe-integer range' };
-                }
-                return { state: 'confirmed', blockNumber: Number(receipt.blockNumber) };
-            }
-        }
-        catch (error) {
-            // viem throws `TransactionReceiptNotFoundError` when it is simply not
-            // mined yet; that is not an error condition, just "still unknown".
-            if (!isReceiptNotFound(error)) {
-                return { state: 'unknown', reason: `receipt lookup failed: ${evmErrorText(error)}` };
-            }
-        }
-        const fence = request.fence;
-        if (!request.allowRebroadcast || !fence) {
-            return { state: 'unknown', reason: 'no receipt yet for this transaction hash' };
-        }
-        try {
-            const nonceNow = await publicClient.getTransactionCount({ address: fence.sender, blockTag: 'latest' });
-            if (nonceNow > fence.nonce) {
-                // The nonce is spent. It may have been spent by THIS transaction under a
-                // different hash (a replacement), so this is emphatically not retry-safe.
-                return {
-                    state: 'unknown',
-                    reason: `nonce ${fence.nonce} on ${fence.sender} has been consumed but this hash has no receipt; ` +
-                        'the transaction may have been replaced, so the write is not proven absent',
-                };
-            }
-            await publicClient.sendRawTransaction({ serializedTransaction: fence.signedTransaction });
-            return { state: 'unknown', reason: 'rebroadcast the byte-identical fenced transaction; still awaiting a receipt' };
-        }
-        catch (error) {
-            return { state: 'unknown', reason: `rebroadcast attempt was inconclusive: ${evmErrorText(error)}` };
-        }
-    }
-    async getNativeMethods() { return this.account; }
-    transactionPolicy() {
-        return {
-            runtimeAddresses: Object.fromEntries([...this.chains].map(([id, config]) => [String(id), config.runtimeAddress])),
-        };
-    }
 }
 
 // #023: strip caller-supplied auth headers so an operation runs as the isolated wallet, not
@@ -602,12 +307,11 @@ function jwtExpiringSoon(token) {
 /*  WalletClient                                                       */
 /* ------------------------------------------------------------------ */
 class WalletClient {
-    constructor(provider, sessionManager, address, config, evmTransactionPolicy) {
+    constructor(provider, sessionManager, address, config) {
         this.provider = provider;
         this.sessionManager = sessionManager;
         this.address = address;
         this.config = config;
-        this.evmTransactionPolicy = evmTransactionPolicy;
         this.live = {
             intent: (roomPath, intent, opts = {}) => core.live.intent(roomPath, intent, this.mergeLiveIntentOptions(opts)),
             // Route status through the SAME auth merge intent uses so a server-keypair
@@ -640,10 +344,12 @@ class WalletClient {
     }
     /* ---- Auth override helpers ---- */
     buildOverrides() {
-        return Object.assign({ authProvider: this.provider, 
+        return {
+            authProvider: this.provider,
             // Pin every request to this wallet client's snapshotted app + endpoints so
             // a later global init() can never retarget its reads/writes (CTA-05).
-            _config: this.config, _getAuthHeaders: async () => {
+            _config: this.config,
+            _getAuthHeaders: async () => {
                 let s = await this.sessionManager.getSession();
                 // Keypair-backed session: if the cached token is expired/near-expiry,
                 // re-sign for a fresh one (we always hold the key). Keeps long-lived WS
@@ -654,9 +360,12 @@ class WalletClient {
                     s = await this.sessionManager.getSession();
                 }
                 return { Authorization: `Bearer ${s.idToken}` };
-            }, _clearAuth: async () => {
+            },
+            _clearAuth: async () => {
                 this.sessionManager.clearSession();
-            }, _walletAddress: this.address }, (this.evmTransactionPolicy ? { _evmTransactionPolicy: this.evmTransactionPolicy } : {}));
+            },
+            _walletAddress: this.address,
+        };
     }
     /** #023: strip caller Authorization (any casing) so operations run as the isolated wallet. */
     sanitizeHeaders(headers) {
@@ -665,7 +374,7 @@ class WalletClient {
     mergeSetOverrides(opts) {
         var _a;
         const ovr = this.buildOverrides();
-        return Object.assign(Object.assign({}, opts), { _overrides: Object.assign(Object.assign({}, opts === null || opts === void 0 ? void 0 : opts._overrides), { headers: this.sanitizeHeaders((_a = opts === null || opts === void 0 ? void 0 : opts._overrides) === null || _a === void 0 ? void 0 : _a.headers), authProvider: ovr.authProvider, _getAuthHeaders: ovr._getAuthHeaders, _clearAuth: ovr._clearAuth, _evmTransactionPolicy: ovr._evmTransactionPolicy, _config: ovr._config }) });
+        return Object.assign(Object.assign({}, opts), { _overrides: Object.assign(Object.assign({}, opts === null || opts === void 0 ? void 0 : opts._overrides), { headers: this.sanitizeHeaders((_a = opts === null || opts === void 0 ? void 0 : opts._overrides) === null || _a === void 0 ? void 0 : _a.headers), authProvider: ovr.authProvider, _getAuthHeaders: ovr._getAuthHeaders, _clearAuth: ovr._clearAuth, _config: ovr._config }) });
     }
     mergeReadOverrides(existing) {
         const ovr = this.buildOverrides();
@@ -784,20 +493,13 @@ class WalletClient {
     }
 }
 /**
- * Create a self-contained wallet client bound to one Solana or EVM keypair.
+ * Create a self-contained wallet client bound to one Solana keypair.
  * Each client has its own auth session — no global state is mutated.
  *
  * @example
  * ```ts
  * const vault = await createWalletClient({ keypair: process.env.VAULT_KEY });
  * await vault.set('markets/123', data);
- *
- * const evmVault = await createWalletClient({
- *   evmPrivateKey: process.env.EVM_PRIVATE_KEY,
- *   chainId: 8453,
- *   rpcUrl: process.env.BASE_RPC_URL,
- *   runtimeAddress: process.env.BOUNDED_RUNTIME,
- * });
  * ```
  */
 async function createWalletClient(opts) {
@@ -813,32 +515,8 @@ async function createWalletClient(opts) {
         authApiUrl: config.authApiUrl,
         authMethod: config.authMethod,
     };
-    if ('evmPrivateKey' in opts && typeof opts.evmPrivateKey === 'string') {
-        const chainConfigs = [];
-        if (opts.chains) {
-            for (const [rawId, chain] of Object.entries(opts.chains)) {
-                const chainId = Number(rawId);
-                if (!Number.isSafeInteger(chainId) || chainId <= 0)
-                    throw new Error(`Invalid EVM chain id in chains map: ${rawId}`);
-                chainConfigs.push({ chainId, rpcUrl: chain.rpcUrl, runtimeAddress: chain.runtimeAddress, name: chain.name });
-            }
-        }
-        if (opts.rpcUrl !== undefined || opts.runtimeAddress !== undefined) {
-            if (!opts.rpcUrl || !opts.runtimeAddress)
-                throw new Error('Single-chain EVM clients require both rpcUrl and runtimeAddress');
-            if (chainConfigs.some((chain) => chain.chainId === opts.chainId))
-                throw new Error(`EVM chain ${opts.chainId} is configured twice`);
-            chainConfigs.push({ chainId: opts.chainId, rpcUrl: opts.rpcUrl, runtimeAddress: opts.runtimeAddress });
-        }
-        if (chainConfigs.length === 0)
-            throw new Error('EVM wallet clients require an explicit RPC URL and BoundedRuntime address');
-        const provider = new EvmKeypairProvider(opts.evmPrivateKey, opts.chainId, chainConfigs);
-        const sessionManager = core.ServerSessionManager.forSessionFactory(() => provider.createBoundedSession(sessionConfig));
-        await sessionManager.getSession();
-        return new WalletClient(provider, sessionManager, provider.address, config, provider.transactionPolicy());
-    }
     if (!('keypair' in opts) || typeof opts.keypair !== 'string') {
-        throw new Error('createWalletClient requires exactly one of keypair or evmPrivateKey');
+        throw new Error('createWalletClient requires a Solana keypair');
     }
     const kp = parseKeypair(opts.keypair);
     let provider = new SolanaKeypairProvider((_a = config.rpcUrl) !== null && _a !== void 0 ? _a : null, kp);
@@ -1217,7 +895,6 @@ Object.defineProperty(exports, "waitForSetResult", {
     get: function () { return core.waitForSetResult; }
 });
 exports.DEFAULT_WEBHOOK_KEYS_URL = DEFAULT_WEBHOOK_KEYS_URL;
-exports.EvmKeypairProvider = EvmKeypairProvider;
 exports.InMemoryReplayStore = InMemoryReplayStore;
 exports.WalletClient = WalletClient;
 exports.WebhookVerificationError = WebhookVerificationError;