@symmetry-hq/sdk 1.0.1

package/dist/src/states/withdrawBasketFees.js

@@ -0,0 +1,154 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addFieldsToWithdrawBasketFees = addFieldsToWithdrawBasketFees;
+exports.fetchWithdrawBasketFees = fetchWithdrawBasketFees;
+exports.fetchWithdrawBasketFeesMultiple = fetchWithdrawBasketFeesMultiple;
+exports.fetchWithdrawBasketFeesList = fetchWithdrawBasketFeesList;
+const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("../constants");
+const basket_1 = require("../layouts/basket");
+const txUtils_1 = require("../txUtils");
+function addFieldsToWithdrawBasketFees(withdrawBasketFees) {
+    // Filter out default/empty owners
+    let numOwners = constants_1.MAX_MANAGERS_PER_BASKET;
+    while (numOwners > 0 && withdrawBasketFees.owners[numOwners - 1].equals(web3_js_1.PublicKey.default)) {
+        numOwners--;
+    }
+    withdrawBasketFees.owners = withdrawBasketFees.owners.slice(0, numOwners);
+    withdrawBasketFees.ownersWeights = withdrawBasketFees.ownersWeights.slice(0, numOwners);
+    // Filter out default/empty tokens
+    let numTokens = constants_1.MAX_SUPPORTED_TOKENS_PER_BASKET;
+    while (numTokens > 0 && withdrawBasketFees.accumulatedTokens[numTokens - 1].equals(web3_js_1.PublicKey.default)) {
+        numTokens--;
+    }
+    withdrawBasketFees.accumulatedTokens = withdrawBasketFees.accumulatedTokens.slice(0, numTokens);
+    withdrawBasketFees.accumulatedFees = withdrawBasketFees.accumulatedFees.slice(0, numTokens);
+    let formatted = {
+        pubkey: withdrawBasketFees.ownAddress.toBase58(),
+        basket: withdrawBasketFees.basket.toBase58(),
+        rent_payer: withdrawBasketFees.rentPayer.toBase58(),
+        owners: withdrawBasketFees.owners.map(owner => owner.toBase58()),
+        owners_weights: withdrawBasketFees.ownersWeights,
+        accumulated_tokens: withdrawBasketFees.accumulatedTokens.map(token => token.toBase58()),
+        accumulated_fees: withdrawBasketFees.accumulatedFees.map(fee => parseInt(fee.toString())),
+    };
+    withdrawBasketFees.formatted = formatted;
+    return withdrawBasketFees;
+}
+function fetchWithdrawBasketFees(connection, withdrawBasketFeesAddress) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const accountInfo = yield connection.getAccountInfo(withdrawBasketFeesAddress);
+        if (!accountInfo)
+            throw new Error("WithdrawBasketFees account not found");
+        let withdrawBasketFees = basket_1.WithdrawBasketFeesLayout.decode(accountInfo.data.slice(8));
+        withdrawBasketFees.ownAddress = withdrawBasketFeesAddress;
+        withdrawBasketFees = addFieldsToWithdrawBasketFees(withdrawBasketFees);
+        return withdrawBasketFees;
+    });
+}
+function fetchWithdrawBasketFeesMultiple(connection, withdrawBasketFeesAddresses) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let multipleAccountsInfo = yield (0, txUtils_1.getMultipleAccountsInfoBatched)(connection, withdrawBasketFeesAddresses);
+        let withdrawBasketFeesList = withdrawBasketFeesAddresses.map(address => {
+            let ai = multipleAccountsInfo.get(address.toBase58());
+            if (!ai)
+                return null;
+            let withdrawBasketFees = Object.assign(Object.assign({}, basket_1.WithdrawBasketFeesLayout.decode(ai.data.slice(8))), { ownAddress: address });
+            withdrawBasketFees = addFieldsToWithdrawBasketFees(withdrawBasketFees);
+            return withdrawBasketFees;
+        }).filter((item) => item !== null);
+        let withdrawBasketFeesMap = new Map();
+        for (let withdrawBasketFees of withdrawBasketFeesList) {
+            withdrawBasketFeesMap.set(withdrawBasketFees.ownAddress.toBase58(), withdrawBasketFees);
+        }
+        return withdrawBasketFeesMap;
+    });
+}
+function fetchWithdrawBasketFeesList(connection, filter) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const MANAGERS_ARRAY_OFFSET = 8 + 32 + 32;
+        const MANAGER_PUBKEY_SIZE = 32;
+        if ((filter === null || filter === void 0 ? void 0 : filter.type) === "manager") {
+            try {
+                const managerPubkey = new web3_js_1.PublicKey(filter.pubkey);
+                const managerBytes = Buffer.from(managerPubkey.toBytes());
+                const managerSliceLength = constants_1.MAX_MANAGERS_PER_BASKET * MANAGER_PUBKEY_SIZE;
+                // Request only manager bytes for each basket (single GPA), then filter locally.
+                const managerSlices = yield connection.getProgramAccounts(constants_1.BASKETS_V3_PROGRAM_ID, {
+                    commitment: "confirmed",
+                    filters: [{ dataSize: 8 + basket_1.WithdrawBasketFeesLayout.getSpan() }],
+                    dataSlice: {
+                        offset: MANAGERS_ARRAY_OFFSET,
+                        length: managerSliceLength,
+                    },
+                    encoding: 'base64',
+                });
+                const matchedPubkeys = [];
+                for (const basketAccount of managerSlices) {
+                    const managersData = basketAccount.account.data;
+                    for (let i = 0; i < constants_1.MAX_MANAGERS_PER_BASKET; i++) {
+                        const start = i * MANAGER_PUBKEY_SIZE;
+                        const end = start + MANAGER_PUBKEY_SIZE;
+                        if (managersData.subarray(start, end).equals(managerBytes)) {
+                            matchedPubkeys.push(basketAccount.pubkey);
+                            break;
+                        }
+                    }
+                }
+                if (matchedPubkeys.length === 0)
+                    return [];
+                const matchedAccountsInfo = yield (0, txUtils_1.getMultipleAccountsInfoBatched)(connection, matchedPubkeys);
+                let withdrawBasketFeesList = [];
+                for (let pubkey of matchedPubkeys) {
+                    const accountInfo = matchedAccountsInfo.get(pubkey.toBase58());
+                    if (!accountInfo)
+                        continue;
+                    let withdrawBasketFees = basket_1.WithdrawBasketFeesLayout.decode(accountInfo.data.slice(8));
+                    withdrawBasketFees.ownAddress = pubkey;
+                    withdrawBasketFees = addFieldsToWithdrawBasketFees(withdrawBasketFees);
+                    withdrawBasketFeesList.push(withdrawBasketFees);
+                }
+                return withdrawBasketFeesList;
+            }
+            catch (error) {
+                // Fallback for RPC providers that might not support/serve this path reliably.
+            }
+        }
+        let filters = [{ dataSize: 8 + basket_1.WithdrawBasketFeesLayout.getSpan() }];
+        if ((filter === null || filter === void 0 ? void 0 : filter.type) === "creator" || (filter === null || filter === void 0 ? void 0 : filter.type) === "host" || (filter === null || filter === void 0 ? void 0 : filter.type) === "symmetry")
+            filters.push({
+                memcmp: {
+                    offset: 8 + 32 + 32,
+                    bytes: filter.pubkey
+                }
+            });
+        if ((filter === null || filter === void 0 ? void 0 : filter.type) === "basket")
+            filters.push({
+                memcmp: {
+                    offset: 8,
+                    bytes: filter.pubkey
+                }
+            });
+        let results = yield connection.getProgramAccounts(constants_1.BASKETS_V3_PROGRAM_ID, {
+            commitment: "confirmed",
+            filters: filters,
+            encoding: 'base64'
+        });
+        let withdrawBasketFeesList = results.map(account => {
+            let withdrawBasketFees = basket_1.WithdrawBasketFeesLayout.decode(account.account.data.slice(8));
+            withdrawBasketFees.ownAddress = account.pubkey;
+            withdrawBasketFees = addFieldsToWithdrawBasketFees(withdrawBasketFees);
+            return withdrawBasketFees;
+        });
+        return withdrawBasketFeesList;
+    });
+}

