@streamflow/common 7.5.3 → 8.0.0-alpha.p284.726ba98

package/dist/cjs/solana/utils.js

@@ -1,478 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildSendThrottler = void 0;
-exports.getProgramAccounts = getProgramAccounts;
-exports.isSignerWallet = isSignerWallet;
-exports.isSignerKeypair = isSignerKeypair;
-exports.isTransactionVersioned = isTransactionVersioned;
-exports.prepareTransaction = prepareTransaction;
-exports.signTransaction = signTransaction;
-exports.signAndExecuteTransaction = signAndExecuteTransaction;
-exports.executeTransaction = executeTransaction;
-exports.executeMultipleTransactions = executeMultipleTransactions;
-exports.sendAndConfirmTransaction = sendAndConfirmTransaction;
-exports.simulateTransaction = simulateTransaction;
-exports.confirmAndEnsureTransaction = confirmAndEnsureTransaction;
-exports.ata = ata;
-exports.ataBatchExist = ataBatchExist;
-exports.enrichAtaParams = enrichAtaParams;
-exports.generateCreateAtaBatchTx = generateCreateAtaBatchTx;
-exports.createAtaBatch = createAtaBatch;
-exports.checkOrCreateAtaBatch = checkOrCreateAtaBatch;
-exports.prepareBaseInstructions = prepareBaseInstructions;
-exports.getMintAndProgram = getMintAndProgram;
-exports.getMultipleAccountsInfoBatched = getMultipleAccountsInfoBatched;
-const spl_token_1 = require("@solana/spl-token");
-const web3_js_1 = require("@solana/web3.js");
-const bs58_1 = __importDefault(require("bs58"));
-const p_queue_1 = __importDefault(require("p-queue"));
-const types_js_1 = require("./types.js");
-const utils_js_1 = require("../lib/utils.js");
-const SIMULATE_TRIES = 3;
-const buildSendThrottler = (sendRate, sendInterval = 1000) => {
-    return new p_queue_1.default({ concurrency: sendRate, intervalCap: 1, interval: sendInterval });
-};
-exports.buildSendThrottler = buildSendThrottler;
-/**
- * Wrapper function for Solana web3 getProgramAccounts with slightly better call interface
- * @param {Connection} connection - Solana web3 connection object.
- * @param {PublicKey} wallet - PublicKey to compare against.
- * @param {number} offset - Offset of bits of the PublicKey in the account binary.
- * @param {PublicKey} programId - Solana program ID.
- * @return {Promise<Account[]>} - Array of resulting accounts.
- */
-async function getProgramAccounts(connection, wallet, offset, programId) {
-    const programAccounts = await connection?.getProgramAccounts(programId, {
-        filters: [
-            {
-                memcmp: {
-                    offset,
-                    bytes: wallet.toBase58(),
-                },
-            },
-        ],
-    });
-    return [...programAccounts];
-}
-/**
- * Utility function to check if the transaction initiator is a Wallet object
- * @param {Keypair | SignerWalletAdapter} walletOrKeypair - Wallet or Keypair in question
- * @return {boolean} - Returns true if parameter is a Wallet.
- */
-function isSignerWallet(walletOrKeypair) {
-    return walletOrKeypair.signTransaction !== undefined;
-}
-/**
- * Utility function to check if the transaction initiator a Keypair object, tries to mitigate version mismatch issues
- * @param walletOrKeypair {Keypair | SignerWalletAdapter} walletOrKeypair - Wallet or Keypair in question
- * @returns {boolean} - Returns true if parameter is a Keypair.
- */
-function isSignerKeypair(walletOrKeypair) {
-    return (walletOrKeypair instanceof web3_js_1.Keypair ||
-        walletOrKeypair.constructor === web3_js_1.Keypair ||
-        walletOrKeypair.constructor.name === web3_js_1.Keypair.prototype.constructor.name);
-}
-/**
- * Utility function to check whether given transaction is Versioned
- * @param tx {Transaction | VersionedTransaction} - Transaction to check
- * @returns {boolean} - Returns true if transaction is Versioned.
- */
-function isTransactionVersioned(tx) {
-    return "message" in tx;
-}
-/**
- * Creates a Transaction with given instructions and optionally signs it.
- * @param connection - Solana client connection
- * @param ixs - Instructions to add to the Transaction
- * @param payer - PublicKey of payer
- * @param commitment - optional Commitment that will be used to fetch latest blockhash
- * @param partialSigners - optional signers that will be used to partially sign a Transaction
- * @returns Transaction and Blockhash
- */
-async function prepareTransaction(connection, ixs, payer, commitment, ...partialSigners) {
-    if (!payer) {
-        throw new Error("Payer public key is not provided!");
-    }
-    const { value: hash, context } = await connection.getLatestBlockhashAndContext(commitment);
-    const messageV0 = new web3_js_1.TransactionMessage({
-        payerKey: payer,
-        recentBlockhash: hash.blockhash,
-        instructions: ixs,
-    }).compileToV0Message();
-    const tx = new web3_js_1.VersionedTransaction(messageV0);
-    const signers = partialSigners.filter((item) => !!item);
-    tx.sign(signers);
-    return { tx, context, hash };
-}
-async function signTransaction(invoker, tx) {
-    let signedTx;
-    if (isSignerWallet(invoker)) {
-        signedTx = await invoker.signTransaction(tx);
-    }
-    else {
-        if (isTransactionVersioned(tx)) {
-            tx.sign([invoker]);
-        }
-        else {
-            tx.partialSign(invoker);
-        }
-        signedTx = tx;
-    }
-    return signedTx;
-}
-/**
- * Signs, sends and confirms Transaction
- * @param connection - Solana client connection
- * @param invoker - Keypair used as signer
- * @param tx - Transaction instance
- * @param confirmationParams - Confirmation Params that will be used for execution
- * @param throttleParams - rate or throttler instance to throttle TX sending - to not spam the blockchain too much
- * @returns Transaction signature
- */
-async function signAndExecuteTransaction(connection, invoker, tx, confirmationParams, throttleParams) {
-    const signedTx = await signTransaction(invoker, tx);
-    return executeTransaction(connection, signedTx, confirmationParams, throttleParams);
-}
-/**
- * Sends and confirms Transaction
- * Uses custom confirmation logic that:
- * - simulates tx before sending separately
- * - sends transaction without preFlight checks but with some valuable flags https://twitter.com/jordaaash/status/1774892862049800524?s=46&t=bhZ10V0r7IX5Lk5kKzxfGw
- * - rebroadcasts a tx every 500 ms
- * - after broadcasting check whether tx has executed once
- * - catch errors for every actionable item, throw only the ones that signal that tx has failed
- * - otherwise there is a chance of marking a landed tx as failed if it was broadcasted at least once
- * @param connection - Solana client connection
- * @param tx - Transaction instance
- * @param confirmationParams - Confirmation Params that will be used for execution
- * @param throttleParams - rate or throttler instance to throttle TX sending - to not spam the blockchain too much
- * @returns Transaction signature
- */
-async function executeTransaction(connection, tx, confirmationParams, throttleParams) {
-    if (tx.signatures.length === 0) {
-        throw Error("Error with transaction parameters.");
-    }
-    await simulateTransaction(connection, tx);
-    return sendAndConfirmTransaction(connection, tx, confirmationParams, throttleParams);
-}
-/**
- * Launches a PromisePool with all transaction being executed at the same time, allows to throttle all TXs through one Queue
- * @param connection - Solana client connection
- * @param txs - Transactions
- * @param confirmationParams - Confirmation Params that will be used for execution
- * @param throttleParams - rate or throttler instance to throttle TX sending - to not spam the blockchain too much
- * @param throttleParams.sendRate - rate
- * @param throttleParams.sendThrottler -  throttler instance
- * @returns Raw Promise Results - should be handled by the consumer and unwrapped accordingly
- */
-async function executeMultipleTransactions(connection, txs, confirmationParams, { sendRate = 1, sendThrottler, ...throttlingParams }) {
-    if (!sendThrottler) {
-        sendThrottler = (0, exports.buildSendThrottler)(sendRate);
-    }
-    return Promise.allSettled(txs.map((tx) => executeTransaction(connection, tx, confirmationParams, {
-        ...throttlingParams,
-        sendRate: sendRate,
-        sendThrottler: sendThrottler,
-    })));
-}
-/**
- * Sends and confirm transaction in a loop, constantly re-broadcsting the tx until Blockheight expires.
- * - we add additional 30 bocks to account for validators in an PRC pool divergence
- * @param connection - Solana client connection
- * @param tx - Transaction instance
- * @param confirmationParams - Confirmation Params that will be used for execution
- * @param confirmationParams.hash - blockhash information, the same hash should be used in the Transaction
- * @param confirmationParams.context - context at which blockhash has been retrieve
- * @param confirmationParams.commitment - optional commitment that will be used for simulation and confirmation
- * @param throttleParams - rate or throttler instance to throttle TX sending - to not spam the blockchain too much
- * @param throttleParams.sendRate - rate
- * @param throttleParams.sendThrottler -  throttler instance
- */
-async function sendAndConfirmTransaction(connection, tx, { hash, context, commitment }, { sendRate = 1, sendThrottler, waitBeforeConfirming }) {
-    const isVersioned = isTransactionVersioned(tx);
-    let signature;
-    if (isVersioned) {
-        signature = bs58_1.default.encode(tx.signatures[0]);
-    }
-    else {
-        signature = bs58_1.default.encode(tx.signature);
-    }
-    if (!sendThrottler) {
-        sendThrottler = (0, exports.buildSendThrottler)(sendRate);
-    }
-    let blockheight = await connection.getBlockHeight(commitment);
-    let transactionSent = false;
-    const rawTransaction = tx.serialize();
-    while (blockheight < hash.lastValidBlockHeight + 15) {
-        try {
-            if (blockheight < hash.lastValidBlockHeight || !transactionSent) {
-                await sendThrottler.add(async () => connection.sendRawTransaction(rawTransaction, {
-                    maxRetries: 0,
-                    minContextSlot: context.slot,
-                    preflightCommitment: commitment,
-                    skipPreflight: true,
-                }));
-                transactionSent = true;
-            }
-        }
-        catch (e) {
-            if (transactionSent ||
-                (e instanceof web3_js_1.SendTransactionError && e.message.includes("Minimum context slot has not been reached"))) {
-                await (0, utils_js_1.sleep)(500);
-                continue;
-            }
-            throw e;
-        }
-        // Wait at least 5 slots (~400ms before confirming)
-        await (0, utils_js_1.sleep)(waitBeforeConfirming ?? 2000);
-        try {
-            const value = await confirmAndEnsureTransaction(connection, signature);
-            if (value) {
-                return signature;
-            }
-        }
-        catch (e) {
-            if (e instanceof types_js_1.TransactionFailedError) {
-                throw e;
-            }
-            await (0, utils_js_1.sleep)(500);
-        }
-        try {
-            blockheight = await connection.getBlockHeight(commitment);
-        }
-        catch (_e) {
-            await (0, utils_js_1.sleep)(500);
-        }
-    }
-    throw new Error(`Transaction ${signature} expired.`);
-}
-async function simulateTransaction(connection, tx) {
-    let res;
-    for (let i = 0; i < SIMULATE_TRIES; i++) {
-        if (isTransactionVersioned(tx)) {
-            res = await connection.simulateTransaction(tx);
-        }
-        else {
-            res = await connection.simulateTransaction(tx);
-        }
-        if (res.value.err) {
-            const errMessage = JSON.stringify(res.value.err);
-            if (!errMessage.includes("BlockhashNotFound") || i === SIMULATE_TRIES - 1) {
-                throw new web3_js_1.SendTransactionError({
-                    action: "simulate",
-                    signature: "",
-                    transactionMessage: `failed to simulate transaction: ${typeof res.value.err === "string" ? res.value.err : errMessage}`,
-                    logs: res.value.logs ?? undefined,
-                });
-            }
-            continue;
-        }
-        return res;
-    }
-    throw new web3_js_1.SendTransactionError({
-        action: "simulate",
-        signature: "",
-        transactionMessage: "failed to simulate transaction",
-    });
-}
-/**
- * Confirms and validates transaction success once
- * @param connection - Solana client connection
- * @param signature - Transaction signature
- * @param ignoreError - return status even if tx failed
- * @returns Transaction Status
- */
-async function confirmAndEnsureTransaction(connection, signature, ignoreError) {
-    const response = await connection.getSignatureStatuses([signature]);
-    if (!response || response.value.length === 0 || response.value[0] === null) {
-        return null;
-    }
-    const value = response.value[0];
-    if (!value) {
-        return null;
-    }
-    if (!ignoreError && value.err) {
-        // That's how solana-web3js does it, `err` here is an object that won't really be handled
-        throw new types_js_1.TransactionFailedError(`Raw transaction ${signature} failed (${JSON.stringify({ err: value.err })})`);
-    }
-    switch (connection.commitment) {
-        case "confirmed":
-        case "single":
-        case "singleGossip": {
-            if (value.confirmationStatus === "processed") {
-                return null;
-            }
-            break;
-        }
-        case "finalized":
-        case "max":
-        case "root": {
-            if (value.confirmationStatus === "processed" || value.confirmationStatus === "confirmed") {
-                return null;
-            }
-            break;
-        }
-        // exhaust enums to ensure full coverage
-        case "processed":
-        case "recent":
-    }
-    return value;
-}
-/**
- * Shorthand call signature for getAssociatedTokenAddress, with allowance for address to be offCurve
- * @param {PublicKey} mint - SPL token Mint address.
- * @param {PublicKey} owner - Owner of the Associated Token Address
- * @param {PublicKey} programId - Program ID of the mint
- * @return {Promise<PublicKey>} - Associated Token Address
- */
-function ata(mint, owner, programId) {
-    return (0, spl_token_1.getAssociatedTokenAddress)(mint, owner, true, programId);
-}
-/**
- * Function that checks whether ATA exists for each provided owner
- * @param connection - Solana client connection
- * @param paramsBatch - Array of Params for each ATA account: {mint, owner}
- * @returns Array of boolean where each member corresponds to an owner
- */
-async function ataBatchExist(connection, paramsBatch) {
-    const tokenAccounts = await Promise.all(paramsBatch.map(async ({ mint, owner, programId }) => {
-        return ata(mint, owner, programId);
-    }));
-    const response = await connection.getMultipleAccountsInfo(tokenAccounts);
-    return response.map((accInfo) => !!accInfo);
-}
-async function enrichAtaParams(connection, paramsBatch) {
-    const programIdByMint = {};
-    return Promise.all(paramsBatch.map(async (params) => {
-        if (params.programId) {
-            return params;
-        }
-        const mintStr = params.mint.toString();
-        if (!(mintStr in programIdByMint)) {
-            const { tokenProgramId } = await getMintAndProgram(connection, params.mint);
-            programIdByMint[mintStr] = tokenProgramId;
-        }
-        params.programId = programIdByMint[mintStr];
-        return params;
-    }));
-}
-/**
- * Generates a Transaction to create ATA for an array of owners
- * @param connection - Solana client connection
- * @param payer - Transaction invoker, should be a signer
- * @param paramsBatch - Array of Params for an each ATA account: {mint, owner}
- * @param commitment - optional commitment that will be used to fetch Blockhash
- * @returns Unsigned Transaction with create ATA instructions
- */
-async function generateCreateAtaBatchTx(connection, payer, paramsBatch, commitment) {
-    paramsBatch = await enrichAtaParams(connection, paramsBatch);
-    const ixs = await Promise.all(paramsBatch.map(async ({ mint, owner, programId }) => {
-        return (0, spl_token_1.createAssociatedTokenAccountInstruction)(payer, await ata(mint, owner), owner, mint, programId);
-    }));
-    const { value: hash, context } = await connection.getLatestBlockhashAndContext({ commitment });
-    const messageV0 = new web3_js_1.TransactionMessage({
-        payerKey: payer,
-        recentBlockhash: hash.blockhash,
-        instructions: ixs,
-    }).compileToV0Message();
-    const tx = new web3_js_1.VersionedTransaction(messageV0);
-    return { tx, hash, context };
-}
-/**
- * Creates ATA for an array of owners
- * @param connection - Solana client connection
- * @param invoker - Transaction invoker and payer
- * @param paramsBatch - Array of Params for an each ATA account: {mint, owner}
- * @param commitment - optional commitment that will be used to fetch Blockhash
- * @param rate - throttle rate for tx sending
- * @returns Transaction signature
- */
-async function createAtaBatch(connection, invoker, paramsBatch, commitment, rate) {
-    const { tx, hash, context } = await generateCreateAtaBatchTx(connection, invoker.publicKey, await enrichAtaParams(connection, paramsBatch), commitment);
-    return signAndExecuteTransaction(connection, invoker, tx, { hash, context, commitment }, { sendRate: rate });
-}
-/**
- * Utility function that checks whether associated token accounts exist and return instructions to populate them if not
- * @param connection - Solana client connection
- * @param owners - Array of ATA owners
- * @param mint - Mint for which ATA will be checked
- * @param invoker - Transaction invoker and payer
- * @param programId - Program ID of the Mint
- * @returns Array of Transaction Instructions that should be added to a transaction
- */
-async function checkOrCreateAtaBatch(connection, owners, mint, invoker, programId) {
-    const ixs = [];
-    if (!programId) {
-        programId = (await getMintAndProgram(connection, mint)).tokenProgramId;
-    }
-    // TODO: optimize fetching and maps/arrays
-    const atas = [];
-    for (const owner of owners) {
-        atas.push(await ata(mint, owner, programId));
-    }
-    const response = await connection.getMultipleAccountsInfo(atas);
-    for (let i = 0; i < response.length; i++) {
-        if (!response[i]) {
-            ixs.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(invoker.publicKey, atas[i], owners[i], mint, programId));
-        }
-    }
-    return ixs;
-}
-/**
- * Create Base instructions for Solana
- * - sets compute price if `computePrice` is provided
- * - sets compute limit if `computeLimit` is provided
- */
-function prepareBaseInstructions(connection, { computePrice, computeLimit }) {
-    const ixs = [];
-    if (computePrice) {
-        ixs.push(web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: computePrice }));
-    }
-    if (computeLimit) {
-        ixs.push(web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: computeLimit }));
-    }
-    return ixs;
-}
-/**
- * Retrieve information about a mint and its program ID, support all Token Programs.
- *
- * @param connection Connection to use
- * @param address    Mint account
- * @param commitment Desired level of commitment for querying the state
- *
- * @return Mint information
- */
-async function getMintAndProgram(connection, address, commitment) {
-    const accountInfo = await connection.getAccountInfo(address, commitment);
-    let programId = accountInfo?.owner;
-    if (!programId?.equals(spl_token_1.TOKEN_PROGRAM_ID) && !programId?.equals(spl_token_1.TOKEN_2022_PROGRAM_ID)) {
-        programId = spl_token_1.TOKEN_PROGRAM_ID;
-    }
-    return {
-        mint: (0, spl_token_1.unpackMint)(address, accountInfo, programId),
-        tokenProgramId: programId,
-    };
-}
-/**
- * Split fetching of Multiple Accounts Info into batches of 100
- * as the maximum number of accounts that can be fetched in a single call is 100
- *
- * @param connection Connection to use
- * @param pubKeys Array of public keys to fetch account info for
- * @param commitment Desired level of commitment for querying the state
- *
- * @return Array of AccountInfo objects
- */
-async function getMultipleAccountsInfoBatched(connection, pubKeys, commitment) {
-    const batchSize = 99;
-    const batches = [];
-    for (let i = 0; i < pubKeys.length; i += batchSize) {
-        const batch = pubKeys.slice(i, i + batchSize);
-        batches.push(connection.getMultipleAccountsInfo(batch, commitment));
-    }
-    const results = await Promise.all(batches);
-    return results.flat();
-}

