@omegax/protocol-sdk 0.4.4 → 0.5.0

package/dist/rpc.js

@@ -1,6 +1,31 @@
 import { Connection, } from '@solana/web3.js';
 import { normalizeClaimSimulationFailure } from './claims.js';
-import { decodeSolanaTransaction, } from './transactions.js';
+import { decodeSolanaTransaction, serializeSolanaTransaction, } from './transactions.js';
+function shouldRetrySignedSimulationWithoutSigVerify(params) {
+    const message = params.error instanceof Error ? params.error.message : String(params.error);
+    return (params.sigVerify
+        && /invalid arguments/i.test(message));
+}
+async function simulateSignedTransaction(connection, transaction, options) {
+    const rpcRequest = connection._rpcRequest;
+    if (typeof rpcRequest !== 'function') {
+        return await connection.simulateTransaction(transaction, options);
+    }
+    const unsafe = await rpcRequest.call(connection, 'simulateTransaction', [
+        serializeSolanaTransaction(transaction).toString('base64'),
+        {
+            encoding: 'base64',
+            ...options,
+        },
+    ]);
+    if (unsafe?.error) {
+        throw new Error(unsafe.error.message ?? 'failed to simulate transaction');
+    }
+    if (!unsafe?.result?.value) {
+        throw new Error('failed to simulate transaction: missing RPC result');
+    }
+    return unsafe.result;
+}
 export const OMEGAX_NETWORKS = {
     devnet: {
         network: 'devnet',
@@ -85,11 +110,46 @@ export function createRpcClient(connection) {
                     failure: normalizeClaimSimulationFailure({ err: error, logs: [] }),
                 };
             }
-            const result = await connection.simulateTransaction(tx, {
+            const replaceRecentBlockhash = params.replaceRecentBlockhash ?? true;
+            const sigVerify = params.sigVerify ?? true;
+            const baseOptions = {
                 commitment: params.commitment ?? 'confirmed',
-                replaceRecentBlockhash: params.replaceRecentBlockhash ?? true,
-                sigVerify: params.sigVerify ?? true,
-            });
+                replaceRecentBlockhash,
+                sigVerify,
+            };
+            let result;
+            try {
+                result = await simulateSignedTransaction(connection, tx, baseOptions);
+            }
+            catch (error) {
+                if (!shouldRetrySignedSimulationWithoutSigVerify({
+                    error,
+                    sigVerify,
+                })) {
+                    return {
+                        ok: false,
+                        logs: [],
+                        unitsConsumed: null,
+                        err: error,
+                        failure: normalizeClaimSimulationFailure({ err: error, logs: [] }),
+                    };
+                }
+                try {
+                    result = await simulateSignedTransaction(connection, tx, {
+                        ...baseOptions,
+                        sigVerify: false,
+                    });
+                }
+                catch (retryError) {
+                    return {
+                        ok: false,
+                        logs: [],
+                        unitsConsumed: null,
+                        err: retryError,
+                        failure: normalizeClaimSimulationFailure({ err: retryError, logs: [] }),
+                    };
+                }
+            }
             const logs = result.value.logs ?? [];
             const unitsConsumed = typeof result.value.unitsConsumed === 'number'
                 ? result.value.unitsConsumed

package/dist/transactions.d.ts

@@ -4,6 +4,7 @@ export declare function decodeSolanaTransaction(input: string | Uint8Array | Buf
 export declare function serializeSolanaTransaction(transaction: SolanaTransaction): Buffer;
 export declare function serializeSolanaTransactionBase64(transaction: SolanaTransaction): string;
 export declare function solanaTransactionMessageBytes(transaction: SolanaTransaction): Uint8Array;
+export declare function solanaTransactionIntentMessageBytes(transaction: SolanaTransaction): Uint8Array;
 export declare function solanaTransactionMessageBase64(input: SolanaTransaction | string | Uint8Array | Buffer): string;
 export declare function solanaTransactionRequiredSigner(transaction: SolanaTransaction): string | null;
 export declare function solanaTransactionFirstSignature(transaction: SolanaTransaction): string | null;

package/dist/transactions.js

@@ -57,6 +57,23 @@ export function solanaTransactionMessageBytes(transaction) {
     }
     return transaction.message.serialize();
 }
+function normalizeSolanaMessageBytesIgnoringRecentBlockhash(messageBytes) {
+    const normalized = Uint8Array.from(messageBytes);
+    const messagePrefix = normalized[0] ?? 0;
+    const isVersioned = (messagePrefix & 0x80) !== 0;
+    let cursor = isVersioned ? 1 : 0;
+    cursor += 3;
+    const { length: accountKeyCount, bytesRead } = decodeShortVecLength(normalized, cursor);
+    cursor += bytesRead + accountKeyCount * 32;
+    if (cursor + 32 > normalized.length) {
+        throw new Error('invalid serialized transaction message');
+    }
+    normalized.fill(0, cursor, cursor + 32);
+    return normalized;
+}
+export function solanaTransactionIntentMessageBytes(transaction) {
+    return normalizeSolanaMessageBytesIgnoringRecentBlockhash(solanaTransactionMessageBytes(transaction));
+}
 export function solanaTransactionMessageBase64(input) {
     const transaction = typeof input === 'string' || input instanceof Uint8Array || Buffer.isBuffer(input)
         ? decodeSolanaTransaction(input)