@bounded-sh/server 0.0.65 → 0.0.67

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

@@ -1,4 +1,4 @@
-import type { AuthProvider, EVMTransaction, SolTransaction, TransactionResult, User, SetOptions } from '@bounded-sh/core';
+import type { AuthProvider, EVMTransaction, EvmReconcileRequest, SolTransaction, TransactionReconciliation, TransactionResult, User, SetOptions } from '@bounded-sh/core';
 import { type SessionMintConfig } from '@bounded-sh/core';
 import type { PublicKey, Transaction, VersionedTransaction } from '@solana/web3.js';
 export interface EvmKeypairChainConfig {
@@ -27,6 +27,17 @@ export declare class EvmKeypairProvider implements AuthProvider {
     signTransaction(_transaction: Transaction | VersionedTransaction): Promise<Transaction | VersionedTransaction>;
     signAndSubmitTransaction(_transaction: Transaction | VersionedTransaction, _feePayer?: PublicKey): Promise<string>;
     runTransaction(evm?: EVMTransaction, sol?: SolTransaction, options?: SetOptions): Promise<TransactionResult>;
+    /**
+     * 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.
+     */
+    reconcileEvmTransaction(request: EvmReconcileRequest): Promise<TransactionReconciliation>;
     getNativeMethods(): Promise<any>;
     transactionPolicy(): {
         runtimeAddresses: Record<string, string>;

package/dist/index.d.ts

@@ -4,6 +4,8 @@ export { BoundedDeclineError, deriveDecline, DECLINE_EVENT_NAME } from '@bounded
 export type { BoundedDecline, DeclineReason, DeclineBoundary } from '@bounded-sh/core';
 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 { 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';

package/dist/index.js

@@ -242,6 +242,48 @@ class OffchainAuthProvider {
     }
 }
 
+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;
@@ -356,25 +398,145 @@ class EvmKeypairProvider {
         const transport = viem.http(config.rpcUrl);
         const wallet = viem.createWalletClient({ account: this.account, chain, transport });
         const publicClient = viem.createPublicClient({ chain, transport });
-        const hash = await wallet.sendTransaction({
-            account: this.account,
-            chain,
-            to: config.runtimeAddress,
-            data: evm.data,
-            value: BigInt(0),
-        });
-        const receipt = await publicClient.waitForTransactionReceipt({ hash });
+        // 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 {
@@ -531,6 +693,24 @@ class WalletClient {
     async setFile(path, file, options) {
         return core.setFile(path, file, { _overrides: this.mergeReadOverrides(options === null || options === void 0 ? void 0 : options._overrides) });
     }
+    /**
+     * Reconcile a `submitted` write receipt through THIS client's own provider
+     * and app binding. A bare top-level `reconcileSetResult` cannot serve a wallet
+     * client: the provider and config are private to the instance, and a later
+     * global `init()` would otherwise reconcile against the wrong app.
+     */
+    async reconcileSetResult(receipt, options) {
+        return core.reconcileSetResult(receipt, this.mergeReconcileOptions(options));
+    }
+    /** Bounded repeat of {@link reconcileSetResult}; see `waitForSetResult`. */
+    async waitForSetResult(receipt, options) {
+        return core.waitForSetResult(receipt, this.mergeReconcileOptions(options));
+    }
+    mergeReconcileOptions(opts) {
+        var _a;
+        const ovr = this.buildOverrides();
+        return Object.assign(Object.assign({}, (opts !== null && opts !== void 0 ? 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, _walletAddress: ovr._walletAddress, _config: ovr._config }) });
+    }
     async get(path, opts) {
         return core.get(path, Object.assign(Object.assign({}, opts), { _overrides: this.mergeReadOverrides(opts === null || opts === void 0 ? void 0 : opts._overrides) }));
     }
@@ -1028,6 +1208,14 @@ Object.defineProperty(exports, "getWebhookKeysUrl", {
     enumerable: true,
     get: function () { return core.getWebhookKeysUrl; }
 });
+Object.defineProperty(exports, "reconcileSetResult", {
+    enumerable: true,
+    get: function () { return core.reconcileSetResult; }
+});
+Object.defineProperty(exports, "waitForSetResult", {
+    enumerable: true,
+    get: function () { return core.waitForSetResult; }
+});
 exports.DEFAULT_WEBHOOK_KEYS_URL = DEFAULT_WEBHOOK_KEYS_URL;
 exports.EvmKeypairProvider = EvmKeypairProvider;
 exports.InMemoryReplayStore = InMemoryReplayStore;