@bounded-sh/core 0.0.90 → 0.0.92

package/dist/client/client-transaction-versions.d.ts

@@ -0,0 +1,2 @@
+import type { AuthProvider, SolanaTransactionVersion } from '../types';
+export declare function resolveClientTransactionVersions(authProvider: AuthProvider | null | undefined): Promise<SolanaTransactionVersion[]>;

package/dist/client/solana-operations.d.ts

@@ -1,6 +1,13 @@
+export { getTransactionJson, SOLANA_MAX_SUPPORTED_TRANSACTION_VERSION } from './solana-transaction-read';
 import type { VersionedTransaction } from '@solana/web3.js';
 import type { AuthProvider, SolanaTransactionResult } from '../types';
 import type { SetOptions } from './operations';
+/**
+ * Minimal base58 encoder, used ONLY to derive a Solana transaction signature
+ * from already-signed bytes. Core deliberately does not take a `bs58`
+ * dependency for eighteen lines of arithmetic.
+ */
+export declare function encodeBase58(bytes: Uint8Array): string;
 /**
  * Derive the transaction signature from the SIGNED bytes, before broadcasting.
  *
@@ -9,6 +16,8 @@ import type { SetOptions } from './operations';
  * nothing recorded — and a retry builds a DIFFERENT transaction that can land
  * beside the first.
  */