package/dist/cjs/types.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContractError = exports.IChain = exports.ICluster = void 0;
-// Utility types
-var ICluster;
-(function (ICluster) {
-    ICluster["Mainnet"] = "mainnet";
-    ICluster["Devnet"] = "devnet";
-    ICluster["Testnet"] = "testnet";
-    ICluster["Local"] = "local";
-})(ICluster || (exports.ICluster = ICluster = {}));
-var IChain;
-(function (IChain) {
-    IChain["Solana"] = "Solana";
-    IChain["Aptos"] = "Aptos";
-    IChain["Ethereum"] = "Ethereum";
-    IChain["BNB"] = "BNB";
-    IChain["Polygon"] = "Polygon";
-    IChain["Sui"] = "Sui";
-})(IChain || (exports.IChain = IChain = {}));
-/**
- * Error wrapper for calls made to the contract on chain
- */
-class ContractError extends Error {
-    /**
-     * Constructs the Error Wrapper
-     * @param error Original error raised probably by the chain SDK
-     * @param code extracted code from the error if managed to parse it
-     */
-    constructor(error, code, description) {
-        super(error.message); // Call the base class constructor with the error message
-        this.contractErrorCode = code ?? null;
-        this.description = description ?? null;
-        // Copy properties from the original error
-        Object.setPrototypeOf(this, ContractError.prototype);
-        this.name = "ContractError"; // Set the name property
-        this.stack = error.stack;
-    }
-}
-exports.ContractError = ContractError;

