@debridge-finance/solana-utils 4.3.1 → 4.4.1

package/dist/browser/index.js

@@ -1,4 +1,4 @@
-import { Transaction, MessageV0, VersionedTransaction, PublicKey, TransactionInstruction, SystemProgram } from '@solana/web3.js';
+import { VersionedTransaction, Transaction, Keypair, MessageV0, PublicKey, TransactionInstruction, SystemProgram } from '@solana/web3.js';
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -6550,20 +6550,23 @@ function sleep(milliSeconds) {
  * @param feePayer optional fee payer
  * @returns transaction size
  */
-function getTransactionSize(transaction, feePayer) {
-    const clonedTransaction = new Transaction({
-        lastValidBlockHeight: 1234,
-        feePayer: (transaction === null || transaction === void 0 ? void 0 : transaction.feePayer) ||
-            feePayer ||
-            transaction.instructions[0].programId,
-        blockhash: "CSymwgTNX1j3E4qhKfJAUE41nBWEwXufoYryPbkde5RR", // fake blockhash
-    }).add(transaction);
-    const serializedMessage = clonedTransaction.serializeMessage();
-    const uniqueSigners = new Set(clonedTransaction.instructions.flatMap((ix) => ix.keys
-        .filter((meta) => meta.isSigner)
-        .map((meta) => meta.pubkey.toBase58())));
-    // message length + signatures length (1 byte) + signatures count * signature size (64)
-    return serializedMessage.length + uniqueSigners.size * 64 + 1;
+function getTransactionSize(tx) {
+    try {
+        if (isVersionedTx(tx)) {
+            const txCopy = new VersionedTransaction(tx.message);
+            txCopy.message.recentBlockhash = FAKE_BLOCKHASH;
+            return txCopy.serialize().length;
+        }
+        else {
+            const txCopy = new Transaction(tx);
+            txCopy.feePayer = Keypair.generate().publicKey;
+            txCopy.recentBlockhash = FAKE_BLOCKHASH;
+            return tx.serialize({ verifySignatures: false }).length;
+        }
+    }
+    catch (e) {
+        return null;
+    }
 }
 function isVersionedTx(arg) {
     return "version" in arg;
@@ -6596,28 +6599,6 @@ class Wallet {
         });
     }
 }
