@bounded-sh/server 0.0.65 → 0.0.66

package/dist/index.mjs

@@ -1,10 +1,10 @@
-import { init as init$1, normalizeEvmAddress, genAuthNonce, getConfig, genSiweMessage, createSessionWithSignature, assertCanonicalBoundedRuntimeWriteCalldata, live as live$1, set as set$1, setMany as setMany$1, setFile as setFile$1, get as get$1, getMany as getMany$1, getFiles as getFiles$1, search as search$1, runQuery as runQuery$1, runQueryMany as runQueryMany$1, runExpression as runExpression$1, runExpressionMany as runExpressionMany$1, count as count$1, aggregate as aggregate$1, queryAggregate as queryAggregate$1, subscribe as subscribe$1, functions as functions$1, ServerSessionManager, getWebhookKeysUrl, getConfiguredAppId } from '@bounded-sh/core';
-export { BoundedDeclineError, DECLINE_EVENT_NAME, FunctionInvokeError, InsufficientBalanceError, LiveIntentError, deriveDecline, getConfig, getWebhookKeysUrl } from '@bounded-sh/core';
+import { init as init$1, normalizeEvmAddress, genAuthNonce, getConfig, genSiweMessage, createSessionWithSignature, assertCanonicalBoundedRuntimeWriteCalldata, live as live$1, set as set$1, setMany as setMany$1, setFile as setFile$1, reconcileSetResult, waitForSetResult, get as get$1, getMany as getMany$1, getFiles as getFiles$1, search as search$1, runQuery as runQuery$1, runQueryMany as runQueryMany$1, runExpression as runExpression$1, runExpressionMany as runExpressionMany$1, count as count$1, aggregate as aggregate$1, queryAggregate as queryAggregate$1, subscribe as subscribe$1, functions as functions$1, ServerSessionManager, getWebhookKeysUrl, getConfiguredAppId } from '@bounded-sh/core';
+export { BoundedDeclineError, DECLINE_EVENT_NAME, FunctionInvokeError, InsufficientBalanceError, LiveIntentError, deriveDecline, getConfig, getWebhookKeysUrl, reconcileSetResult, waitForSetResult } from '@bounded-sh/core';
 import { Connection, Keypair } from '@solana/web3.js';
 import bs58 from 'bs58';
 import { Buffer as Buffer$1 } from 'buffer';
 import nacl from 'tweetnacl';
-import { http, createWalletClient as createWalletClient$1, createPublicClient, defineChain } from 'viem';
+import { http, createWalletClient as createWalletClient$1, createPublicClient, keccak256, defineChain } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 
 async function init(newConfig) {
@@ -241,6 +241,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;
@@ -355,25 +397,145 @@ class EvmKeypairProvider {
         const transport = http(config.rpcUrl);
         const wallet = createWalletClient$1({ account: this.account, chain, transport });
         const publicClient = 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 = 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 = http(config.rpcUrl);
+        const publicClient = 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 {
@@ -530,6 +692,24 @@ class WalletClient {
     async setFile(path, file, options) {
         return setFile$1(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 reconcileSetResult(receipt, this.mergeReconcileOptions(options));
+    }
+    /** Bounded repeat of {@link reconcileSetResult}; see `waitForSetResult`. */
+    async waitForSetResult(receipt, options) {
+        return 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 get$1(path, Object.assign(Object.assign({}, opts), { _overrides: this.mergeReadOverrides(opts === null || opts === void 0 ? void 0 : opts._overrides) }));
     }