package/dist/src/txUtils.d.ts

@@ -0,0 +1,65 @@
+import { AccountInfo, Transaction } from '@solana/web3.js';
+import { AddressLookupTableAccount, Connection, Keypair, PublicKey, TransactionInstruction, VersionedTransaction } from '@solana/web3.js';
+type TransactionSignature = string;
+export interface Wallet {
+    signTransaction<T extends Transaction | VersionedTransaction>(tx: T): Promise<T>;
+    signAllTransactions<T extends Transaction | VersionedTransaction>(txs: T[]): Promise<T[]>;
+    publicKey: PublicKey;
+    /** Keypair of the configured payer (Node only) */
+    payer?: Keypair;
+}
+export declare function wrapWsolIxs(connection: Connection, wallet: PublicKey, amount: number): Promise<TransactionInstruction[]>;
+export interface TxData {
+    payer: PublicKey;
+    instructions: TransactionInstruction[];
+    lookupTables: PublicKey[];
+}
+export interface TxBatchData {
+    batches: TxData[][];
+}
+export interface VersionedTxs {
+    blockhash: string;
+    lastValidBlockHeight: number;
+    batches: VersionedTransaction[][];
+}
+export interface TxPayloadIxAccountMeta {
+    pubkey: string;
+    is_signer: boolean;
+    is_writable: boolean;
+}
+export interface TxPayloadIx {
+    program_id: string;
+    accounts: TxPayloadIxAccountMeta[];
+    data: string;
+}
+export interface TxPayload {
+    tx_b64: string;
+    message_version: "0" | "legacy";
+    recent_blockhash: string;
+    payer: string;
+    lookup_tables: string[];
+    instructions: TxPayloadIx[];
+}
+export interface TxPayloadBatch {
+    transactions: TxPayload[];
+}
+export interface TxPayloadBatchSequence {
+    batches: TxPayloadBatch[];
+}
+export interface BasketCreationTx extends TxPayloadBatchSequence {
+    mint: string;
+    basket: string;
+}
+export declare function prepareTxPayloadBatchSequence(txBatchData: TxBatchData, versionedTxs?: VersionedTxs): TxPayloadBatchSequence;
+export declare function delay(ms: number): Promise<void>;
+export declare function getMultipleAccountsInfoBatched(connection: Connection, pubkeys: PublicKey[]): Promise<Map<string, AccountInfo<Buffer> | null>>;
+export declare function getAddressLookupTableAccounts(connection: Connection, keys: PublicKey[]): Promise<Map<string, AddressLookupTableAccount>>;
+export declare function getMultipleAddressLookupTableAccounts(connection: Connection, batches: PublicKey[][][]): Promise<AddressLookupTableAccount[][][]>;
+export declare function compileVersionedTransaction(blockhash: string, addressLookupTableAccounts: AddressLookupTableAccount[], payerPubkey: PublicKey, ixs: TransactionInstruction[]): VersionedTransaction;
+export declare function sendVersionedTransaction(connection: Connection, tx: VersionedTransaction, blockhash: string, lastValidBlockHeight: number, simulateTransactions: boolean): Promise<TransactionSignature>;
+export declare function prepareVersionedTxs(connection: Connection, txBatchData: TxBatchData): Promise<VersionedTxs>;
+export declare function sendVersionedTxs(connection: Connection, versionedTxs: VersionedTxs, simulateTransactions?: boolean): Promise<TransactionSignature[][]>;
+export declare function signVersionedTxs(wallet: Wallet, versionedTxs: VersionedTxs): Promise<VersionedTxs>;
+export declare function signTxPayloadBatchSequence(wallet: Wallet, txPayloadBatchSequence: TxPayloadBatchSequence): Promise<TxPayloadBatchSequence>;
+export declare function sendTxPayloadBatchSequence(connection: Connection, txPayloadBatchSequence: TxPayloadBatchSequence, simulateTransactions?: boolean): Promise<TransactionSignature[][]>;
+export {};

