@symmetry-hq/temp-v3-sdk 0.0.1

package/dist/src/states/oracles/raydium_cpmm_oracle.js

@@ -0,0 +1,420 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RaydiumCPMMOracle = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const oracle_1 = require("./oracle");
+const CPMM_PROGRAM_ID = new web3_js_1.PublicKey("CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C");
+const DEV_CPMM_PROGRAM_ID = new web3_js_1.PublicKey("DRaycpLY18LhpbydsBWbVJtxpNv9oXPgjRSfpF2bWpYb");
+var Side;
+(function (Side) {
+    Side[Side["Base"] = 0] = "Base";
+    Side[Side["Quote"] = 1] = "Quote";
+})(Side || (Side = {}));
+var Quote;
+(function (Quote) {
+    Quote[Quote["Usdc"] = 0] = "Usdc";
+    Quote[Quote["Wsol"] = 1] = "Wsol";
+})(Quote || (Quote = {}));
+class Observation {
+    constructor(params) {
+        this.timestamp = params.timestamp;
+        this.cum_t_0_price = params.cum_t_0_price;
+        this.cum_t_1_price = params.cum_t_1_price;
+    }
+    static decode(data, offset = 0) {
+        const timestamp = new anchor_1.BN(data.subarray(offset, offset + 8), "le");
+        const cum_t_0_price = new anchor_1.BN(data.subarray(offset + 8, offset + 24), 'le');
+        const cum_t_1_price = new anchor_1.BN(data.subarray(offset + 24, offset + 40), 'le');
+        return [
+            new Observation({
+                timestamp,
+                cum_t_0_price,
+                cum_t_1_price
+            }),
+            offset + 40
+        ];
+    }
+    sub(other) {
+        if (!(other instanceof Observation)) {
+            throw new TypeError("Subtraction is only supported between Observation instances");
+        }
+        return new Observation({
+            timestamp: this.timestamp.sub(other.timestamp),
+            cum_t_0_price: this.cum_t_0_price.sub(other.cum_t_0_price),
+            cum_t_1_price: this.cum_t_1_price.sub(other.cum_t_1_price),
+        });
+    }
+    add(other) {
+        if (!(other instanceof Observation)) {
+            throw new TypeError("Addition is only supported between Observation instances");
+        }
+        return new Observation({
+            timestamp: this.timestamp.add(other.timestamp),
+            cum_t_0_price: this.cum_t_0_price.add(other.cum_t_0_price),
+            cum_t_1_price: this.cum_t_1_price.add(other.cum_t_1_price),
+        });
+    }
+    get_weighted_observation(time) {
+        const cum_t_0_price = this.cum_t_0_price.mul(time).div(this.timestamp);
+        const cum_t_1_price = this.cum_t_1_price.mul(time).div(this.timestamp);
+        return new Observation({
+            timestamp: time,
+            cum_t_0_price,
+            cum_t_1_price
+        });
+    }
+    adjust_to_timestamp(target_timestamp, observation_prev) {
+        // delta = self.sub(prev_observation)
+        const delta = this.sub(observation_prev);
+        // weighted_delta = delta.get_weighted_observation(target_timestamp - self.block_timestamp)
+        const timeForWeighted = target_timestamp.sub(this.timestamp);
+        const weighted_delta = delta.get_weighted_observation(timeForWeighted);
+        // return self.add(weighted_delta)
+        return this.add(weighted_delta);
+    }
+    get_twap(side) {
+        let cum_price = new anchor_1.BN(0);
+        if (side === Side.Base)
+            cum_price = this.cum_t_0_price;
+        else
+            cum_price = this.cum_t_1_price;
+        console.log("cum_price", cum_price.toString());
+        return cum_price.div(this.timestamp);
+    }
+}
+class ObservationState {
+    constructor(params) {
+        this.initialized = params.initialized;
+        this.observation_index = params.observation_index;
+        this.pool_id = params.pool_id;
+        this.observations = params.observations;
+        this.last_update_timestamp = params.last_update_timestamp;
+        this.padding = params.padding;
+    }
+    static decode(data, offset = 8) {
+        let cursor = offset;
+        const initialized = data.readUInt8(cursor) !== 0;
+        cursor += 1;
+        const observation_index = data.readUInt16LE(cursor);
+        cursor += 2;
+        const pool_id = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const observations = [];
+        for (let i = 0; i < 100; i++) {
+            let obs;
+            [obs, cursor] = Observation.decode(data, cursor);
+            observations.push(obs);
+        }
+        const last_update_timestamp = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const padding = [];
+        for (let i = 0; i < 4; i++) {
+            padding.push(new anchor_1.BN(data.subarray(cursor, cursor + 8), "le"));
+            cursor += 8;
+        }
+        return [
+            new ObservationState({
+                initialized,
+                observation_index,
+                pool_id,
+                observations,
+                last_update_timestamp,
+                padding
+            }),
+            cursor
+        ];
+    }
+}
+class PoolState {
+    constructor(params) {
+        this.amm_config = params.amm_config;
+        this.pool_creator = params.pool_creator;
+        this.token_0_vault = params.token_0_vault;
+        this.token_1_vault = params.token_1_vault;
+        this.lp_mint = params.lp_mint;
+        this.token_0_mint = params.token_0_mint;
+        this.token_1_mint = params.token_1_mint;
+        this.token_0_program = params.token_0_program;
+        this.token_1_program = params.token_1_program;
+        this.observation_key = params.observation_key;
+        this.auth_bump = params.auth_bump; // u8
+        this.status = params.status; // u8
+        this.lp_mint_decimals = params.lp_mint_decimals; // u8
+        this.mint_0_decimals = params.mint_0_decimals; // u8
+        this.mint_1_decimals = params.mint_1_decimals; // u8
+        this.lp_supply = params.lp_supply; // u64
+        this.protocol_fees_token_0 = params.protocol_fees_token_0; // u64
+        this.protocol_fees_token_1 = params.protocol_fees_token_1; // u64
+        this.fund_fees_token_0 = params.fund_fees_token_0; // u64
+        this.fund_fees_token_1 = params.fund_fees_token_1; // u64
+        this.open_time = params.open_time; // u64
+        this.recent_epoch = params.recent_epoch; // u64
+        this.creator_fee_on = params.creator_fee_on; //u8
+        this.enable_creator_fee = params.enable_creator_fee;
+        this.padding1 = params.padding1; // [u8; 6]
+        this.creator_fees_token_0 = params.creator_fees_token_0; // u64
+        this.creator_fees_token_1 = params.creator_fees_token_1; // u64
+        this.padding = params.padding; // [u64; 28]
+    }
+    static decode(data, offset = 8) {
+        let cursor = offset;
+        const amm_config = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const pool_creator = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const token_0_vault = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const token_1_vault = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const lp_mint = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const token_0_mint = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const token_1_mint = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const token_0_program = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const token_1_program = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const observation_key = new web3_js_1.PublicKey(data.subarray(cursor, cursor + 32));
+        cursor += 32;
+        const auth_bump = data.readUInt8(cursor);
+        cursor += 1;
+        const status = data.readUInt8(cursor);
+        cursor += 1;
+        const lp_mint_decimals = data.readUInt8(cursor);
+        cursor += 1;
+        const mint_0_decimals = data.readUInt8(cursor);
+        cursor += 1;
+        const mint_1_decimals = data.readUInt8(cursor);
+        cursor += 1;
+        const lp_supply = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const protocol_fees_token_0 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const protocol_fees_token_1 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const fund_fees_token_0 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const fund_fees_token_1 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const open_time = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const recent_epoch = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const creator_fee_on = data.readUInt8(cursor);
+        cursor += 1;
+        const enable_creator_fee = !!data.readUInt8(cursor);
+        cursor += 1;
+        const padding1 = [];
+        for (let i = 0; i < 6; i++) {
+            padding1.push(data.readUInt8(cursor));
+            cursor += 1;
+        }
+        const creator_fees_token_0 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const creator_fees_token_1 = new anchor_1.BN(data.subarray(cursor, cursor + 8), "le");
+        cursor += 8;
+        const padding = [];
+        for (let i = 0; i < 28; i++) {
+            padding.push(new anchor_1.BN(data.subarray(cursor, cursor + 8), "le"));
+            cursor += 8;
+        }
+        return [
+            new PoolState({
+                amm_config,
+                pool_creator,
+                token_0_vault,
+                token_1_vault,
+                lp_mint,
+                token_0_mint,
+                token_1_mint,
+                token_0_program,
+                token_1_program,
+                observation_key,
+                auth_bump,
+                status,
+                lp_mint_decimals,
+                mint_0_decimals,
+                mint_1_decimals,
+                lp_supply,
+                protocol_fees_token_0,
+                protocol_fees_token_1,
+                fund_fees_token_0,
+                fund_fees_token_1,
+                open_time,
+                recent_epoch,
+                creator_fee_on,
+                enable_creator_fee,
+                padding1,
+                creator_fees_token_0,
+                creator_fees_token_1,
+                padding,
+            }),
+            cursor,
+        ];
+    }
+}
+class RaydiumCPMMOracle extends oracle_1.Oracle {
+    constructor(params) {
+        super(params.weight, params.conf_thresh_bps, params.staleness_thresh, params.volatility_thresh, params.min_liquidity, params.staleness_conf_rate_bps);
+        this.pool_id = params.pool_id;
+        this.quote_token = params.quote_token;
+        this.pool_state = params.pool_state;
+        this.side = params.side;
+        this.observation_state = params.observation_state;
+    }
+    static create(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { connection, pool_id } = params;
+            // Fetch pool_state
+            const poolAccountInfo = yield connection.getAccountInfo(new web3_js_1.PublicKey(pool_id));
+            if (!poolAccountInfo)
+                throw new Error("Pool account not found");
+            const [pool_state, _] = PoolState.decode(poolAccountInfo.data, 8);
+            // Fetch observation_state from pool_state
+            const obsPubkey = pool_state.observation_key;
+            const obsAccountInfo = yield connection.getAccountInfo(new web3_js_1.PublicKey(obsPubkey));
+            if (!obsAccountInfo)
+                throw new Error("Observation account not found");
+            const [observation_state, __] = ObservationState.decode(obsAccountInfo.data, 8);
+            return new RaydiumCPMMOracle({
+                pool_id: pool_id,
+                quote_token: params.quote_token,
+                pool_state: pool_state,
+                side: params.side,
+                observation_state: observation_state,
+                weight: params.weight,
+                conf_thresh_bps: params.conf_thresh_bps,
+                staleness_thresh: params.staleness_thresh,
+                volatility_thresh: params.volatility_thresh,
+                min_liquidity: params.min_liquidity,
+                staleness_conf_rate_bps: params.staleness_conf_rate_bps
+            });
+        });
+    }
+    set_side(side) {
+        this.side = side;
+    }
+    static derive_observation_key(poolId) {
+        const seeds = [
+            Buffer.from("observation"),
+            poolId.toBuffer(),
+        ];
+        return web3_js_1.PublicKey.findProgramAddressSync(seeds, CPMM_PROGRAM_ID);
+    }
+    ;
+    get_observation_at_index(index) {
+        return this.observation_state.observations[index];
+    }
+    get_observation_at_timestamp(timestamp, startIndex) {
+        let observationCurrent = this.get_observation_at_index(startIndex);
+        let index = startIndex;
+        // Loop backwards until we find the observation <= timestamp
+        while (observationCurrent.timestamp.gt(timestamp)) {
+            index = (index - 1 + 100) % 100;
+            observationCurrent = this.get_observation_at_index(index);
+            if (index === startIndex) {
+                throw Error("Observations do not go back far enough in time");
+                break; // looped all the way around
+            }
+        }
+        // Previous index for interpolation
+        const prevIndex = (index - 1 + 100) % 100;
+        const observationPrev = this.get_observation_at_index(prevIndex);
+        // Adjust current observation to the target timestamp
+        const result = observationCurrent.adjust_to_timestamp(timestamp, observationPrev);
+        return result;
+    }
+    get_delta_observations(currentTime) {
+        const obsIndex = this.observation_state.observation_index;
+        const observationCurrent = this.get_observation_at_timestamp(currentTime, obsIndex);
+        const observation30s = this.get_observation_at_timestamp(new anchor_1.BN(currentTime.sub(new anchor_1.BN(30))), obsIndex);
+        const delta30s = observationCurrent.sub(observation30s);
+        const observation2min = this.get_observation_at_timestamp(new anchor_1.BN(currentTime.sub(new anchor_1.BN(120))), obsIndex);
+        const delta2min = observationCurrent.sub(observation2min);
+        const observation5min = this.get_observation_at_timestamp(new anchor_1.BN(currentTime.sub(new anchor_1.BN(300))), obsIndex);
+        const delta5min = observationCurrent.sub(observation5min);
+        const observation20min = this.get_observation_at_timestamp(new anchor_1.BN(currentTime.sub(new anchor_1.BN(1200))), obsIndex);
+        const delta20min = observationCurrent.sub(observation20min);
+        return [delta30s, delta2min, delta5min, delta20min];
+    }
+    ;
+    get_decimals() {
+        let dec;
+        if (this.side === Side.Base)
+            dec = this.pool_state.mint_0_decimals - this.pool_state.mint_1_decimals;
+        else
+            dec = this.pool_state.mint_1_decimals - this.pool_state.mint_0_decimals;
+        return dec;
+    }
+    get_twap_30sec(current_time) {
+        let observation = this.get_delta_observations(current_time)[0];
+        let twap_scaled = new decimal_js_1.default(observation.get_twap(this.side).toString()).div(2 ** 32);
+        let twap = new decimal_js_1.default(twap_scaled.toString()).div(10 ** this.get_decimals());
+        return twap;
+    }
+    get_twap_2min(current_time) {
+        let observation = this.get_delta_observations(current_time)[1];
+        let twap_scaled = new decimal_js_1.default(observation.get_twap(this.side).toString()).div(2 ** 32);
+        let twap = new decimal_js_1.default(twap_scaled.toString()).div(10 ** this.get_decimals());
+        return twap;
+    }
+    get_twap_5min(current_time) {
+        let observation = this.get_delta_observations(current_time)[2];
+        let twap_scaled = new decimal_js_1.default(observation.get_twap(this.side).toString()).div(2 ** 32);
+        let twap = new decimal_js_1.default(twap_scaled.toString()).div(10 ** this.get_decimals());
+        return twap;
+    }
+    get_twap_20min(current_time) {
+        let observation = this.get_delta_observations(current_time)[3];
+        let twap_scaled = new decimal_js_1.default(observation.get_twap(this.side).toString()).div(2 ** 32);
+        let twap = new decimal_js_1.default(twap_scaled.toString()).div(10 ** this.get_decimals());
+        return twap;
+    }
+    get_confidence(current_time) {
+        const twapNow = this.get_twap_30sec(current_time);
+        const diff2Min = twapNow.sub(this.get_twap_2min(current_time)).abs();
+        const diff5Min = twapNow.sub(this.get_twap_5min(current_time)).abs();
+        const diff20Min = twapNow.sub(this.get_twap_20min(current_time)).abs();
+        let max = diff2Min;
+        if (diff5Min.gt(max))
+            max = diff5Min;
+        if (diff20Min.gt(max))
+            max = diff20Min;
+        return max;
+    }
+    fetch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentTime = new anchor_1.BN(Math.floor(Date.now() / 1000)); // current UNIX timestamp in seconds
+            const confidence = this.get_confidence(currentTime);
+            // const liquidity = this.pool_state.liquidity; // assuming pool_state is already the decoded data
+            const price = this.get_twap_30sec(currentTime);
+            let errors = 0;
+            // if (confidence.mul(10_000).greaterThan(this.conf_thresh_bps!)) {
+            //     errors |= ErrorCode.TOO_UNCERTAIN;
+            // }
+            // if (liquidity.lt(this.min_liquidity)) {
+            //     errors |= ErrorCode.NOT_ENOUGH_LIQUIDITY;
+            // };
+            let err = new oracle_1.OracleErrors(errors);
+            let oracle_price = new oracle_1.OraclePrice(price, confidence, currentTime);
+            return new oracle_1.OracleResult(oracle_price, err);
+        });
+    }
+}
+exports.RaydiumCPMMOracle = RaydiumCPMMOracle;