package/dist/esm/lib/assertions.d.ts

@@ -1 +0,0 @@
-export declare const invariant: (condition: any, message?: string | (() => string)) => asserts condition;

package/dist/esm/lib/assertions.js

@@ -1,9 +0,0 @@
-const prefix = "Assertion failed";
-export const invariant = (condition, message) => {
-    if (condition) {
-        return;
-    }
-    const provided = typeof message === "function" ? message() : message;
-    const value = provided ? `${prefix}: ${provided}` : prefix;
-    throw new Error(value);
-};

package/dist/esm/lib/utils.d.ts

@@ -1,28 +0,0 @@
-import BN from "bn.js";
-/**
- * Used for conversion of token amounts to their Big Number representation.
- * Get Big Number representation in the smallest units from the same value in the highest units.
- * @param {number} value - Number of tokens you want to convert to its BN representation.
- * @param {number} decimals - Number of decimals the token has.
- */
-export declare const getBN: (value: number, decimals: number) => BN;
-/**
- * Used for token amounts conversion from their Big Number representation to number.
- * Get value in the highest units from BN representation of the same value in the smallest units.
- * @param {BN} value - Big Number representation of value in the smallest units.
- * @param {number} decimals - Number of decimals the token has.
- */
-export declare const getNumberFromBN: (value: BN, decimals: number) => number;
-/**
- * Used to make on chain calls to the contract and wrap raised errors if any
- * @param func function that interacts with the contract
- * @param callback callback that may be used to extract error code
- * @returns {T}
- */
-export declare function handleContractError<T>(func: () => Promise<T>, callback?: (err: Error) => string | null): Promise<T>;
-/**
- * Pause async function execution for given amount of milliseconds
- * @param ms millisecond to sleep for
- */
-export declare function sleep(ms: number): Promise<void>;
-export declare const divCeilN: (n: bigint, d: bigint) => bigint;