package/dist/src/txUtils.js

@@ -0,0 +1,306 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapWsolIxs = wrapWsolIxs;
+exports.prepareTxPayloadBatchSequence = prepareTxPayloadBatchSequence;
+exports.delay = delay;
+exports.getMultipleAccountsInfoBatched = getMultipleAccountsInfoBatched;
+exports.getAddressLookupTableAccounts = getAddressLookupTableAccounts;
+exports.getMultipleAddressLookupTableAccounts = getMultipleAddressLookupTableAccounts;
+exports.compileVersionedTransaction = compileVersionedTransaction;
+exports.sendVersionedTransaction = sendVersionedTransaction;
+exports.prepareVersionedTxs = prepareVersionedTxs;
+exports.sendVersionedTxs = sendVersionedTxs;
+exports.signVersionedTxs = signVersionedTxs;
+exports.signTxPayloadBatchSequence = signTxPayloadBatchSequence;
+exports.sendTxPayloadBatchSequence = sendTxPayloadBatchSequence;
+const web3_js_1 = require("@solana/web3.js");
+const web3_js_2 = require("@solana/web3.js");
+const pda_1 = require("./instructions/pda");
+const constants_1 = require("./constants");
+const spl_token_1 = require("@solana/spl-token");
+function wrapWsolIxs(connection, wallet, amount) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (amount == 0)
+            return [];
+        let wsolIxs = [];
+        let wsolAta = (0, pda_1.getAta)(wallet, constants_1.MINTS["mainnet"].WSOL);
+        let wsolBalance = 0;
+        let accountExists = false;
+        try {
+            let info = yield connection.getTokenAccountBalance(wsolAta);
+            wsolBalance = parseInt(info.value.amount);
+            accountExists = wsolBalance >= 0;
+        }
+        catch (_a) { }
+        if (!accountExists)
+            wsolIxs.push((0, spl_token_1.createAssociatedTokenAccountIdempotentInstruction)(wallet, wsolAta, wallet, constants_1.MINTS["mainnet"].WSOL));
+        if (wsolBalance < amount)
+            wsolIxs.push(web3_js_1.SystemProgram.transfer({
+                fromPubkey: wallet,
+                toPubkey: wsolAta,
+                lamports: amount - wsolBalance,
+            }), (0, spl_token_1.createSyncNativeInstruction)(wsolAta));
+        return wsolIxs;
+    });
+}
+function prepareTxPayloadBatchSequence(txBatchData, versionedTxs) {
+    return {
+        batches: txBatchData.batches.map((txDatas, i) => {
+            return {
+                transactions: txDatas.map((txData, j) => {
+                    return {
+                        tx_b64: versionedTxs ? Buffer.from(versionedTxs.batches[i][j].serialize()).toString('base64') : "",
+                        message_version: versionedTxs ? (versionedTxs.batches[i][j].message.version == 0 ? "0" : "legacy") : "0",
+                        recent_blockhash: versionedTxs ? versionedTxs.batches[i][j].message.recentBlockhash : "",
+                        payer: txData.payer.toBase58(),
+                        lookup_tables: txData.lookupTables.map(lookupTable => lookupTable.toBase58()),
+                        instructions: txData.instructions.map(instruction => ({
+                            program_id: instruction.programId.toBase58(),
+                            accounts: instruction.keys.map(account => ({
+                                pubkey: account.pubkey.toBase58(),
+                                is_signer: account.isSigner,
+                                is_writable: account.isWritable,
+                            })),
+                            data: instruction.data.toString('base64'),
+                        }))
+                    };
+                })
+            };
+        }),
+    };
+}
+function delay(ms) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    });
+}
+function getMultipleAccountsInfoBatched(connection, pubkeys) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let uniquePubkeys = [];
+        for (const pubkey of pubkeys) {
+            if (uniquePubkeys.find(x => x.equals(pubkey)) === undefined) {
+                uniquePubkeys.push(pubkey);
+            }
+        }
+        let chunkSize = 100;
+        let promises = [];
+        for (let i = 0; i < uniquePubkeys.length; i += chunkSize) {
+            let chunk = uniquePubkeys.slice(i, i + chunkSize);
+            promises.push(connection.getMultipleAccountsInfo(chunk, "confirmed"));
+        }
+        let resolve = yield Promise.all(promises);
+        let infos = [];
+        resolve.forEach(result => {
+            infos.push(...result);
+        });
+        let allResults = new Map();
+        infos.forEach((info, idx) => {
+            allResults.set(uniquePubkeys[idx].toBase58(), info);
+        });
+        return allResults;
+    });
+}
+function getAddressLookupTableAccounts(connection, keys) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const addressLookupTableAccountInfos = yield getMultipleAccountsInfoBatched(connection, keys);
+        let addressLookupTableAccounts = new Map();
+        for (const key of keys) {
+            const accountInfo = addressLookupTableAccountInfos.get(key.toBase58());
+            if (!key.equals(web3_js_2.PublicKey.default) && accountInfo) {
+                const addressLookupTableAccount = new web3_js_2.AddressLookupTableAccount({
+                    key: new web3_js_2.PublicKey(key),
+                    state: web3_js_2.AddressLookupTableAccount.deserialize(accountInfo.data),
+                });
+                addressLookupTableAccounts.set(key.toBase58(), addressLookupTableAccount);
+            }
+        }
+        return addressLookupTableAccounts;
+    });
+}
+;
+function getMultipleAddressLookupTableAccounts(connection, batches) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let allLuts = [];
+        batches.forEach(batch => batch.forEach(luts => luts.forEach(lut => allLuts.push(lut))));
+        let addressLookupTableAccounts = yield getAddressLookupTableAccounts(connection, allLuts);
+        let result = [];
+        for (const batch of batches) {
+            let batchLuts = [];
+            for (const luts of batch) {
+                let batchLut = [];
+                for (const lut of luts) {
+                    batchLut.push(addressLookupTableAccounts.get(lut.toBase58()));
+                }
+                batchLuts.push(batchLut);
+            }
+            result.push(batchLuts);
+        }
+        return result;
+    });
+}
+function compileVersionedTransaction(blockhash, addressLookupTableAccounts, payerPubkey, ixs) {
+    const txMessage = new web3_js_2.TransactionMessage({
+        payerKey: payerPubkey,
+        recentBlockhash: blockhash,
+        instructions: ixs,
+    });
+    let versionedTx = new web3_js_2.VersionedTransaction(txMessage.compileToV0Message(addressLookupTableAccounts));
+    try {
+        let tt = versionedTx.serialize().length;
+        if (tt > 1232) {
+            throw new Error("Transaction too large");
+        }
+    }
+    catch (e) {
+        throw new Error(e.message);
+    }
+    return versionedTx;
+}
+function sendVersionedTransaction(connection, tx, blockhash, lastValidBlockHeight, simulateTransactions) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const serializedTx = tx.serialize();
+        let txId;
+        if (simulateTransactions) {
+            txId = yield connection.sendRawTransaction(serializedTx, { preflightCommitment: "confirmed", maxRetries: 0 }).catch(e => {
+                console.log(e.message);
+                throw new Error("Simulation failed");
+            });
+            for (let i = 0; i < 4; i++) {
+                yield delay(3000).then(() => connection.sendRawTransaction(serializedTx, { preflightCommitment: "confirmed", maxRetries: 0 }).catch(() => { }));
+            }
+            console.log("Simulation txId:", txId);
+        }
+        else {
+            txId = yield connection.sendRawTransaction(serializedTx, { skipPreflight: true, maxRetries: 0 });
+            for (let i = 0; i < 4; i++) {
+                yield delay(3000).then(() => connection.sendRawTransaction(serializedTx, { preflightCommitment: "confirmed", maxRetries: 0 }).catch(() => { }));
+            }
+            console.log("Sending tx:", txId);
+        }
+        let confirmation = null;
+        let result = null;
+        connection.confirmTransaction({
+            blockhash,
+            lastValidBlockHeight,
+            signature: txId,
+        }, "confirmed").catch(() => null).then((res) => confirmation = res);
+        let iterations = 10;
+        while (confirmation === null && result === null && iterations > 0) {
+            yield delay(1000);
+            result = yield connection.getTransaction(txId, {
+                commitment: "confirmed",
+                maxSupportedTransactionVersion: 0,
+            }).catch(() => null);
+            if (result && result.meta && ((_a = result.meta) === null || _a === void 0 ? void 0 : _a.err)) {
+                console.log(result.meta.err);
+                throw new Error(txId);
+            }
+            iterations--;
+        }
+        if (result)
+            return txId;
+        //@ts-ignore
+        if (!confirmation || confirmation.value.err) {
+            //@ts-ignore
+            console.log(confirmation === null || confirmation === void 0 ? void 0 : confirmation.value.err);
+            throw new Error(txId);
+        }
+        return txId;
+    });
+}
+function prepareVersionedTxs(connection, txBatchData) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { batches } = txBatchData;
+        const { blockhash, lastValidBlockHeight } = yield connection.getLatestBlockhash("confirmed");
+        let multipleLookupTableAddresses = batches.map(batch => batch.map(txData => txData.lookupTables));
+        const multipleAddressLookupTableAccounts = yield getMultipleAddressLookupTableAccounts(connection, multipleLookupTableAddresses);
+        const batchTxs = batches.map((batch, batchIndex) => {
+            const txs = batch.map((txData, txIndex) => {
+                let tx = null;
+                try {
+                    tx = compileVersionedTransaction(blockhash, multipleAddressLookupTableAccounts[batchIndex][txIndex], txData.payer, txData.instructions);
+                }
+                catch (e) {
+                    console.log("Error signing tx:", e.message);
+                }
+                return tx;
+            }).filter(tx => tx !== null);
+            return txs;
+        });
+        return {
+            blockhash,
+            lastValidBlockHeight,
+            batches: batchTxs,
+        };
+    });
+}
+function sendVersionedTxs(connection_1, versionedTxs_1) {
+    return __awaiter(this, arguments, void 0, function* (connection, versionedTxs, simulateTransactions = false) {
+        const { batches, blockhash, lastValidBlockHeight } = versionedTxs;
+        let batchTxIds = [];
+        for (const batch of batches) {
+            let txIds = yield Promise.all(batch.map(tx => sendVersionedTransaction(connection, tx, blockhash, lastValidBlockHeight, simulateTransactions).catch(e => { console.log("Error sending tx:", e.message); return "Error"; })));
+            batchTxIds.push(txIds);
+        }
+        return batchTxIds;
+    });
+}
+function signVersionedTxs(wallet, versionedTxs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let txs = [];
+        for (const batch of versionedTxs.batches)
+            for (const tx of batch)
+                txs.push(tx);
+        txs = yield wallet.signAllTransactions(txs);
+        let pointer = 0;
+        for (let batchIndex = 0; batchIndex < versionedTxs.batches.length; batchIndex++)
+            for (let txIndex = 0; txIndex < versionedTxs.batches[batchIndex].length; txIndex++) {
+                versionedTxs.batches[batchIndex][txIndex] = txs[pointer];
+                pointer++;
+            }
+        return versionedTxs;
+    });
+}
+function signTxPayloadBatchSequence(wallet, txPayloadBatchSequence) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let txs = [];
+        for (const batch of txPayloadBatchSequence.batches)
+            for (const tx of batch.transactions)
+                txs.push(web3_js_2.VersionedTransaction.deserialize(Buffer.from(tx.tx_b64, 'base64')));
+        txs = yield wallet.signAllTransactions(txs);
+        let pointer = 0;
+        for (let batchIndex = 0; batchIndex < txPayloadBatchSequence.batches.length; batchIndex++)
+            for (let txIndex = 0; txIndex < txPayloadBatchSequence.batches[batchIndex].transactions.length; txIndex++) {
+                txPayloadBatchSequence.batches[batchIndex].transactions[txIndex].tx_b64 = Buffer.from(txs[pointer].serialize()).toString('base64');
+                pointer++;
+            }
+        return txPayloadBatchSequence;
+    });
+}
+function sendTxPayloadBatchSequence(connection_1, txPayloadBatchSequence_1) {
+    return __awaiter(this, arguments, void 0, function* (connection, txPayloadBatchSequence, simulateTransactions = false) {
+        var _a, _b;
+        let txs = [];
+        for (const batch of txPayloadBatchSequence.batches) {
+            let batchTxs = [];
+            for (const tx of batch.transactions)
+                batchTxs.push(web3_js_2.VersionedTransaction.deserialize(Buffer.from(tx.tx_b64, 'base64')));
+            txs.push(batchTxs);
+        }
+        return yield sendVersionedTxs(connection, {
+            blockhash: (_b = (_a = txPayloadBatchSequence.batches[0].transactions[0]) === null || _a === void 0 ? void 0 : _a.recent_blockhash) !== null && _b !== void 0 ? _b : "",
+            lastValidBlockHeight: 0,
+            batches: txs,
+        }, simulateTransactions);
+    });
+}

package/dist/test.d.ts

@@ -0,0 +1 @@
+export {};