@debridge-finance/solana-utils 1.0.2 → 2.2.0

package/dist/browser/index.js

@@ -1,4 +1,4 @@
-import { Transaction, Message, VersionedTransaction, MessageV0, sendAndConfirmRawTransaction, PublicKey } from '@solana/web3.js';
+import { Transaction, Message, VersionedTransaction, MessageV0, PublicKey } from '@solana/web3.js';
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -7501,6 +7501,20 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
+function getAccountInfo(connection, account) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const info = yield connection.getAccountInfo(account);
+        if (info) {
+            // alchemy bug fix
+            if (info.lamports === 0 && info.rentEpoch === 0)
+                return null;
+            return info;
+        }
+        else {
+            return null;
+        }
+    });
+}
 function hexToBuffer(data, align) {
     if (!data.startsWith("0x"))
         throw new Error("[hexToBuffer]: string must start with 0x");
@@ -7552,7 +7566,12 @@ class Wallet {
     }
     signTransaction(tx, additionalSigners) {
         return __awaiter(this, void 0, void 0, function* () {
-            tx.sign(this.keypair, ...(additionalSigners || []));
+            if (!isVersionedTx(tx)) {
+                tx.sign(this.keypair, ...(additionalSigners || []));
+            }
+            else {
+                tx.sign([this.keypair, ...(additionalSigners || [])]);
+            }
             return Promise.resolve(tx);
         });
     }
@@ -7565,30 +7584,13 @@ class Wallet {
             return Promise.all(promises);
         });
     }
-    signVersionedTransaction(tx, additionalSigners) {
-        return __awaiter(this, void 0, void 0, function* () {
-            tx.sign([this.keypair, ...(additionalSigners || [])]);
-            return Promise.resolve(tx);
-        });
-    }
-    ;
-    signAllVersionedTransactions(txs, additionalSigners) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const promises = [];
-            for (const [id, tx] of txs.entries()) {
-                promises.push(this.signVersionedTransaction(tx, additionalSigners && additionalSigners.length > id ? additionalSigners[id] : []));
-            }
-            return Promise.all(promises);
-        });
-    }
 }
