@hawksightco/hawk-sdk 1.3.265 → 1.3.267

package/dist/classes/TransactionBatchExecute2.js

@@ -0,0 +1,357 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionBatchExecute2 = void 0;
+const web3 = __importStar(require("@solana/web3.js"));
+const TransactionBatchExecute_1 = require("./TransactionBatchExecute");
+const MultiTransaction_1 = require("./MultiTransaction");
+const functions_1 = require("../functions");
+/**
+ * Executes transactions in batches
+ */
+class TransactionBatchExecute2 extends TransactionBatchExecute_1.TransactionBatchExecute {
+    /**
+     * Creates an instance of TransactionExecute class
+     *
+     * @param lookupTableAddresses Address lookup table addresses to be used by batch of transactions
+     * @param instructions Array of instructions to be batched into transactions
+     * @param payer Payer that will pay for the batch of transactions
+     * @param connection Connection to mainnet
+     */
+    constructor(lookupTableAddresses, instructions, connection, createTxMetadataInstance, latestBlockhash, payerKey) {
+        super(lookupTableAddresses, instructions, new web3.Keypair(), // unused
+        connection, []);
+        this.lookupTableAddresses = lookupTableAddresses;
+        this.instructions = instructions;
+        this.connection = connection;
+        this.createTxMetadataInstance = createTxMetadataInstance;
+        this.latestBlockhash = latestBlockhash;
+        this.payerKey = payerKey;
+        this._insertNonceAt = {};
+    }
+    ;
+    /**
+     * Download all jupiter alts (overridable)
+     */
+    jupiterDownloadAlts() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    /**
+     * Find alt by pubkeys (overridable)
+     */
+    jupiterFindAltByPubkeys(pubkeys) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _a.jupiterFindAltByPubkeysFn(pubkeys);
+        });
+    }
+    /**
+     * Downoad address lookup table from given cluster
+     */
+    downloadAlts2(lookupTableAddresses) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pubkeyStr = lookupTableAddresses.map(pubkey => pubkey.toString());
+            const alts = yield this.createTxMetadataInstance.stringToAlt(pubkeyStr);
+            this.alts.push(...alts);
+        });
+    }
+    /**
+     * Option to include nonce advance instruction
+     *
+     * @param opt
+     */
+    insertNonceAt(opt) {
+        this._insertNonceAt = opt;
+    }
+    /**
+     * Builds a batch of executable transaction instructions
+     */
+    buildBatch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Download address lookup table from given cluster
+            yield this.downloadAlts();
+            // Generate dummy instructions for batch calculation
+            const [simulationIxs, dummySigners] = this.generateSimulationIxs();
+            // Split simulation ixs
+            const dummyBatches = yield this.splitToTransactions(simulationIxs, dummySigners);
+            // Batch of actual instructions
+            const batch = [];
+            let index = 0;
+            let i = 0;
+            const lastIndex = dummyBatches.length - 1;
+            for (const dummyIxs of dummyBatches) {
+                const isLastIndex = i == lastIndex;
+                const currentBatch = [];
+                for (const ix of dummyIxs) {
+                    // If program id is compute budget, ignore
+                    if (ix.programId.equals(web3.ComputeBudgetProgram.programId))
+                        continue;
+                    // Otherwise, include in batch
+                    currentBatch.push(this.instructions[index++]);
+                }
+                if (isLastIndex && this._insertNonceAt.onlyEndOfTx) {
+                    currentBatch.push(yield this.generateNonceAdvanceIx(i));
+                }
+                batch.push(currentBatch);
+                i++;
+            }
+            return batch;
+        });
+    }
+    /**
+     * Builds a batch of executable transaction instructions
+     */
+    buildBatchWithAlts(description, generalUtility) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Download address lookup table from given cluster
+            yield this.downloadAlts();
+            // Generate dummy instructions for batch calculation
+            const [simulationIxs, dummySigners] = this.generateSimulationIxs();
+            // Split simulation ixs
+            const dummyBatches = yield this.splitToTransactions(simulationIxs, dummySigners);
+            // Batch of actual instructions
+            const batch = new MultiTransaction_1.MultiTransaction(description, generalUtility, this.latestBlockhash, this.payerKey);
+            let index = 0;
+            let i = 0;
+            const lastIndex = dummyBatches.length - 1;
+            for (const dummyIxs of dummyBatches) {
+                const isLastIndex = i == lastIndex;
+                const currentBatch = [];
+                for (const ix of dummyIxs) {
+                    // If program id is compute budget, ignore
+                    if (ix.programId.equals(web3.ComputeBudgetProgram.programId))
+                        continue;
+                    // Otherwise, include in batch
+                    currentBatch.push(this.instructions[index++]);
+                }
+                if (lastIndex !== 0 && isLastIndex && this._insertNonceAt.onlyEndOfTx) {
+                    currentBatch.push(yield this.generateNonceAdvanceIx(i));
+                }
+                const alts = this.findRequiredAltsForBatch2(currentBatch);
+                batch.push(alts, currentBatch);
+                i++;
+            }
+            return batch;
+        });
+    }
+    /**
+     * Split transactions
+     *
+     * @param simulationIxs
+     * @param dummySigners
+     * @returns
+     */
+    splitToTransactions(simulationIxs, dummySigners) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Create dummy priority fee instructions for the transaction (to account for total tx size)
+            const preIxs = [
+                web3.ComputeBudgetProgram.setComputeUnitLimit({
+                    units: 1400000, // dummy value
+                }),
+                web3.ComputeBudgetProgram.setComputeUnitPrice({
+                    microLamports: 1000000, // dummy value
+                }),
+            ];
+            // Run simulation
+            let batch = [];
+            let result = [];
+            for (const ix of simulationIxs) {
+                // Include dummy ix to transaction
+                batch.push(ix);
+                // Calculate transaction size
+                try {
+                    const estimateTxSize = this.getEstimateSize([...preIxs, ...batch]);
+                    if (estimateTxSize < this.MAX_SIZE)
+                        continue;
+                    // Generate dummy nonce advance (anticipation)
+                    const nonceAdvance = this._insertNonceAt.onlyEndOfTx ? [yield this.generateNonceAdvanceIx(result.length)] : [];
+                    const txSize = this.calculateTransactionSize(this.latestBlockhash, [...preIxs, ...nonceAdvance, ...batch], dummySigners);
+                    if (txSize > this.MAX_SIZE) {
+                        batch.pop();
+                        result.push([...preIxs, ...batch]);
+                        batch = [ix];
+                    }
+                }
+                catch (_b) {
+                    batch.pop();
+                    result.push([...preIxs, ...batch]);
+                    batch = [ix];
+                }
+            }
+            if (batch.length > 0 && simulationIxs.length !== 0) {
+                result.push([...preIxs, ...batch]);
+            }
+            return result;
+        });
+    }
+    /**
+     * Generate nonde advance instruction (dummy instruction)
+     */
+    generateNonceAdvanceIx(index) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const noncePubkey = yield (0, functions_1.generateNonceAddressFromIndex)(this.payerKey, index);
+            // Generate dummy nonce ix
+            return web3.SystemProgram.nonceAdvance({
+                /** Nonce account */
+                noncePubkey,
+                /** Public key of the nonce authority */
+                authorizedPubkey: this.payerKey,
+            });
+        });
+    }
+    getEstimateSize(ixs) {
+        let length = 0;
+        const alts = {};
+        ixs.map(ix => {
+            length += ix.data.length + ix.programId.toBuffer().length;
+            ix.keys.map(meta => {
+                const alt = this.pubkeyToAlt[meta.pubkey.toString()];
+                if (!!alt) {
+                    alts[alt.key.toString()] = alt;
+                    length += 3;
+                }
+                else {
+                    length += 34;
+                }
+            });
+        });
+        for (const _ in alts) {
+            length += 32;
+        }
+        return length;
+    }
+    /**
+     * Find required signers from instructions
+     *
+     * @param ixs
+     * @param dummySigners
+     */
+    findRequiredSignersFromIxs(ixs) {
+        const signers = [];
+        signers.push(this.payerKey);
+        for (const instruction of ixs) {
+            const _signers = instruction.keys
+                .filter(meta => meta.isSigner)
+                .map(meta => meta.pubkey);
+            if (_signers.length > 0) {
+                signers.push(..._signers);
+            }
+        }
+        const uniqueSigners = {};
+        for (const signer of signers) {
+            uniqueSigners[signer.toBase58()] = signer;
+        }
+        const result = [];
+        for (const id in uniqueSigners) {
+            result.push(uniqueSigners[id]);
+        }
+        return result;
+    }
+    /**
+     * Calculate transaction size
+     *
+     * @param batch
+     */
+    calculateTransactionSize(latestBlockhash, batch, dummySigners) {
+        const alts = this.findRequiredAltsForBatch2(batch);
+        const messageV0 = new web3.TransactionMessage({
+            payerKey: dummySigners[this.payerKey.toString()].publicKey,
+            instructions: batch,
+            recentBlockhash: latestBlockhash.blockhash,
+        }).compileToV0Message(alts);
+        const versionedTx = new web3.VersionedTransaction(messageV0);
+        const signers = this.findRequiredSignersFromBatch2(batch, dummySigners);
+        versionedTx.sign(signers);
+        const bytes = versionedTx.serialize();
+        return bytes.length;
+    }
+    /**
+     * Find required address lookup table addresses for given batch of instructions
+     *
+     * @param batch
+     */
+    findRequiredAltsForBatch2(batch) {
+        const pubkeys = [];
+        batch.map(ix => {
+            pubkeys.push(...ix.keys.map(meta => meta.pubkey));
+        });
+        const alts = {};
+        for (const pubkey of pubkeys) {
+            const alt = this.pubkeyToAlt[pubkey.toString()];
+            if (!!alt) {
+                alts[alt.key.toString()] = alt;
+            }
+        }
+        const result = [];
+        for (const key in alts) {
+            result.push(alts[key]);
+        }
+        return result;
+    }
+    /**
+     * Find required signers from batch
+     *
+     * @param ixs
+     * @param dummySigners
+     */
+    findRequiredSignersFromBatch2(batch, dummySigners) {
+        const signers = this.findRequiredSignersFromIxs(batch);
+        const result = [];
+        for (const signer of signers) {
+            const key = signer.toString();
+            result.push(dummySigners[key]);
+        }
+        return result;
+    }
+}
+exports.TransactionBatchExecute2 = TransactionBatchExecute2;
+_a = TransactionBatchExecute2;
+/**
+ * Find alt by pubkeys (overridable)
+ *
+ * @param pubkeys
+ */
+TransactionBatchExecute2.jupiterFindAltByPubkeysFn = () => __awaiter(void 0, void 0, void 0, function* () {
+    return [];
+});