@bounded-sh/core 0.0.72 → 0.0.73

package/dist/{solana-operations-DGEGqFd9.js → solana-operations-DycSSUls.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-yT8ZfzrL.js');
+var index = require('./index-C9ezg0Ef.js');
 require('axios');
 require('tweetnacl');
 require('reconnecting-websocket');
@@ -151,33 +151,39 @@ class BorshCursor {
         return value >>> 0;
     }
     skip(length, field) { this.requireBytes(length, field); this.offset += length; }
-    readString(field) {
-        const length = this.readU32(`${field} length`);
+    readBytes(length, field) {
         this.requireBytes(length, field);
         const raw = this.data.slice(this.offset, this.offset + length);
         this.offset += length;
-        return index.bufferExports.Buffer.from(raw).toString('utf8');
+        return raw;
+    }
+    readString(field) {
+        const length = this.readU32(`${field} length`);
+        return index.bufferExports.Buffer.from(this.readBytes(length, field)).toString('utf8');
+    }
+    readLengthPrefixedBytes(field) {
+        return this.readBytes(this.readU32(`${field} length`), field);
     }
-    skipBytes(field) { this.skip(this.readU32(`${field} length`), field); }
     isAtEnd() { return this.offset === this.data.length; }
 }
-function skipBoundedFieldValue(cursor) {
+function readBoundedFieldValue(cursor) {
     const option = cursor.readU8('operation value option');
     if (option === 0)
-        return;
+        return null;
     if (option !== 1)
         throw new Error('Server transaction has malformed Bounded field value option');
     const variant = cursor.readU8('operation value variant');
-    if (variant === 0 || variant === 1)
-        cursor.skip(8, 'operation numeric value');
-    else if (variant === 2)
-        cursor.skip(1, 'operation bool value');
-    else if (variant === 3)
-        cursor.readString('operation string value');
-    else if (variant === 4)
-        cursor.skip(32, 'operation address value');
-    else
-        throw new Error(`Server transaction has unsupported Bounded field value variant: ${variant}`);
+    if (variant === 0)
+        return { variant: 'u64', value: readU64LE(cursor.readBytes(8, 'operation numeric value'), 0) };
+    if (variant === 1)
+        return { variant: 'i64', value: readI64LE(cursor.readBytes(8, 'operation numeric value'), 0) };
+    if (variant === 2)
+        return { variant: 'bool', value: cursor.readU8('operation bool value') !== 0 };
+    if (variant === 3)
+        return { variant: 'string', value: cursor.readString('operation string value') };
+    if (variant === 4)
+        return { variant: 'address', value: cursor.readBytes(32, 'operation address value') };
+    throw new Error(`Server transaction has unsupported Bounded field value variant: ${variant}`);
 }
 function normalizeOnchainPath(path) {
     let normalized = path.startsWith('/') ? path.slice(1) : path;
@@ -196,43 +202,323 @@ function parseBoundedSetDocumentsInstruction(data, label) {
     }
     const cursor = new BorshCursor(data, 8, label);
     const appId = cursor.readString('appId');
-    const documentPaths = [];
+    const documents = [];
     const documentCount = cursor.readU32('documents length');
     for (let i = 0; i < documentCount; i++) {
-        documentPaths.push(normalizeOnchainPath(cursor.readString('document path')));
+        const path = normalizeOnchainPath(cursor.readString('document path'));
+        const operations = [];
         const operationCount = cursor.readU32('operations length');
         for (let j = 0; j < operationCount; j++) {
-            cursor.readString('operation key');
-            skipBoundedFieldValue(cursor);
-            cursor.skip(1, 'operation kind');
+            const key = cursor.readString('operation key');
+            const value = readBoundedFieldValue(cursor);
+            const kind = cursor.readU8('operation kind');
+            operations.push({ key, value, kind });
         }
+        documents.push({ path, operations });
     }
     const deletePaths = [];
     const deleteCount = cursor.readU32('delete paths length');
     for (let i = 0; i < deleteCount; i++)
         deletePaths.push(normalizeOnchainPath(cursor.readString('delete path')));
+    const txData = [];
     const txDataCount = cursor.readU32('txData length');
     for (let i = 0; i < txDataCount; i++) {
-        cursor.readString('txData plugin function key');
-        cursor.skipBytes('txData bytes');
-        cursor.skipBytes('txData raIndices');
+        txData.push({
+            pluginFunctionKey: cursor.readString('txData plugin function key'),
+            payload: cursor.readLengthPrefixedBytes('txData bytes'),
+            raIndices: cursor.readLengthPrefixedBytes('txData raIndices'),
+        });
     }
-    const simulate = cursor.readU8('simulate');
-    if (simulate !== 0 && simulate !== 1)
+    const simulateByte = cursor.readU8('simulate');
+    if (simulateByte !== 0 && simulateByte !== 1)
         throw new Error(`${label} has malformed Bounded simulate flag`);
     if (!cursor.isAtEnd())
         throw new Error(`${label} has trailing Bounded instruction data`);
-    return { appId, documentPaths, deletePaths };
+    return { appId, documents, deletePaths, txData, simulate: simulateByte === 1 };
+}
+// ---------------------------------------------------------------------------
+// OA-0001: signing-intent binding
+//
+// The wallet must sign ONLY the state transition the caller actually requested.
+// The expected intent below is derived from the CLIENT'S OWN write request - the
+// one ground truth a tampered builder response cannot change - and the parsed
+// instruction must match it field for field before any signer is invoked.
+// ---------------------------------------------------------------------------
+/** The program's field-operation kinds (programs/tarobase; mirrored by the worker's solana-tx-builder). */
+const FIELD_OPERATION_WRITE = 0;
+const FIELD_OPERATION_DELETE = 1;
+const FIELD_OPERATION_TIMESTAMP = 2;
+const FIELD_OPERATION_INCREMENT = 3;
+// Keys the worker drops from a client write by NAME before encoding
+// (realtime-worker types.ts: SYSTEM_FIELDS without the `_`-prefixed entries the
+// client already strips, plus the prototype-pollution DANGEROUS_KEYS). The
+// expected model must skip exactly the keys the honest builder skips, or a
+// legitimate write would be rejected.
+const SERVER_DROPPED_FIELD_KEYS = new Set([
+    'pathId',
+    'relativePath',
+    'absolutePath',
+    '__proto__',
+    'constructor',
+    'prototype',
+]);
+// The worker resolves {operation:'time',value:'now'} into this sentinel and the
+// onchain encoder maps the sentinel to a TIMESTAMP op - including when a caller
+// writes the literal string, so the expected model must mirror that quirk.
+const TIME_NOW_SENTINEL = '__TIME_NOW__';
+/**
+ * Build the expected write intent from the exact request the client POSTed
+ * (`[{ destinationPath, document }]`, a `null` document being a delete).
+ *
+ * Each document is JSON-round-tripped first: the server parsed the SERIALIZED
+ * body, so the intent must be derived from the same bytes - this drops
+ * `undefined` values, turns `NaN`/`Infinity` into `null`, and normalizes key
+ * order exactly as the server's JSON.parse did.
+ *
+ * Operation order mirrors the worker's transform (normalizeWriteBody ->
+ * resolveOperationFields -> documentToOperations): plain fields in request key
+ * order, then increment fields appended in the order they appeared. The
+ * comparison is therefore ORDERED, not a multiset - the honest builder is
+ * deterministic given the request, and ordering additionally catches
+ * duplicate-path and reordering tampering that the retired set comparison hid.
+ */
+function buildExpectedWriteIntent(documents) {
+    const intentDocuments = [];
+    const deletePaths = [];
+    for (const entry of documents) {
+        if (entry.document == null) {
+            deletePaths.push(entry.destinationPath);
+            continue;
+        }
+        if (typeof entry.document !== 'object') {
+            // The worker 400s a scalar document, so no honest 202 can exist for this
+            // request. Throw here rather than let a dishonest 202 be compared against
+            // an intent this entry never had.
+            throw new Error(`Cannot derive the expected write intent for ${entry.destinationPath}: the request document is not an object`);
+        }
+        const wireDocument = JSON.parse(JSON.stringify(entry.document));
+        const operations = [];
+        const increments = [];
+        for (const [key, value] of Object.entries(wireDocument)) {
+            if (key.startsWith('_') || SERVER_DROPPED_FIELD_KEYS.has(key))
+                continue;
+            if (value === null) {
+                operations.push({ key, kind: 'delete' });
+                continue;
+            }
+            if (typeof value === 'object' && !Array.isArray(value) &&
+                typeof value.operation === 'string' && value.operation.length > 0) {
+                const operation = value.operation;
+                if (operation === 'increment' && typeof value.value === 'number') {
+                    increments.push({ key, delta: value.value });
+                    continue;
+                }
+                if (operation === 'time' && value.value === 'now') {
+                    operations.push({ key, kind: 'timestamp' });
+                    continue;
+                }
+                // Any other {operation,...} shape is rejected by the worker with a 400,
+                // so it has no honest onchain encoding. Falling through to a plain write
+                // of the raw object keeps the comparison fail-closed: a 202 can only
+                // arrive from a dishonest builder, and no instruction can match this.
+            }
+            if (value === TIME_NOW_SENTINEL) {
+                operations.push({ key, kind: 'timestamp' });
+                continue;
+            }
+            operations.push({ key, kind: 'write', value });
+        }
+        for (const { key, delta } of increments) {
+            operations.push({ key, kind: 'increment', delta });
+        }
+        intentDocuments.push({ path: entry.destinationPath, operations });
+    }
+    return { documents: intentDocuments, deletePaths };
+}
+/**
+ * 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.
+ */
+function decodeBase58(text) {
+    if (text.length === 0)
+        return null;
+    let value = BigInt(0);
+    for (const ch of text) {
+        const digit = BASE58_ALPHABET.indexOf(ch);
+        if (digit < 0)
+            return null;
+        value = value * BigInt(58) + BigInt(digit);
+    }
+    // Leading '1' characters are leading zero bytes, not part of the number.
+    let leadingZeros = 0;
+    while (leadingZeros < text.length && text[leadingZeros] === BASE58_ALPHABET[0])
+        leadingZeros++;
+    const body = [];
+    if (value > BigInt(0)) {
+        let hex = value.toString(16);
+        if (hex.length % 2 === 1)
+            hex = `0${hex}`;
+        for (let i = 0; i < hex.length; i += 2)
+            body.push(parseInt(hex.slice(i, i + 2), 16));
+    }
+    const out = new Uint8Array(leadingZeros + body.length);
+    out.set(body, leadingZeros);
+    return out;
 }
-function assertSamePathSet(label, expectedPaths, actualPaths) {
-    const expected = new Set(expectedPaths.map(normalizeOnchainPath).filter(Boolean));
-    const actual = new Set(actualPaths.map(normalizeOnchainPath).filter(Boolean));
-    const missing = [...expected].filter(path => !actual.has(path));
-    const extra = [...actual].filter(path => !expected.has(path));
-    if (missing.length || extra.length) {
-        const details = [missing.length ? `missing paths: ${missing.join(', ')}` : '', extra.length ? `unexpected paths: ${extra.join(', ')}` : '']
-            .filter(Boolean).join('; ');
-        throw new Error(`${label} Bounded instruction paths do not match requested write paths (${details})`);
+/**
+ * Whether `parsed` is an encoding the HONEST builder could have produced for
+ * the request field value. The onchain FieldValue variant is chosen by the
+ * collection's DECLARED schema (worker-side `jsValueToFieldValue`), which the
+ * client does not hold, so every variant any declared type could yield for this
+ * JSON value is accepted - and nothing else:
+ * - boolean: BoolVal only.
+ * - integer number/bigint: U64Val (inference/UInt; UInt takes abs for
+ *   negatives) or I64Val (Int), of the exact integer.
+ * - fractional number: StringVal of its decimal text (inference/Float), or a
+ *   truncated U64/I64 (declared UInt/Int truncates toward zero).
+ * - string: StringVal verbatim, AddressVal when it is the base58 of the exact
+ *   32 bytes (declared Address), or U64/I64 of its integer text (declared
+ *   UInt/Int accept numeric strings, truncating any fraction).
+ * - array/object: StringVal of its JSON serialization (identical on both sides
+ *   of the wire for the round-tripped value).
+ */
+function isFaithfulFieldValueEncoding(requestValue, parsed) {
+    if (parsed === null)
+        return false;
+    if (typeof requestValue === 'boolean') {
+        return parsed.variant === 'bool' && parsed.value === requestValue;
+    }
+    if (typeof requestValue === 'number') {
+        if (!Number.isFinite(requestValue))
+            return false;
+        if (Number.isInteger(requestValue)) {
+            const exact = BigInt(requestValue);
+            if (parsed.variant === 'i64' && parsed.value === exact)
+                return true;
+            // The declared-UInt encoder stores abs(value), so a negative request
+            // integer can honestly arrive as its positive magnitude.
+            return parsed.variant === 'u64' && parsed.value === (exact < BigInt(0) ? -exact : exact);
+        }
+        if (parsed.variant === 'string' && parsed.value === String(requestValue))
+            return true;
+        const truncated = BigInt(Math.trunc(requestValue));
+        if (parsed.variant === 'i64' && parsed.value === truncated)
+            return true;
+        return parsed.variant === 'u64' && parsed.value === (truncated < BigInt(0) ? -truncated : truncated);
+    }
+    if (typeof requestValue === 'string') {
+        if (parsed.variant === 'string' && parsed.value === requestValue)
+            return true;
+        if (parsed.variant === 'address') {
+            const decoded = decodeBase58(requestValue);
+            const expectedBytes = parsed.value;
+            if (decoded !== null && decoded.length === 32 && decoded.every((byte, i) => byte === expectedBytes[i]))
+                return true;
+        }
+        if (parsed.variant === 'u64' || parsed.variant === 'i64') {
+            const trimmed = requestValue.trim();
+            const intPart = trimmed.includes('.') ? trimmed.split('.')[0] : trimmed;
+            if (/^-?\d+$/.test(intPart)) {
+                const numeric = BigInt(intPart);
+                if (parsed.variant === 'i64' && parsed.value === numeric)
+                    return true;
+                if (parsed.variant === 'u64' && parsed.value === (numeric < BigInt(0) ? -numeric : numeric))
+                    return true;
+            }
+        }
+        return false;
+    }
+    if (requestValue !== null && typeof requestValue === 'object') {
+        return parsed.variant === 'string' && parsed.value === JSON.stringify(requestValue);
+    }
+    return false;
+}
+const EXPECTED_KIND_TO_WIRE = {
+    write: FIELD_OPERATION_WRITE,
+    delete: FIELD_OPERATION_DELETE,
+    timestamp: FIELD_OPERATION_TIMESTAMP,
+    increment: FIELD_OPERATION_INCREMENT,
+};
+function describeParsedValue(value) {
+    if (value === null)
+        return 'no value';
+    if (value.variant === 'address')
+        return `address 0x${index.bufferExports.Buffer.from(value.value).toString('hex')}`;
+    if (value.variant === 'u64' || value.variant === 'i64')
+        return `${value.variant} ${value.value.toString()}`;
+    return `${value.variant} ${JSON.stringify(value.value)}`;
+}
+/**
+ * OA-0001: the one Bounded set-documents instruction in a server-built
+ * transaction must encode EXACTLY the requested write - app id, ordered
+ * documents, per-field operation key/kind/value, ordered deletes, and a clear
+ * simulate flag - or the transaction is rejected BEFORE the wallet sees it.
+ *
+ * The comparison is ordered because the honest builder (realtime-worker's
+ * solana-tx-builder) preserves the request's document/delete/operation order
+ * deterministically; nothing legitimate reorders, and an ordered check catches
+ * duplicate-path and reorder tampering the retired path-SET comparison hid.
+ *
+ * Deliberately NOT bound here: the plugin `txData` entries and the remaining
+ * accounts their ra_indices reference. Those are derived by server-side policy
+ * hooks (a Jupiter quote, an ATA layout), not by the caller's request, so the
+ * client holds no request-derived expectation to compare against; that surface
+ * stays bound by the onchain policy, the typed setup-instruction guards, and
+ * the attestation co-signer the program demands for any non-empty txData.
+ */
+function assertMatchesExpectedIntent(label, expectedAppId, expected, parsed) {
+    var _a;
+    if (parsed.appId !== expectedAppId)
+        throw new Error(`${label} Bounded instruction appId does not match configured appId`);
+    if (parsed.simulate) {
+        throw new Error(`${label} Bounded instruction has the simulate flag set; a client-signed write must be a real execution`);
+    }
+    if (parsed.deletePaths.length !== expected.deletePaths.length ||
+        parsed.deletePaths.some((path, i) => path !== normalizeOnchainPath(expected.deletePaths[i]))) {
+        throw new Error(`${label} Bounded instruction delete paths do not match the requested deletes`);
+    }
+    if (parsed.documents.length !== expected.documents.length) {
+        throw new Error(`${label} Bounded instruction document count does not match the requested write ` +
+            `(expected ${expected.documents.length}, got ${parsed.documents.length})`);
+    }
+    for (let i = 0; i < expected.documents.length; i++) {
+        const expectedDoc = expected.documents[i];
+        const actualDoc = parsed.documents[i];
+        const expectedPath = normalizeOnchainPath(expectedDoc.path);
+        if (actualDoc.path !== expectedPath) {
+            throw new Error(`${label} Bounded instruction document path "${actualDoc.path}" does not match requested path "${expectedPath}"`);
+        }
+        if (actualDoc.operations.length !== expectedDoc.operations.length) {
+            throw new Error(`${label} Bounded instruction operations for path "${expectedPath}" do not match the requested write ` +
+                `(expected ${expectedDoc.operations.length} operations, got ${actualDoc.operations.length})`);
+        }
+        for (let j = 0; j < expectedDoc.operations.length; j++) {
+            const expectedOp = expectedDoc.operations[j];
+            const actualOp = actualDoc.operations[j];
+            if (actualOp.key !== expectedOp.key || actualOp.kind !== EXPECTED_KIND_TO_WIRE[expectedOp.kind]) {
+                throw new Error(`${label} Bounded instruction operation ${j} on path "${expectedPath}" does not match the requested write ` +
+                    `(expected key "${expectedOp.key}" kind ${expectedOp.kind}, got key "${actualOp.key}" kind ${actualOp.kind})`);
+            }
+            if (expectedOp.kind === 'delete' || expectedOp.kind === 'timestamp') {
+                if (actualOp.value !== null) {
+                    throw new Error(`${label} Bounded instruction operation "${expectedOp.key}" on path "${expectedPath}" carries an unexpected value`);
+                }
+                continue;
+            }
+            if (expectedOp.kind === 'increment') {
+                const expectedDelta = BigInt(Math.trunc(expectedOp.delta));
+                if (((_a = actualOp.value) === null || _a === void 0 ? void 0 : _a.variant) !== 'i64' || actualOp.value.value !== expectedDelta) {
+                    throw new Error(`${label} Bounded instruction increment "${expectedOp.key}" on path "${expectedPath}" does not match the requested delta`);
+                }
+                continue;
+            }
+            if (!isFaithfulFieldValueEncoding(expectedOp.value, actualOp.value)) {
+                throw new Error(`${label} Bounded instruction operation "${expectedOp.key}" on path "${expectedPath}" encodes a value that does not match the requested field ` +
+                    `(got ${describeParsedValue(actualOp.value)})`);
+            }
+        }
     }
 }
 /** Read a little-endian u64 as a BigInt (lamport amounts can exceed 2^53). */
@@ -242,6 +528,11 @@ function readU64LE(bytes, offset) {
         value |= BigInt(bytes[offset + i]) << BigInt(8 * i);
     return value;
 }
+/** Read a little-endian i64 as a BigInt (two's complement). */
+function readI64LE(bytes, offset) {
+    const unsigned = readU64LE(bytes, offset);
+    return unsigned >= (BigInt(1) << BigInt(63)) ? unsigned - (BigInt(1) << BigInt(64)) : unsigned;
+}
 /**
  * Resolve an instruction's referenced account keys against the transaction's
  * STATIC key list. A setup instruction that reaches into an address-lookup
@@ -320,14 +611,14 @@ function deserializeAndValidateServerTransaction(serializedTransaction, web3, op
     var _a;
     const { VersionedTransaction: VersionedTransactionClass, PublicKey: PublicKeyCtor } = web3;
     const transaction = VersionedTransactionClass.deserialize(index.bufferExports.Buffer.from(serializedTransaction, 'base64'));
-    const { label, expectedAppId, expectedWritePaths } = options;
+    const { label, expectedAppId, expectedIntent } = options;
     const accountKeys = transaction.message.staticAccountKeys;
     if (accountKeys.length === 0)
         throw new Error(`${label} has no static account keys`);
     const feePayer = accountKeys[0];
     const isAccountSigner = (index) => transaction.message.isAccountSigner(index);
     let boundedInstructionCount = 0;
-    const actualWritePaths = [];
+    let parsedBoundedInstruction = null;
     for (const ix of transaction.message.compiledInstructions) {
         if (ix.programIdIndex >= accountKeys.length)
             throw new Error(`${label} has program ID in lookup table (not allowed)`);
@@ -347,31 +638,38 @@ function deserializeAndValidateServerTransaction(serializedTransaction, web3, op
         }
         else if (programId === BOUNDED_PROGRAM_MAINNET || programId === BOUNDED_PROGRAM_DEVNET) {
             boundedInstructionCount++;
-            const parsed = parseBoundedSetDocumentsInstruction(data, label);
-            if (parsed.appId !== expectedAppId)
-                throw new Error(`${label} Bounded instruction appId does not match configured appId`);
-            actualWritePaths.push(...parsed.documentPaths, ...parsed.deletePaths);
+            parsedBoundedInstruction = parseBoundedSetDocumentsInstruction(data, label);
         }
     }
     if (boundedInstructionCount !== 1)
         throw new Error(`${label} must contain exactly one Bounded set-documents instruction`);
-    assertSamePathSet(label, expectedWritePaths, actualWritePaths);
+    // OA-0001: bind the FULL operation semantics of the one Bounded instruction to
+    // the caller's own request before any signer runs - not just the app/path
+    // envelope, which a tampered builder response can keep while changing amounts.
+    assertMatchesExpectedIntent(label, expectedAppId, expectedIntent, parsedBoundedInstruction);
     return transaction;
 }
-async function handlePreBuiltTransaction(tx, authProvider, options, expectedWritePaths) {
+async function handlePreBuiltTransaction(tx, authProvider, options, expectedIntent) {
     var _a, _b, _c, _d, _e, _f, _g, _h;
     const { Connection, VersionedTransaction, PublicKey } = await import('@solana/web3.js');
     // Honor a wallet client's immutable config snapshot for the expected app-id
     // binding and RPC endpoint (CTA-05); otherwise read the global init() config.
     const config = (_b = (_a = options === null || options === void 0 ? void 0 : options._overrides) === null || _a === void 0 ? void 0 : _a._config) !== null && _b !== void 0 ? _b : await index.getConfig();
     const transaction = deserializeAndValidateServerTransaction(tx.serializedTransaction, { VersionedTransaction, PublicKey }, {
-        label: 'Pre-built transaction', expectedAppId: config.appId, expectedWritePaths,
+        label: 'Pre-built transaction', expectedAppId: config.appId, expectedIntent,
     });
     const shouldSubmit = (options === null || options === void 0 ? void 0 : options.shouldSubmitTx) !== false;
     const rpcUrl = (_c = config.rpcUrl) === null || _c === void 0 ? void 0 : _c.trim();
     const injectedRpc = (_d = options === null || options === void 0 ? void 0 : options._overrides) === null || _d === void 0 ? void 0 : _d._solanaRpc;
     if (shouldSubmit && !rpcUrl && !injectedRpc) {
-        throw new Error(`Pre-built Solana transaction submission requires init({ rpcUrl }) for ${tx.network}`);
+        // Checked BEFORE the wallet signs, so a misconfigured app fails its first
+        // launch attempt without spending the user's signature. Deliberately no
+        // bundled default endpoint (2026-06-28 hardening): the app must supply the
+        // RPC it submits through.
+        throw new Error(`Pre-built Solana transaction submission requires init({ rpcUrl }) for ${tx.network}. ` +
+            `Pass a TOP-LEVEL rpcUrl (with chain) to init(), e.g. ` +
+            `init({ appId, chain: '${tx.network}', rpcUrl: '<your ${tx.network} RPC endpoint>' }); ` +
+            `a nested walletLogin.rpcUrl only configures wallet login and does not enable submission.`);
     }
     const signedTx = await authProvider.signTransaction(transaction);
     const rawTx = signedTx.serialize();
@@ -452,7 +750,8 @@ async function handlePreBuiltTransaction(tx, authProvider, options, expectedWrit
     };
 }
 
+exports.buildExpectedWriteIntent = buildExpectedWriteIntent;
 exports.deriveTransactionSignature = deriveTransactionSignature;
 exports.handlePreBuiltTransaction = handlePreBuiltTransaction;
 exports.isDefinitiveSolanaSendFailure = isDefinitiveSolanaSendFailure;
-//# sourceMappingURL=solana-operations-DGEGqFd9.js.map
+//# sourceMappingURL=solana-operations-DycSSUls.js.map