+/** true when the base64 wire is a SIMD-0385 v1 transaction (first byte 0x81). */
+export declare function isTransactionV1Base64(serializedTransaction: string): boolean;
 export declare function deriveTransactionSignature(signedTransaction: VersionedTransaction): string;
 export declare function isDefinitiveSolanaSendFailure(error: unknown): boolean;
 /**
@@ -33,6 +42,7 @@ export declare class BoundedOnchainRuleRejection extends Error {
     readonly logs: string[];
     constructor(cause: unknown, extraLogs?: unknown);
 }
+export declare function errorText(error: unknown): string;
 /**
  * One expected field operation, derived from the caller's request document.
  * `value`/`delta` are the JSON-round-tripped request values (what the server
@@ -80,6 +90,37 @@ export declare function buildExpectedWriteIntent(documents: Array<{
     destinationPath: string;
     document: any;
 }>): ExpectedWriteIntent;
+/**
+ * Minimal base58 decoder, used ONLY to recognize a declared-Address field: a
+ * request string that decodes to exactly the 32 bytes the instruction carries
+ * is a faithful AddressVal encoding of that string. Returns null on any
+ * non-base58 character.
+ */
+export declare function decodeBase58(text: string): Uint8Array | null;
+type PublicKeyClass = typeof import('@solana/web3.js')['PublicKey'];
+type PublicKeyInstance = InstanceType<PublicKeyClass>;
+export interface ServerTransactionInstructionView {
+    programId: string;
+    accountKeyIndexes: number[];
+    data: Uint8Array;
+}
+/**
+ * The format-blind half of pre-sign validation: every instruction must be a
+ * program the server builder is allowed to emit, the two setup shapes must
+ * recompute to this write's values, and exactly one Bounded set-documents
+ * instruction must bind the caller's own intent (OA-0001). The v0 path feeds it
+ * web3.js's compiled message; the SIMD-0385 v1 lane feeds it kit's decoded
+ * instruction headers and payloads.
+ */
+export declare function validateServerTransactionSemantics(input: {
+    label: string;
+    expectedAppId: string;
+    expectedIntent: ExpectedWriteIntent;
+    accountKeys: PublicKeyInstance[];
+    isAccountSigner: (index: number) => boolean;
+    instructions: ServerTransactionInstructionView[];
+    PublicKeyCtor: PublicKeyClass;
+}): void;
 export declare function handlePreBuiltTransaction(tx: {
     serializedTransaction: string;
     blockhash: string;

package/dist/client/solana-transaction-read.d.ts

@@ -0,0 +1,13 @@
+import type { SolanaWriteRpc } from '../types';
+/** The highest Solana transaction version this SDK reads back (SIMD-0385 v1). */
+export declare const SOLANA_MAX_SUPPORTED_TRANSACTION_VERSION = 1;
+/**
+ * getTransaction that survives a SIMD-0385 v1 response. @solana/web3.js 1.98.x
+ * validates `version` against `0 | 'legacy'` and THROWS on 1 even when the request
+ * raised the ceiling, so a real `Connection` (which exposes `rpcEndpoint`) is read
+ * as raw JSON-RPC instead. An injected double without an endpoint goes through its
+ * own `getTransaction` with the ceiling raised. Returns the RPC `result` (null when
+ * the signature is unknown); RPC and transport failures throw so callers keep
+ * treating a failed lookup as inconclusive rather than as absence.
+ */
+export declare function getTransactionJson(rpc: SolanaWriteRpc, signature: string, commitment?: 'confirmed' | 'finalized'): Promise<any | null>;

package/dist/client/solana-v1-operations.d.ts

@@ -0,0 +1,9 @@
+import type { AuthProvider, SolanaTransactionResult } from '../types';
+import type { SetOptions } from './operations';
+import { type ExpectedWriteIntent } from './solana-operations';
+export declare function handlePreBuiltV1Transaction(tx: {
+    serializedTransaction: string;
+    blockhash: string;
+    lastValidBlockHeight: number;
+    network: string;
+}, authProvider: AuthProvider, options: SetOptions | undefined, expectedIntent: ExpectedWriteIntent): Promise<SolanaTransactionResult>;

package/dist/{index-CXs7rqHt.js → index-BjLa1c_O.js}

@@ -4133,7 +4133,7 @@ class ServerSessionManager {
         const sessionConfig = (_a = this.sessionConfig) !== null && _a !== void 0 ? _a : undefined;
         /* fetch nonce from auth API (bound to the snapshotted app+issuer) */
         const nonce = await genAuthNonce(sessionConfig);
-        const { genSolanaMessage } = await Promise.resolve().then(function () { return require('./solana-message-BwjSWa1j.js'); });
+        const { genSolanaMessage } = await Promise.resolve().then(function () { return require('./solana-message-DY0FVgHp.js'); });
         const message = await genSolanaMessage(address, nonce, sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.appId);
         /* sign the message */
         const sigBytes = nacl.sign.detached(new TextEncoder().encode(message), kp.secretKey);
@@ -5157,6 +5157,23 @@ async function makeApiRequest(method, urlPath, data, _overrides) {
     }
 }
 
+async function resolveClientTransactionVersions(authProvider) {
+    if (!authProvider)
+        return ['legacy', 0];
+    if (typeof authProvider.supportedTransactionVersions === 'function') {
+        try {
+            const declared = await authProvider.supportedTransactionVersions();
+            const versions = declared.filter((v) => v === 'legacy' || v === 0 || v === 1);
+            // v1 needs a v1 signer no matter what the provider claims.
+            return versions.filter((v) => v !== 1 || typeof authProvider.signTransactionV1 === 'function');
+        }
+        catch (_a) {
+            return ['legacy', 0];
+        }
+    }
+    return typeof authProvider.signTransactionV1 === 'function' ? ['legacy', 0, 1] : ['legacy', 0];
+}
+
 /**
  * WebSocket v2 Subscription Manager
  *
@@ -6901,7 +6918,7 @@ async function doReconnectWithNewAuth() {
         console.warn('[WS v2] Failed to clear HTTP read cache on auth change:', error);
     }
     try {
-        const { reconnectRealtimeStoreWithNewAuth } = await Promise.resolve().then(function () { return require('./realtime-store-Dv_JzBx6.js'); });
+        const { reconnectRealtimeStoreWithNewAuth } = await Promise.resolve().then(function () { return require('./realtime-store-O-5CDrGm.js'); });
         await reconnectRealtimeStoreWithNewAuth();
     }
     catch (error) {
@@ -8281,7 +8298,10 @@ async function setMany(many, options) {
         }
         let setResponse;
         try {
-            setResponse = await makeApiRequest('PUT', `items`, { documents }, options === null || options === void 0 ? void 0 : options._overrides);
+            // SIMD-0385: tell the worker which Solana transaction formats this client
+            // can sign, so it builds v1 only for a client that can complete it.
+            const clientTransactionVersions = await resolveClientTransactionVersions(authProvider);
+            setResponse = await makeApiRequest('PUT', `items`, { documents, clientTransactionVersions }, options === null || options === void 0 ? void 0 : options._overrides);
         }
         catch (error) {
             if ((error === null || error === void 0 ? void 0 : error.statusCode) === 402 && (error === null || error === void 0 ? void 0 : error.error) === 'INSUFFICIENT_BALANCE') {
@@ -8348,7 +8368,7 @@ async function setMany(many, options) {
                         'Nothing was signed or submitted.');
                 }
                 const solanaChain = workerChain;
-                const { handlePreBuiltTransaction, buildExpectedWriteIntent } = await Promise.resolve().then(function () { return require('./solana-operations-DS9-hI7T.js'); });
+                const { handlePreBuiltTransaction, buildExpectedWriteIntent } = await Promise.resolve().then(function () { return require('./solana-operations-DSAWnjWi.js'); });
                 // OA-0001: derive the expected intent from OUR OWN request (the one
                 // ground truth a tampered builder response cannot change) so the
                 // validator can reject any transaction whose operation semantics
@@ -8669,6 +8689,48 @@ var operations = /*#__PURE__*/Object.freeze({
     syncItems: syncItems
 });
 
+/** The highest Solana transaction version this SDK reads back (SIMD-0385 v1). */
+const SOLANA_MAX_SUPPORTED_TRANSACTION_VERSION = 1;
+/**
+ * getTransaction that survives a SIMD-0385 v1 response. @solana/web3.js 1.98.x
+ * validates `version` against `0 | 'legacy'` and THROWS on 1 even when the request
+ * raised the ceiling, so a real `Connection` (which exposes `rpcEndpoint`) is read
+ * as raw JSON-RPC instead. An injected double without an endpoint goes through its
+ * own `getTransaction` with the ceiling raised. Returns the RPC `result` (null when
+ * the signature is unknown); RPC and transport failures throw so callers keep
+ * treating a failed lookup as inconclusive rather than as absence.
+ */
+async function getTransactionJson(rpc, signature, commitment = 'confirmed') {
+    var _a;
+    const endpoint = typeof (rpc === null || rpc === void 0 ? void 0 : rpc.rpcEndpoint) === 'string' ? rpc.rpcEndpoint.trim() : '';
+    if (!endpoint) {
+        return rpc.getTransaction(signature, {
+            maxSupportedTransactionVersion: SOLANA_MAX_SUPPORTED_TRANSACTION_VERSION,
+            commitment,
+        });
+    }
+    const response = await fetch(endpoint, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'getTransaction',
+            params: [signature, {
+                    commitment,
+                    encoding: 'json',
+                    maxSupportedTransactionVersion: SOLANA_MAX_SUPPORTED_TRANSACTION_VERSION,
+                }],
+        }),
+    });
+    if (!response.ok)
+        throw new Error(`getTransaction http ${response.status}`);
+    const body = await response.json();
+    if (body === null || body === void 0 ? void 0 : body.error)
+        throw new Error(`getTransaction rpc error ${body.error.code}: ${body.error.message}`);
+    return (_a = body === null || body === void 0 ? void 0 : body.result) !== null && _a !== void 0 ? _a : null;
+}
+
 const DEFAULT_TIMEOUT_MS = 60000;
 const DEFAULT_MAX_ATTEMPTS = 20;
 const DEFAULT_POLL_INTERVAL_MS = 3000;