package/dist/esm/lib/utils.js

@@ -1,51 +0,0 @@
-import BN from "bn.js";
-import { ContractError } from "../types.js";
-/**
- * Used for conversion of token amounts to their Big Number representation.
- * Get Big Number representation in the smallest units from the same value in the highest units.
- * @param {number} value - Number of tokens you want to convert to its BN representation.
- * @param {number} decimals - Number of decimals the token has.
- */
-export const getBN = (value, decimals) => {
-    const decimalPart = value - Math.trunc(value);
-    const integerPart = new BN(Math.trunc(value));
-    const decimalE = new BN(decimalPart * 1e9);
-    const sum = integerPart.mul(new BN(1e9)).add(decimalE);
-    const resultE = sum.mul(new BN(10).pow(new BN(decimals)));
-    return resultE.div(new BN(1e9));
-};
-/**
- * Used for token amounts conversion from their Big Number representation to number.
- * Get value in the highest units from BN representation of the same value in the smallest units.
- * @param {BN} value - Big Number representation of value in the smallest units.
- * @param {number} decimals - Number of decimals the token has.
- */
-export const getNumberFromBN = (value, decimals) => value.gt(new BN(2 ** 53 - 1)) ? value.div(new BN(10 ** decimals)).toNumber() : value.toNumber() / 10 ** decimals;
-/**
- * Used to make on chain calls to the contract and wrap raised errors if any
- * @param func function that interacts with the contract
- * @param callback callback that may be used to extract error code
- * @returns {T}
- */
-export async function handleContractError(func, callback) {
-    try {
-        return await func();
-    }
-    catch (err) {
-        if (err instanceof Error) {
-            if (callback) {
-                throw new ContractError(err, callback(err));
-            }
-            throw new ContractError(err);
-        }
-        throw err;
-    }
-}
-/**
- * Pause async function execution for given amount of milliseconds
- * @param ms millisecond to sleep for
- */
-export function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-export const divCeilN = (n, d) => n / d + (n % d ? BigInt(1) : BigInt(0));