package/dist/src/states/oracles/switchboardOracle.js

@@ -0,0 +1 @@
+"use strict";

package/dist/src/states/oracles/switchboard_oracle.js

@@ -0,0 +1 @@
+"use strict";

package/dist/src/txUtils.d.ts

@@ -0,0 +1,26 @@
+import { AddressLookupTableAccount, Connection, Keypair, PublicKey, Signer, TransactionInstruction, VersionedTransaction } from '@solana/web3.js';
+export declare const COMPUTE_UNITS = 1000000;
+type TransactionSignature = string;
+export interface VersionedTxs {
+    blockhash: string;
+    lastValidBlockHeight: number;
+    versionedTxs: VersionedTransaction[];
+    batches: number[];
+}
+export declare function delay(ms: number): Promise<void>;
+export declare function getAddressLookupTableAccounts(connection: Connection, keys: PublicKey[]): Promise<AddressLookupTableAccount[]>;
+export declare function getMultipleAddressLookupTableAccounts(connection: Connection, keys: PublicKey[][]): Promise<AddressLookupTableAccount[][]>;
+export declare function wrapV0Transaction(blockhash: string, addressLookupTableAccounts: AddressLookupTableAccount[], payerPubkey: PublicKey, priorityFee: number, ixs: TransactionInstruction[]): VersionedTransaction;
+export declare function sendV0Transaction(connection: Connection, tx: VersionedTransaction, blockhash: string, lastValidBlockHeight: number, simulateTransactions: boolean): Promise<TransactionSignature>;
+export declare function prepareV0Transactions(params: {
+    connection: Connection;
+    payer: PublicKey;
+    priorityFee: number;
+    multipleIxs: TransactionInstruction[][];
+    multipleLookupTableAddresses: PublicKey[][];
+    signers: Keypair[][];
+    batches: number[];
+}): Promise<VersionedTxs>;
+export declare function sendV0Transactions(connection: Connection, txParams: VersionedTxs, simulateTransactions: boolean): Promise<TransactionSignature[]>;
+export declare function signAndSendVtx(connection: Connection, signer: Signer, txs: VersionedTxs): Promise<TransactionSignature[]>;
+export {};