-function sendWithRetries(connection, serialized, lastValidBlockHeight) {
+function sendWithRetries(connection, serialized, lastValidBlockHeight, timesToSend = 5) {
     return __awaiter(this, void 0, void 0, function* () {
         const txId = yield connection.sendRawTransaction(serialized, {
             skipPreflight: true,
         });
         let blockheight = yield connection.getBlockHeight();
-        const timesToSend = 5;
         let sent = 0;
         while (blockheight < lastValidBlockHeight && sent < timesToSend) {
             yield connection.sendRawTransaction(serialized, {
@@ -7601,40 +7603,31 @@ function sendWithRetries(connection, serialized, lastValidBlockHeight) {
         return txId;
     });
 }
-function sendAll(connection, wallet, transactions, signers, waitBetweenSend, skipPreflight = false, debug = false) {
+function txToV0(transaction, payer, blockhash) {
+    if (isVersionedTx(transaction)) {
+        return transaction;
+    }
+    else {
+        const v0Message = MessageV0.compile({
+            instructions: transaction.instructions,
+            payerKey: transaction.feePayer || payer,
+            recentBlockhash: transaction.recentBlockhash || blockhash,
+        });
+        return new VersionedTransaction(v0Message);
+    }
+}
+function sendAll(connection, wallet, transactions, signers, waitBetweenSend, skipPreflight = false, debug = false, convertIntoTxV0 = true, rpcCalls = 5) {
+    var _a;
     return __awaiter(this, void 0, void 0, function* () {
+        if (convertIntoTxV0) {
+            const fakeBlockHash = "0".repeat(64);
+            transactions = transactions.map((tx) => txToV0(tx, wallet.publicKey, fakeBlockHash));
+        }
         let txIds = [];
-        const signAllTransactions = (txs, additionalSigners) => {
-            const result = [];
-            const txTypes = txs.map(isVersionedTx);
-            if (txTypes.every((isVersioned) => isVersioned === true)) {
-                // all txs are Versioned
-                if (wallet.signAllVersionedTransactions === undefined)
-                    throw new Error("Trying to sign versioned transactions without implementation for sigining such transactions (signAllVersionedTransactions)");
-                return wallet.signAllVersionedTransactions(txs, additionalSigners);
-            }
-            else if (txTypes.every((isVersioned) => isVersioned === false)) {
-                // all txs are Legacy
-                return wallet.signAllTransactions(txs, additionalSigners);
-            }
-            // transactions are mixed
-            if (wallet.signVersionedTransaction === undefined)
-                throw new Error("Trying to sign versioned transaction without implementation for sigining such transaction (signVersionedTransaction)");
-            for (const [i, tx] of txs.entries()) {
-                const signers = additionalSigners && additionalSigners.length > i ? additionalSigners[i] : undefined;
-                if (isVersionedTx(tx)) {
-                    result.push(wallet.signVersionedTransaction(tx, signers));
-                }
-                else {
-                    result.push(wallet.signTransaction(tx, signers));
-                }
-            }
-            return Promise.all(result);
-        };
         if (waitBetweenSend === undefined || waitBetweenSend === 0) {
             const { blockhash, lastValidBlockHeight } = yield connection.getLatestBlockhash({ commitment: "confirmed" });
             yield Promise.all(transactions.map((tx) => __awaiter(this, void 0, void 0, function* () {
-                var _a;
+                var _b;
                 let txV0;
                 if (isVersionedTx(tx)) {
                     tx.message.recentBlockhash = blockhash;
@@ -7649,39 +7642,45 @@ function sendAll(connection, wallet, transactions, signers, waitBetweenSend, ski
                 if (!skipPreflight) {
                     const simulationResult = yield connection.simulateTransaction(txV0, { sigVerify: false, replaceRecentBlockhash: true, commitment: "confirmed" });
                     if (simulationResult.value.err !== null) {
-                        throw new Error(`Tx simulation Error! Transaction message dump: ${buffer.Buffer.from(tx.serialize()).toString("base64")}\n Error: ${JSON.stringify(simulationResult.value.err)}, logs:\n ${(_a = simulationResult.value.logs) === null || _a === void 0 ? void 0 : _a.join("\n")}`);
+                        throw new Error(`Tx simulation Error! Transaction message dump: ${buffer.Buffer.from(tx.serialize()).toString("base64")}\n Error: ${JSON.stringify(simulationResult.value.err)}, logs:\n ${(_b = simulationResult.value.logs) === null || _b === void 0 ? void 0 : _b.join("\n")}`);
                     }
                 }
             })));
             // sign after setting correct blockhashes
-            const signed = yield signAllTransactions(transactions, signers);
+            const signed = yield wallet.signAllTransactions(transactions, signers);
             txIds = yield Promise.all(signed.map((signedTx) => {
                 const serialized = buffer.Buffer.from(signedTx.serialize());
                 if (debug)
                     console.debug(serialized.toString("base64"));
-                return sendWithRetries(connection, serialized, lastValidBlockHeight);
+                return sendWithRetries(connection, serialized, lastValidBlockHeight, rpcCalls);
             }));
         }
         else {
             for (let i = 0; i < transactions.length; i++) {
                 const tx = transactions[i];
-                const { blockhash } = yield connection.getLatestBlockhash();
-                let signed;
+                const { blockhash, lastValidBlockHeight } = yield connection.getLatestBlockhash();
+                let txV0;
                 if (isVersionedTx(tx)) {
                     tx.message.recentBlockhash = blockhash;
-                    if (wallet.signVersionedTransaction === undefined)
-                        throw new Error("Trying to sign versioned transaction without implementation for sigining such transaction (signVersionedTransaction)");
-                    signed = yield wallet.signVersionedTransaction(tx, signers && signers.length > i ? signers[i] : undefined);
+                    txV0 = tx;
                 }
                 else {
                     tx.recentBlockhash = blockhash;
                     tx.feePayer = wallet.publicKey;
-                    signed = yield wallet.signTransaction(tx, signers && signers.length > i ? signers[i] : undefined);
+                    const message = Message.from(tx.serializeMessage());
+                    txV0 = new VersionedTransaction(new MessageV0({ addressTableLookups: [], compiledInstructions: [], header: message.header, recentBlockhash: blockhash, staticAccountKeys: message.accountKeys }));
+                }
+                const signed = yield wallet.signTransaction(tx, signers && signers.length > i ? signers[i] : undefined);
+                if (!skipPreflight) {
+                    const simulationResult = yield connection.simulateTransaction(txV0, { sigVerify: false, replaceRecentBlockhash: true, commitment: "confirmed" });
+                    if (simulationResult.value.err !== null) {
+                        throw new Error(`Tx simulation Error! Transaction message dump: ${buffer.Buffer.from(tx.serialize()).toString("base64")}\n Error: ${JSON.stringify(simulationResult.value.err)}, logs:\n ${(_a = simulationResult.value.logs) === null || _a === void 0 ? void 0 : _a.join("\n")}`);
+                    }
                 }
                 const serialized = buffer.Buffer.from(signed.serialize());
                 if (debug)
                     console.debug(serialized.toString("base64"));
-                txIds.push(yield sendAndConfirmRawTransaction(connection, serialized, { maxRetries: 20, commitment: "confirmed", skipPreflight }));
+                txIds.push(yield sendWithRetries(connection, serialized, lastValidBlockHeight, rpcCalls));
                 yield sleep(waitBetweenSend);
             }
         }
@@ -7691,6 +7690,7 @@ function sendAll(connection, wallet, transactions, signers, waitBetweenSend, ski
 
 var helpers = /*#__PURE__*/Object.freeze({
 	__proto__: null,
+	getAccountInfo: getAccountInfo,
 	hexToBuffer: hexToBuffer,
 	bufferToHex: bufferToHex,
 	sleep: sleep,