package/dist/esm/solana/account-filters.d.ts

@@ -1,2 +0,0 @@
-import { MemcmpFilter, PublicKey } from "@solana/web3.js";
-export declare const getFilters: <T extends Record<string, number | PublicKey>>(criteria: T, byteOffsets: Record<keyof T, number>) => MemcmpFilter[];

package/dist/esm/solana/account-filters.js

@@ -1,15 +0,0 @@
-export const getFilters = (criteria, byteOffsets) => {
-    return Object.entries(criteria).reduce((acc, [key, value]) => {
-        const criteriaKey = key;
-        const effectiveByteOffset = byteOffsets[criteriaKey];
-        if (criteria[criteriaKey] && effectiveByteOffset) {
-            acc.push({
-                memcmp: {
-                    offset: effectiveByteOffset,
-                    bytes: value.toString(),
-                },
-            });
-        }
-        return acc;
-    }, []);
-};

package/dist/esm/solana/instructions.d.ts

@@ -1,3 +0,0 @@
-import { Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
-import BN from "bn.js";
-export declare const prepareWrappedAccount: (connection: Connection, senderAddress: PublicKey, amount: BN) => Promise<TransactionInstruction[]>;

package/dist/esm/solana/instructions.js

@@ -1,18 +0,0 @@
-import { getAssociatedTokenAddress, NATIVE_MINT, createAssociatedTokenAccountInstruction, createSyncNativeInstruction, } from "@solana/spl-token";
-import { SystemProgram } from "@solana/web3.js";
-export const prepareWrappedAccount = async (connection, senderAddress, amount) => {
-    const tokenAccount = await getAssociatedTokenAddress(NATIVE_MINT, senderAddress, true);
-    const accInfo = await connection.getParsedAccountInfo(tokenAccount);
-    const instructions = (accInfo.value?.lamports ?? 0) > 0
-        ? []
-        : [createAssociatedTokenAccountInstruction(senderAddress, tokenAccount, senderAddress, NATIVE_MINT)];
-    return [
-        ...instructions,
-        SystemProgram.transfer({
-            fromPubkey: senderAddress,
-            toPubkey: tokenAccount,
-            lamports: amount.toNumber(),
-        }),
-        createSyncNativeInstruction(tokenAccount),
-    ];
-};

package/dist/esm/solana/public-key.d.ts

@@ -1,7 +0,0 @@
-import { PublicKey } from "@solana/web3.js";
-/**
- * Converts a string or PublicKey to a PublicKey object.
- * @param address - The input address as a string or PublicKey.
- * @returns The PublicKey object.
- */
-export declare const pk: (address: string | PublicKey) => PublicKey;

package/dist/esm/solana/public-key.js

@@ -1,9 +0,0 @@
-import { PublicKey } from "@solana/web3.js";
-/**
- * Converts a string or PublicKey to a PublicKey object.
- * @param address - The input address as a string or PublicKey.
- * @returns The PublicKey object.
- */
-export const pk = (address) => {
-    return typeof address === "string" ? new PublicKey(address) : address;
-};