-function sendWithRetries(connection, serialized, lastValidBlockHeight, timesToSend = 5, blockhashCommitment = "finalized") {
-    return __awaiter(this, void 0, void 0, function* () {
-        const txId = yield connection.sendRawTransaction(serialized, {
-            skipPreflight: false,
-            preflightCommitment: blockhashCommitment,
-            maxRetries: 3,
-        });
-        let blockheight = yield connection.getBlockHeight();
-        let sent = 1;
-        while (blockheight < lastValidBlockHeight && sent < timesToSend) {
-            yield connection.sendRawTransaction(serialized, {
-                skipPreflight: true,
-                preflightCommitment: blockhashCommitment,
-                maxRetries: 5,
-            });
-            yield sleep(300);
-            blockheight = yield connection.getBlockHeight();
-            sent += 1;
-        }
-        return txId;
-    });
-}
 function txToV0(transaction, payer, blockhash) {
     if (isVersionedTx(transaction)) {
         return transaction;
@@ -6694,7 +6675,6 @@ function sendAll(connection, wallet, transactions, options) {
             : options.blockhashCommitment;
         const convertIntoTxV0 = (options === null || options === void 0 ? void 0 : options.convertIntoTxV0) === undefined ? true : options.convertIntoTxV0;
         const skipPreflight = (options === null || options === void 0 ? void 0 : options.skipPreflight) === undefined ? false : options.skipPreflight;
-        const rpcCalls = (options === null || options === void 0 ? void 0 : options.rpcCalls) === undefined ? 3 : options.rpcCalls;
         if (!Array.isArray(transactions))
             transactions = [transactions];
         if (convertIntoTxV0) {
@@ -6705,27 +6685,28 @@ function sendAll(connection, wallet, transactions, options) {
             if (!skipPreflight) {
                 yield Promise.all(transactions.map((tx) => simulateTx(connection, tx, blockhashCommitment, wallet.publicKey, convertIntoTxV0, skipSign)));
             }
-            const { blockhash, lastValidBlockHeight } = yield connection.getLatestBlockhash({ commitment: blockhashCommitment });
+            const blockhashResponse = yield connection.getLatestBlockhashAndContext({ commitment: blockhashCommitment });
             let signed = transactions;
             if (!skipSign) {
                 // set real blockhash
-                transactions.map((tx) => setBlockhash(tx, blockhash));
+                transactions.map((tx) => setBlockhash(tx, blockhashResponse.value.blockhash));
                 // sign after setting correct blockhashes
                 signed = yield wallet.signAllTransactions(transactions, options === null || options === void 0 ? void 0 : options.signers);
             }
             txIds = yield Promise.all(signed.map((signedTx) => {
                 var _a;
-                const serialized = buffer.Buffer.from(signedTx.serialize());
-                (_a = options === null || options === void 0 ? void 0 : options.logger) === null || _a === void 0 ? void 0 : _a.call(options, `Sending tx: ${serialized.toString("base64")}`);
-                return sendWithRetries(connection, serialized, lastValidBlockHeight, rpcCalls, blockhashCommitment);
+                const serialized = buffer.Buffer.from(signedTx.serialize()).toString("base64");
+                (_a = options === null || options === void 0 ? void 0 : options.logger) === null || _a === void 0 ? void 0 : _a.call(options, `Sending tx: ${serialized}`);
+                return connection.sendEncodedTransaction(serialized, {
+                    preflightCommitment: blockhashCommitment,
+                    skipPreflight: false,
+                    minContextSlot: blockhashResponse.context.slot + 1
+                });
             }));
         }
         else {
             for (let i = 0; i < transactions.length; i++) {
                 const tx = transactions[i];
-                const { blockhash, lastValidBlockHeight } = yield connection.getLatestBlockhash({
-                    commitment: blockhashCommitment,
-                });
                 const signed = skipSign
                     ? tx
                     : yield wallet.signTransaction(tx, (options === null || options === void 0 ? void 0 : options.signers) && (options === null || options === void 0 ? void 0 : options.signers.length) > i
@@ -6734,9 +6715,12 @@ function sendAll(connection, wallet, transactions, options) {
                 if (!skipPreflight) {
                     yield simulateTx(connection, tx, blockhashCommitment, wallet.publicKey, convertIntoTxV0, skipSign);
                 }
-                const serialized = buffer.Buffer.from(signed.serialize());
-                (_b = options === null || options === void 0 ? void 0 : options.logger) === null || _b === void 0 ? void 0 : _b.call(options, `Sending tx: ${serialized.toString("base64")}`);
-                txIds.push(yield sendWithRetries(connection, serialized, lastValidBlockHeight, rpcCalls, blockhashCommitment));
+                const serialized = buffer.Buffer.from(signed.serialize()).toString("base64");
+                (_b = options === null || options === void 0 ? void 0 : options.logger) === null || _b === void 0 ? void 0 : _b.call(options, `Sending tx: ${serialized}`);
+                txIds.push(yield connection.sendEncodedTransaction(serialized, {
+                    preflightCommitment: blockhashCommitment,
+                    skipPreflight: false,
+                }));
                 yield sleep(options.waitBetweenSend);
             }
         }
@@ -6978,12 +6962,12 @@ function hashExternalCallBytes(data) {
 function hashSubmissionIdRaw(params) {
     var _a, _b, _c, _d;
     let packParams = [
-        "uint256",
-        "uint256",
-        "uint256",
-        "uint256",
-        "uint256",
-        "bytes",
+        "uint256", // submission prefix
+        "uint256", // bridge_id
+        "uint256", // source_chain_id
+        "uint256", // target_chain_id
+        "uint256", // amount
+        "bytes", // receiver
         "uint256", // nonce
     ];
     const receiver = isBuffer(params.receiver)
@@ -6995,19 +6979,19 @@ function hashSubmissionIdRaw(params) {
             : new PublicKey(params.receiver).toBuffer();
     let packData = [
         SUBMISSION_PREFIX,
-        params.debridgeId,
-        normalizeChainId(params.sourceChainId),
-        normalizeChainId(params.targetChainId),
-        new BN(params.amount).toArray("be", 32),
-        receiver,
+        params.debridgeId, // bridge_id
+        normalizeChainId(params.sourceChainId), // source_chain_id
+        normalizeChainId(params.targetChainId), // target_chain_id
+        new BN(params.amount).toArray("be", 32), // amount
+        receiver, // receiver
         params.nonce, // nonce
     ];
     if (params === null || params === void 0 ? void 0 : params.autoParams) {
         packParams = packParams.concat([
-            "uint256",
-            "uint256",
-            "uint256",
-            "uint256",
+            "uint256", // execution fee
+            "uint256", // flag
+            "uint256", // fallback hash
+            "uint256", // ext call data hash
             "uint256", // native sender hash
         ]);
         const shortcut = ((_a = params.autoParams) === null || _a === void 0 ? void 0 : _a.shortcut)