@omegax/protocol-sdk 0.4.3 → 0.5.0

package/dist/rpc.js

@@ -1,5 +1,31 @@
-import { Connection, Transaction, } from '@solana/web3.js';
+import { Connection, } from '@solana/web3.js';
 import { normalizeClaimSimulationFailure } from './claims.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',
@@ -73,7 +99,7 @@ export function createRpcClient(connection) {
         async simulateSignedTx(params) {
             let tx;
             try {
-                tx = Transaction.from(Buffer.from(params.signedTxBase64, 'base64'));
+                tx = decodeSolanaTransaction(params.signedTxBase64);
             }
             catch (error) {
                 return {
@@ -84,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

@@ -0,0 +1,11 @@
+import { Transaction, VersionedTransaction } from '@solana/web3.js';
+export type SolanaTransaction = Transaction | VersionedTransaction;
+export declare function decodeSolanaTransaction(input: string | Uint8Array | Buffer): SolanaTransaction;
+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;
+export declare function solanaTransactionSignerSignature(transaction: SolanaTransaction, signer: string): Uint8Array | null;

package/dist/transactions.js

@@ -0,0 +1,121 @@
+import bs58 from 'bs58';
+import { Transaction, VersionedTransaction, } from '@solana/web3.js';
+function decodeShortVecLength(bytes, offset = 0) {
+    let length = 0;
+    let size = 0;
+    let cursor = offset;
+    while (cursor < bytes.length) {
+        const value = bytes[cursor] ?? 0;
+        length |= (value & 0x7f) << (size * 7);
+        size += 1;
+        cursor += 1;
+        if ((value & 0x80) === 0) {
+            return { length, bytesRead: size };
+        }
+    }
+    throw new Error('invalid shortvec length');
+}
+function versionedStaticAccountKeys(transaction) {
+    const message = transaction.message;
+    return (message?.staticAccountKeys ??
+        message?.getAccountKeys?.().staticAccountKeys ??
+        []);
+}
+function signatureIsPresent(signature) {
+    if (!signature || signature.length === 0)
+        return false;
+    return signature.some((value) => value !== 0);
+}
+export function decodeSolanaTransaction(input) {
+    const bytes = typeof input === 'string' ? Buffer.from(input, 'base64') : Buffer.from(input);
+    const { length: signatureCount, bytesRead } = decodeShortVecLength(bytes);
+    const messageOffset = bytesRead + signatureCount * 64;
+    if (messageOffset >= bytes.length) {
+        throw new Error('invalid serialized transaction');
+    }
+    const messagePrefix = bytes[messageOffset] ?? 0;
+    if ((messagePrefix & 0x80) !== 0) {
+        return VersionedTransaction.deserialize(bytes);
+    }
+    return Transaction.from(bytes);
+}
+export function serializeSolanaTransaction(transaction) {
+    if (transaction instanceof Transaction) {
+        return transaction.serialize({
+            requireAllSignatures: false,
+            verifySignatures: false,
+        });
+    }
+    return Buffer.from(transaction.serialize());
+}
+export function serializeSolanaTransactionBase64(transaction) {
+    return serializeSolanaTransaction(transaction).toString('base64');
+}
+export function solanaTransactionMessageBytes(transaction) {
+    if (transaction instanceof Transaction) {
+        return transaction.serializeMessage();
+    }
+    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)
+        : input;
+    return Buffer.from(solanaTransactionMessageBytes(transaction)).toString('base64');
+}
+export function solanaTransactionRequiredSigner(transaction) {
+    if (transaction instanceof Transaction) {
+        return transaction.feePayer?.toBase58() ?? null;
+    }
+    const accountKeys = versionedStaticAccountKeys(transaction);
+    return accountKeys[0]?.toBase58() ?? null;
+}
+export function solanaTransactionFirstSignature(transaction) {
+    if (transaction instanceof Transaction) {
+        if (transaction.signatures.length === 0)
+            return null;
+        const first = transaction.signatures[0];
+        if (!signatureIsPresent(first?.signature))
+            return null;
+        return bs58.encode(first.signature);
+    }
+    const first = transaction.signatures[0];
+    if (!signatureIsPresent(first))
+        return null;
+    return bs58.encode(first);
+}
+export function solanaTransactionSignerSignature(transaction, signer) {
+    if (transaction instanceof Transaction) {
+        const entry = transaction.signatures.find((candidate) => candidate.publicKey.toBase58() === signer);
+        return signatureIsPresent(entry?.signature) ? entry?.signature : null;
+    }
+    const accountKeys = versionedStaticAccountKeys(transaction);
+    const signerIndex = accountKeys.findIndex((candidate) => candidate.toBase58() === signer);
+    if (signerIndex < 0)
+        return null;
+    const header = transaction.message
+        .header;
+    const requiredSignerCount = header?.numRequiredSignatures ?? 0;
+    if (signerIndex >= requiredSignerCount) {
+        return null;
+    }
+    const signature = transaction.signatures[signerIndex];
+    return signatureIsPresent(signature) ? signature : null;
+}