package/dist/src/txUtils.js

@@ -0,0 +1,183 @@
+"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.COMPUTE_UNITS = void 0;
+exports.delay = delay;
+exports.getAddressLookupTableAccounts = getAddressLookupTableAccounts;
+exports.getMultipleAddressLookupTableAccounts = getMultipleAddressLookupTableAccounts;
+exports.wrapV0Transaction = wrapV0Transaction;
+exports.sendV0Transaction = sendV0Transaction;
+exports.prepareV0Transactions = prepareV0Transactions;
+exports.sendV0Transactions = sendV0Transactions;
+exports.signAndSendVtx = signAndSendVtx;
+const web3_js_1 = require("@solana/web3.js");
+exports.COMPUTE_UNITS = 1000000;
+function delay(ms) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    });
+}
+function getAddressLookupTableAccounts(connection, keys) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const addressLookupTableAccountInfos = yield connection.getMultipleAccountsInfo(keys, "confirmed");
+        return addressLookupTableAccountInfos.reduce((acc, accountInfo, index) => {
+            const addressLookupTableAddress = keys[index];
+            if (accountInfo) {
+                const addressLookupTableAccount = new web3_js_1.AddressLookupTableAccount({
+                    key: new web3_js_1.PublicKey(addressLookupTableAddress),
+                    state: web3_js_1.AddressLookupTableAccount.deserialize(accountInfo.data),
+                });
+                acc.push(addressLookupTableAccount);
+            }
+            return acc;
+        }, new Array());
+    });
+}
+;
+function getMultipleAddressLookupTableAccounts(connection, keys) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let allLuts = [];
+        keys.forEach(luts => luts.forEach(lut => allLuts.push(lut.toBase58())));
+        allLuts = [...new Set(allLuts)];
+        const addressLookupTableAccounts = yield getAddressLookupTableAccounts(connection, allLuts.map(lut => new web3_js_1.PublicKey(lut)));
+        const map = {};
+        allLuts.forEach((pubkey, id) => map[pubkey] = addressLookupTableAccounts[id]);
+        return keys.map(luts => luts.map(lut => map[lut.toBase58()]));
+    });
+}
+function wrapV0Transaction(blockhash, addressLookupTableAccounts, payerPubkey, priorityFee, ixs) {
+    ixs = [
+        ...ixs,
+        web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: exports.COMPUTE_UNITS }),
+        web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee }),
+    ];
+    const txMessage = new web3_js_1.TransactionMessage({
+        payerKey: payerPubkey,
+        recentBlockhash: blockhash,
+        instructions: ixs,
+    });
+    let versionedTx = new web3_js_1.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 sendV0Transaction(connection, tx, blockhash, lastValidBlockHeight, simulateTransactions) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const serializedTx = tx.serialize();
+        let txId = "Error";
+        if (simulateTransactions) {
+            txId = yield connection.sendRawTransaction(serializedTx, { preflightCommitment: "confirmed" }).catch(e => { console.log(e.message); return "Error"; });
+            console.log("Simulation txId:", txId);
+            for (let i = 0; i < 4; i++) {
+                yield delay(1000).then(() => connection.sendRawTransaction(serializedTx, { preflightCommitment: "confirmed" }).catch(() => { }));
+            }
+            if (txId === "Error")
+                throw new Error("Simulation failed");
+        }
+        else {
+            connection.sendRawTransaction(serializedTx, { preflightCommitment: "confirmed" })
+                .catch(e => { console.log(e.message); });
+            txId = yield connection.sendRawTransaction(serializedTx, { skipPreflight: true });
+            console.log("Sending tx:", txId);
+            for (let i = 0; i < 4; i++) {
+                yield delay(1000).then(() => connection.sendRawTransaction(serializedTx, { skipPreflight: true }).catch(() => { }));
+            }
+        }
+        let confirmation = null;
+        let result = null;
+        connection.confirmTransaction({
+            blockhash,
+            lastValidBlockHeight,
+            signature: txId,
+        }, "confirmed").then((res) => confirmation = res);
+        let iterations = 15;
+        while (confirmation === null && result === null && iterations > 0) {
+            yield delay(2500);
+            result = yield connection.getTransaction(txId, {
+                commitment: "confirmed",
+                maxSupportedTransactionVersion: 0,
+            });
+            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 prepareV0Transactions(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { connection, payer, priorityFee, multipleIxs, multipleLookupTableAddresses, signers, batches } = params;
+        const { blockhash, lastValidBlockHeight } = yield connection.getLatestBlockhash();
+        const multipleAddressLookupTableAccounts = yield getMultipleAddressLookupTableAccounts(connection, multipleLookupTableAddresses);
+        const txs = multipleIxs.map((ixs, index) => {
+            let tx = null;
+            try {
+                tx = wrapV0Transaction(blockhash, multipleAddressLookupTableAccounts[index], payer, priorityFee, ixs);
+                if (signers[index].length > 0)
+                    tx.sign(signers[index]);
+            }
+            catch (e) {
+                console.log("Error signing tx:", e.message);
+            }
+            return tx;
+        }).filter(tx => tx !== null);
+        return {
+            blockhash,
+            lastValidBlockHeight,
+            versionedTxs: txs,
+            batches,
+        };
+    });
+}
+function sendV0Transactions(connection, txParams, simulateTransactions) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { versionedTxs, blockhash, lastValidBlockHeight, batches } = txParams;
+        const signedTxs = versionedTxs;
+        let lastIndex = 0;
+        let txIds = [];
+        for (let i = 0; i < batches.length; i++) {
+            const ids = yield Promise.all(signedTxs.slice(lastIndex, lastIndex + batches[i]).map(signedTx => sendV0Transaction(connection, signedTx, blockhash, lastValidBlockHeight, simulateTransactions).catch(e => {
+                console.log("Transaction failed:", e.message);
+                return "Error";
+            })));
+            txIds = [...txIds, ...ids];
+            lastIndex += batches[i];
+        }
+        return txIds;
+    });
+}
+function signAndSendVtx(connection, signer, txs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (let vtx of txs.versionedTxs) {
+            vtx.sign([signer]);
+        }
+        let tx = yield sendV0Transactions(connection, txs, false);
+        return tx;
+    });
+}

package/dist/states/basket.d.ts

@@ -0,0 +1,8 @@
+import { Connection, PublicKey } from "@solana/web3.js";
+import { Basket } from "../layouts/basket";
+export declare function fetchBasket(connection: Connection, basketAddress: PublicKey): Promise<Basket>;
+export interface Filter {
+    filterType: "host" | "creator";
+    filterValue: PublicKey;
+}
+export declare function fetchBaskets(connection: Connection, filters: Filter[]): Promise<Basket[]>;