@@ -8798,10 +8860,7 @@ async function reconcileSolana(receipt, config, options) {
     // Expired. Prove absence from history before declaring the write retry-safe.
     let history;
     try {
-        history = await rpc.getTransaction(receipt.transactionId, {
-            maxSupportedTransactionVersion: 0,
-            commitment: 'confirmed',
-        });
+        history = await getTransactionJson(rpc, receipt.transactionId, 'confirmed');
     }
     catch (error) {
         return stillSubmitted(receipt, `history lookup failed after expiry: ${errorText(error)}`);
@@ -9794,7 +9853,7 @@ function toMillis(seconds) {
 
 /** SIWS message creation is async already, so its onchain module can be lazy. */
 async function genSolanaMessage(address, nonce) {
-    const implementation = await Promise.resolve().then(function () { return require('./solana-message-BwjSWa1j.js'); });
+    const implementation = await Promise.resolve().then(function () { return require('./solana-message-DY0FVgHp.js'); });
     return implementation.genSolanaMessage(address, nonce);
 }
 
@@ -10281,6 +10340,7 @@ exports.LiveIntentError = LiveIntentError;
 exports.MIN_QUERY_POLL_INTERVAL_MS = MIN_QUERY_POLL_INTERVAL_MS;
 exports.RATE_LIMIT_EVENT_NAME = RATE_LIMIT_EVENT_NAME;
 exports.ReactNativeSessionManager = ReactNativeSessionManager;
+exports.SOLANA_MAX_SUPPORTED_TRANSACTION_VERSION = SOLANA_MAX_SUPPORTED_TRANSACTION_VERSION;
 exports.ScopedClientReadOnlyError = ScopedClientReadOnlyError;
 exports.ServerSessionManager = ServerSessionManager;
 exports.SessionEnvironmentError = SessionEnvironmentError;
@@ -10316,6 +10376,7 @@ exports.getFreshAuthToken = getFreshAuthToken;
 exports.getIdToken = getIdToken;
 exports.getMany = getMany;
 exports.getSessionGeneration = getSessionGeneration;
+exports.getTransactionJson = getTransactionJson;
 exports.getWebhookKeysUrl = getWebhookKeysUrl;
 exports.hasActiveConnection = hasActiveConnection;
 exports.increment = increment;
@@ -10355,4 +10416,4 @@ exports.toMillis = toMillis;
 exports.toSeconds = toSeconds;
 exports.waitForSetResult = waitForSetResult;
 exports.withEffects = withEffects;
-//# sourceMappingURL=index-CXs7rqHt.js.map
+//# sourceMappingURL=index-BjLa1c_O.js.map