@streamflow/common 8.3.1 → 8.6.0

package/dist/cjs/solana/index.d.cts

@@ -1,5 +1,5 @@
 import * as _solana_web3_js from '@solana/web3.js';
-import { PublicKey, MemcmpFilter, Connection, TransactionInstruction, VersionedTransaction, AccountInfo, BlockhashWithExpiryBlockHeight, Context, Commitment, Keypair, Transaction, RpcResponseAndContext, SimulatedTransactionResponse, SignatureStatus } from '@solana/web3.js';
+import { PublicKey, MemcmpFilter, Connection, TransactionInstruction, VersionedTransaction, AccountInfo, BlockhashWithExpiryBlockHeight, Context, Commitment, Keypair, Transaction, AddressLookupTableAccount, RpcResponseAndContext, SimulatedTransactionResponse, SignatureStatus } from '@solana/web3.js';
 import BN from 'bn.js';
 import PQueue from 'p-queue';
 import { Mint } from '@solana/spl-token';
@@ -11,9 +11,24 @@ declare const prepareWrappedAccount: (connection: Connection, senderAddress: Pub
 
 type ComputePriceEstimate = (tx: string | (string | PublicKey)[]) => Promise<number>;
 type ComputeLimitEstimate = (tx: VersionedTransaction) => Promise<number>;
+/**
+ * Additional parameter for Solana Transaction processing.
+ *
+ * computePrice - compute price per CU in micro-lamports to be set in a transaction - priority fee, accepts:
+ *  - a constant number;
+ *  - a callable that returns a price for a built transaction;
+ * computeLimit - compute limit in CUs to set for a transaction, `computePrice` is paid per every allocated CU, accepts:
+ *  - a constant number;
+ *  - a callable that returns a CU limit for a built transaction;
+ *  - `autoSimulate` - will be unwrapped by `unwrapExecutionParams` and converted to a callable that runs a simulation to estimate CUs and set a limit with some margin;
+ * feePayer - account that will be set as sol fee payer in instructions that accept such account, i.e. ATA creation:
+ *  - should be only when building instructions via `prepare` methods, as tx executing methods will fail without a signer;
+ *  - currently supported only when claiming an Airdrop;
+ */
 interface ITransactionSolanaExt {
     computePrice?: number | ComputePriceEstimate;
     computeLimit?: number | ComputeLimitEstimate | "autoSimulate";
+    feePayer?: PublicKey;
 }
 /**
  * Acceptable type with resolved values.
@@ -22,6 +37,7 @@ interface ITransactionSolanaExt {
 type ITransactionSolanaExtResolvedValues = {
     computePrice?: number | ComputePriceEstimate;
     computeLimit?: number | ComputeLimitEstimate;
+    feePayer?: PublicKey;
 };
 type KeysNotOfA<T, ToExclude> = Pick<T, Exclude<keyof T, keyof ToExclude>>;
 type ITransactionSolanaExtResolved<T extends ITransactionSolanaExt = ITransactionSolanaExt> = {
@@ -104,14 +120,15 @@ declare function isTransactionVersioned(tx: Transaction | VersionedTransaction):
  * @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
+ * @param lookupTables - lookup table accounts to use in the transaction
  * @returns Transaction and Blockhash
  */
-declare function prepareTransaction(connection: Connection, ixs: TransactionInstruction[], payer: PublicKey | undefined | null, commitment?: Commitment, partialSigners?: (Keypair | undefined)[]): Promise<{
+declare function prepareTransaction(connection: Connection, ixs: TransactionInstruction[], payer: PublicKey | undefined | null, commitment?: Commitment, partialSigners?: (Keypair | undefined)[], lookupTables?: AddressLookupTableAccount[]): Promise<{
     tx: VersionedTransaction;
     hash: BlockhashWithExpiryBlockHeight;
     context: Context;
 }>;
-declare function createVersionedTransaction(ixs: TransactionInstruction[], payer: PublicKey | undefined | null, recentBlockhash: BlockhashWithExpiryBlockHeight["blockhash"], partialSigners?: (Keypair | undefined)[]): VersionedTransaction;
+declare function createVersionedTransaction(ixs: TransactionInstruction[], payer: PublicKey | undefined | null, recentBlockhash: BlockhashWithExpiryBlockHeight["blockhash"], partialSigners?: (Keypair | undefined)[], lookupTables?: AddressLookupTableAccount[]): VersionedTransaction;
 declare function signTransaction<T extends Transaction | VersionedTransaction>(invoker: Keypair | SignerWalletAdapter, tx: T): Promise<T>;
 /**
  * Signs, sends and confirms Transaction
@@ -219,9 +236,10 @@ declare function createAtaBatch(connection: Connection, invoker: Keypair | Signe
  * @param mint - Mint for which ATA will be checked
  * @param invoker - Transaction invoker and payer
  * @param programId - Program ID of the Mint
+ * @param payer - optional payer account, will be used instead of invoker as `source`
  * @returns Array of Transaction Instructions that should be added to a transaction
  */
-declare function checkOrCreateAtaBatch(connection: Connection, owners: PublicKey[], mint: PublicKey, invoker: SignerWalletAdapter | Keypair, programId?: PublicKey): Promise<TransactionInstruction[]>;
+declare function checkOrCreateAtaBatch(connection: Connection, owners: PublicKey[], mint: PublicKey, invoker: SignerWalletAdapter | Keypair, programId?: PublicKey, payer?: PublicKey): Promise<TransactionInstruction[]>;
 /**
  * Create Base instructions for Solana
  * - sets compute price if `computePrice` is provided. If `computePrice` is a function, it will be ignored (the value must be resolved before calling this function).

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

@@ -1,5 +1,5 @@
 import * as _solana_web3_js from '@solana/web3.js';
-import { PublicKey, MemcmpFilter, Connection, TransactionInstruction, VersionedTransaction, AccountInfo, BlockhashWithExpiryBlockHeight, Context, Commitment, Keypair, Transaction, RpcResponseAndContext, SimulatedTransactionResponse, SignatureStatus } from '@solana/web3.js';
+import { PublicKey, MemcmpFilter, Connection, TransactionInstruction, VersionedTransaction, AccountInfo, BlockhashWithExpiryBlockHeight, Context, Commitment, Keypair, Transaction, AddressLookupTableAccount, RpcResponseAndContext, SimulatedTransactionResponse, SignatureStatus } from '@solana/web3.js';
 import BN from 'bn.js';
 import PQueue from 'p-queue';
 import { Mint } from '@solana/spl-token';
@@ -11,9 +11,24 @@ declare const prepareWrappedAccount: (connection: Connection, senderAddress: Pub
 
 type ComputePriceEstimate = (tx: string | (string | PublicKey)[]) => Promise<number>;
 type ComputeLimitEstimate = (tx: VersionedTransaction) => Promise<number>;
+/**
+ * Additional parameter for Solana Transaction processing.
+ *
+ * computePrice - compute price per CU in micro-lamports to be set in a transaction - priority fee, accepts:
+ *  - a constant number;
+ *  - a callable that returns a price for a built transaction;
+ * computeLimit - compute limit in CUs to set for a transaction, `computePrice` is paid per every allocated CU, accepts:
+ *  - a constant number;
+ *  - a callable that returns a CU limit for a built transaction;
+ *  - `autoSimulate` - will be unwrapped by `unwrapExecutionParams` and converted to a callable that runs a simulation to estimate CUs and set a limit with some margin;
+ * feePayer - account that will be set as sol fee payer in instructions that accept such account, i.e. ATA creation:
+ *  - should be only when building instructions via `prepare` methods, as tx executing methods will fail without a signer;
+ *  - currently supported only when claiming an Airdrop;
+ */
 interface ITransactionSolanaExt {
     computePrice?: number | ComputePriceEstimate;
     computeLimit?: number | ComputeLimitEstimate | "autoSimulate";
+    feePayer?: PublicKey;
 }
 /**
  * Acceptable type with resolved values.
@@ -22,6 +37,7 @@ interface ITransactionSolanaExt {
 type ITransactionSolanaExtResolvedValues = {
     computePrice?: number | ComputePriceEstimate;
     computeLimit?: number | ComputeLimitEstimate;
+    feePayer?: PublicKey;
 };
 type KeysNotOfA<T, ToExclude> = Pick<T, Exclude<keyof T, keyof ToExclude>>;
 type ITransactionSolanaExtResolved<T extends ITransactionSolanaExt = ITransactionSolanaExt> = {
@@ -104,14 +120,15 @@ declare function isTransactionVersioned(tx: Transaction | VersionedTransaction):
  * @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
+ * @param lookupTables - lookup table accounts to use in the transaction
  * @returns Transaction and Blockhash
  */
-declare function prepareTransaction(connection: Connection, ixs: TransactionInstruction[], payer: PublicKey | undefined | null, commitment?: Commitment, partialSigners?: (Keypair | undefined)[]): Promise<{
+declare function prepareTransaction(connection: Connection, ixs: TransactionInstruction[], payer: PublicKey | undefined | null, commitment?: Commitment, partialSigners?: (Keypair | undefined)[], lookupTables?: AddressLookupTableAccount[]): Promise<{
     tx: VersionedTransaction;
     hash: BlockhashWithExpiryBlockHeight;
     context: Context;
 }>;
-declare function createVersionedTransaction(ixs: TransactionInstruction[], payer: PublicKey | undefined | null, recentBlockhash: BlockhashWithExpiryBlockHeight["blockhash"], partialSigners?: (Keypair | undefined)[]): VersionedTransaction;
+declare function createVersionedTransaction(ixs: TransactionInstruction[], payer: PublicKey | undefined | null, recentBlockhash: BlockhashWithExpiryBlockHeight["blockhash"], partialSigners?: (Keypair | undefined)[], lookupTables?: AddressLookupTableAccount[]): VersionedTransaction;
 declare function signTransaction<T extends Transaction | VersionedTransaction>(invoker: Keypair | SignerWalletAdapter, tx: T): Promise<T>;
 /**
  * Signs, sends and confirms Transaction
@@ -219,9 +236,10 @@ declare function createAtaBatch(connection: Connection, invoker: Keypair | Signe
  * @param mint - Mint for which ATA will be checked
  * @param invoker - Transaction invoker and payer
  * @param programId - Program ID of the Mint
+ * @param payer - optional payer account, will be used instead of invoker as `source`
  * @returns Array of Transaction Instructions that should be added to a transaction
  */
-declare function checkOrCreateAtaBatch(connection: Connection, owners: PublicKey[], mint: PublicKey, invoker: SignerWalletAdapter | Keypair, programId?: PublicKey): Promise<TransactionInstruction[]>;
+declare function checkOrCreateAtaBatch(connection: Connection, owners: PublicKey[], mint: PublicKey, invoker: SignerWalletAdapter | Keypair, programId?: PublicKey, payer?: PublicKey): Promise<TransactionInstruction[]>;
 /**
  * Create Base instructions for Solana
  * - sets compute price if `computePrice` is provided. If `computePrice` is a function, it will be ignored (the value must be resolved before calling this function).

package/dist/esm/solana/index.js

@@ -741,24 +741,24 @@ function isSignerKeypair(walletOrKeypair) {
 function isTransactionVersioned(tx) {
   return "message" in tx;
 }
-async function prepareTransaction(connection, ixs, payer, commitment, partialSigners) {
+async function prepareTransaction(connection, ixs, payer, commitment, partialSigners, lookupTables) {
   if (!payer) {
     throw new Error("Payer public key is not provided!");
   }
   const { value: hash, context } = await connection.getLatestBlockhashAndContext(commitment);
   return {
-    tx: createVersionedTransaction(ixs, payer, hash.blockhash, partialSigners),
+    tx: createVersionedTransaction(ixs, payer, hash.blockhash, partialSigners, lookupTables),
     hash,
     context
   };
 }
-function createVersionedTransaction(ixs, payer, recentBlockhash, partialSigners) {
+function createVersionedTransaction(ixs, payer, recentBlockhash, partialSigners, lookupTables) {
   invariant(payer, "Payer public key is not provided!");
   const messageV0 = new TransactionMessage({
     payerKey: payer,
     recentBlockhash,
     instructions: ixs
-  }).compileToV0Message();
+  }).compileToV0Message(lookupTables);
   const tx = new VersionedTransaction(messageV0);
   const signers = partialSigners?.filter((item) => !!item) ?? void 0;
   if (signers) {
@@ -969,7 +969,7 @@ async function createAtaBatch(connection, invoker, paramsBatch, commitment, rate
   );
   return signAndExecuteTransaction(connection, invoker, tx, { hash, context, commitment }, { sendRate: rate });
 }
-async function checkOrCreateAtaBatch(connection, owners, mint, invoker, programId) {
+async function checkOrCreateAtaBatch(connection, owners, mint, invoker, programId, payer) {
   const ixs = [];
   if (!programId) {
     programId = (await getMintAndProgram(connection, mint)).tokenProgramId;
@@ -981,7 +981,9 @@ async function checkOrCreateAtaBatch(connection, owners, mint, invoker, programI
   const response = await connection.getMultipleAccountsInfo(atas);
   for (let i = 0; i < response.length; i++) {
     if (!response[i]) {
-      ixs.push(createAssociatedTokenAccountInstruction(invoker.publicKey, atas[i], owners[i], mint, programId));
+      ixs.push(
+        createAssociatedTokenAccountInstruction(payer ?? invoker.publicKey, atas[i], owners[i], mint, programId)
+      );
     }
   }
   return ixs;