@streamflow/common 7.5.3 → 8.0.0-alpha.p287.5172056

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;
-};

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

@@ -1,39 +0,0 @@
-import { AccountInfo, BlockhashWithExpiryBlockHeight, Commitment, Context, PublicKey } from "@solana/web3.js";
-import PQueue from "p-queue";
-export interface ITransactionSolanaExt {
-    computePrice?: number;
-    computeLimit?: number;
-}
-export interface Account {
-    pubkey: PublicKey;
-    account: AccountInfo<Buffer>;
-}
-export interface CheckAssociatedTokenAccountsData {
-    sender: PublicKey;
-    recipient: PublicKey;
-    partner: PublicKey;
-    streamflowTreasury: PublicKey;
-    mint: PublicKey;
-}
-export interface AtaParams {
-    mint: PublicKey;
-    owner: PublicKey;
-    programId?: PublicKey;
-}
-export interface ConfirmationParams {
-    hash: BlockhashWithExpiryBlockHeight;
-    context: Context;
-    commitment?: Commitment;
-}
-export interface ThrottleParams {
-    sendRate?: number;
-    sendThrottler?: PQueue;
-    waitBeforeConfirming?: number | undefined;
-}
-export interface IProgramAccount<T> {
-    publicKey: PublicKey;
-    account: T;
-}
-export declare class TransactionFailedError extends Error {
-    constructor(m: string);
-}

package/dist/esm/solana/types.js

@@ -1,7 +0,0 @@
-export class TransactionFailedError extends Error {
-    constructor(m) {
-        super(m);
-        Object.setPrototypeOf(this, TransactionFailedError.prototype);
-        this.name = "TransactionFailedError";
-    }
-}

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

@@ -1,187 +0,0 @@
-import { Mint } from "@solana/spl-token";
-import { SignerWalletAdapter } from "@solana/wallet-adapter-base";
-import { BlockhashWithExpiryBlockHeight, Commitment, Connection, Keypair, PublicKey, Transaction, TransactionInstruction, SignatureStatus, VersionedTransaction, Context, RpcResponseAndContext, SimulatedTransactionResponse, AccountInfo } from "@solana/web3.js";
-import PQueue from "p-queue";
-import { Account, AtaParams, ConfirmationParams, ITransactionSolanaExt, ThrottleParams } from "./types.js";
-export declare const buildSendThrottler: (sendRate: number, sendInterval?: number) => PQueue;
-/**
- * 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.
- */
-export declare function getProgramAccounts(connection: Connection, wallet: PublicKey, offset: number, programId: PublicKey): Promise<Account[]>;
-/**
- * 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.
- */
-export declare function isSignerWallet(walletOrKeypair: Keypair | SignerWalletAdapter): walletOrKeypair is SignerWalletAdapter;
-/**
- * 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.
- */
-export declare function isSignerKeypair(walletOrKeypair: Keypair | SignerWalletAdapter): walletOrKeypair is Keypair;
-/**
- * Utility function to check whether given transaction is Versioned
- * @param tx {Transaction | VersionedTransaction} - Transaction to check
- * @returns {boolean} - Returns true if transaction is Versioned.
- */
-export declare function isTransactionVersioned(tx: Transaction | VersionedTransaction): tx is VersionedTransaction;
-/**
- * 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
- */
-export declare function prepareTransaction(connection: Connection, ixs: TransactionInstruction[], payer: PublicKey | undefined | null, commitment?: Commitment, ...partialSigners: (Keypair | undefined)[]): Promise<{
-    tx: VersionedTransaction;
-    hash: BlockhashWithExpiryBlockHeight;
-    context: Context;
-}>;
-export declare function signTransaction<T extends Transaction | VersionedTransaction>(invoker: Keypair | SignerWalletAdapter, tx: T): Promise<T>;
-/**
- * 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
- */
-export declare function signAndExecuteTransaction(connection: Connection, invoker: Keypair | SignerWalletAdapter, tx: Transaction | VersionedTransaction, confirmationParams: ConfirmationParams, throttleParams: ThrottleParams): Promise<string>;
-/**
- * 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
- */
-export declare function executeTransaction(connection: Connection, tx: Transaction | VersionedTransaction, confirmationParams: ConfirmationParams, throttleParams: ThrottleParams): Promise<string>;
-/**
- * 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
- */
-export declare function executeMultipleTransactions(connection: Connection, txs: (Transaction | VersionedTransaction)[], confirmationParams: ConfirmationParams, { sendRate, sendThrottler, ...throttlingParams }: ThrottleParams): Promise<PromiseSettledResult<string>[]>;
-/**
- * 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
- */
-export declare function sendAndConfirmTransaction(connection: Connection, tx: Transaction | VersionedTransaction, { hash, context, commitment }: ConfirmationParams, { sendRate, sendThrottler, waitBeforeConfirming }: ThrottleParams): Promise<string>;
-export declare function simulateTransaction(connection: Connection, tx: Transaction | VersionedTransaction): Promise<RpcResponseAndContext<SimulatedTransactionResponse>>;
-/**
- * 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
- */
-export declare function confirmAndEnsureTransaction(connection: Connection, signature: string, ignoreError?: boolean): Promise<SignatureStatus | null>;
-/**
- * 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
- */
-export declare function ata(mint: PublicKey, owner: PublicKey, programId?: PublicKey): Promise<PublicKey>;
-/**
- * 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
- */
-export declare function ataBatchExist(connection: Connection, paramsBatch: AtaParams[]): Promise<boolean[]>;
-export declare function enrichAtaParams(connection: Connection, paramsBatch: AtaParams[]): Promise<AtaParams[]>;
-/**
- * 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
- */
-export declare function generateCreateAtaBatchTx(connection: Connection, payer: PublicKey, paramsBatch: AtaParams[], commitment?: Commitment): Promise<{
-    tx: VersionedTransaction;
-    hash: BlockhashWithExpiryBlockHeight;
-    context: 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
- */
-export declare function createAtaBatch(connection: Connection, invoker: Keypair | SignerWalletAdapter, paramsBatch: AtaParams[], commitment?: Commitment, rate?: number): Promise<string>;
-/**
- * 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
- */
-export declare function checkOrCreateAtaBatch(connection: Connection, owners: PublicKey[], mint: PublicKey, invoker: SignerWalletAdapter | Keypair, programId?: PublicKey): Promise<TransactionInstruction[]>;
-/**
- * Create Base instructions for Solana
- * - sets compute price if `computePrice` is provided
- * - sets compute limit if `computeLimit` is provided
- */
-export declare function prepareBaseInstructions(connection: Connection, { computePrice, computeLimit }: ITransactionSolanaExt): TransactionInstruction[];
-/**
- * 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
- */
-export declare function getMintAndProgram(connection: Connection, address: PublicKey, commitment?: Commitment): Promise<{
-    mint: Mint;
-    tokenProgramId: PublicKey;
-}>;
-/**
- * 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
- */
-export declare function getMultipleAccountsInfoBatched(connection: Connection, pubKeys: PublicKey[], commitment?: Commitment): Promise<(AccountInfo<Buffer> | null)[]>;