@lightprotocol/stateless.js 0.8.0 → 0.10.0

package/dist/es/browser/index.js

@@ -6989,15 +6989,16 @@ if (import.meta.vitest) {
  * @param instructions        instructions to include
  * @param payerPublicKey      fee payer public key
  * @param blockhash          blockhash to use
+ * @param lookupTableAccounts  lookup table accounts to include
  *
  * @return VersionedTransaction
  */
-function buildTx(instructions, payerPublicKey, blockhash) {
+function buildTx(instructions, payerPublicKey, blockhash, lookupTableAccounts) {
     const messageV0 = new TransactionMessage({
         payerKey: payerPublicKey,
         recentBlockhash: blockhash,
         instructions,
-    }).compileToV0Message();
+    }).compileToV0Message(lookupTableAccounts);
     return new VersionedTransaction(messageV0);
 }
 /**
@@ -7053,12 +7054,13 @@ async function confirmTx(rpc, txId, confirmOptions, blockHashCtx) {
  * @param payer               payer of the transaction
  * @param blockhash           recent blockhash to use in the transaction
  * @param additionalSigners   non-feepayer signers to include in the transaction
+ * @param lookupTableAccounts  lookup table accounts to include in the transaction
  */
-function buildAndSignTx(instructions, payer, blockhash, additionalSigners = []) {
+function buildAndSignTx(instructions, payer, blockhash, additionalSigners = [], lookupTableAccounts) {
     if (additionalSigners.includes(payer))
         throw new Error('payer must not be in additionalSigners');
     const allSigners = [payer, ...additionalSigners];
-    const tx = buildTx(instructions, payer.publicKey, blockhash);
+    const tx = buildTx(instructions, payer.publicKey, blockhash, lookupTableAccounts);
     tx.sign(allSigners);
     return tx;
 }
@@ -7508,7 +7510,7 @@ async function createAccount(rpc, payer, seed, programId, addressTree, addressQu
 async function createAccountWithLamports(rpc, payer, seed, lamports, programId, addressTree, addressQueue, outputStateTree, confirmOptions) {
     lamports = bn(lamports);
     const compressedAccounts = await rpc.getCompressedAccountsByOwner(payer.publicKey);
-    const [inputAccounts] = selectMinCompressedSolAccountsForTransfer(compressedAccounts, lamports);
+    const [inputAccounts] = selectMinCompressedSolAccountsForTransfer(compressedAccounts.items, lamports);
     const { blockhash } = await rpc.getLatestBlockhash();
     addressTree = addressTree ?? defaultTestStateTreeAccounts().addressTree;
     addressQueue = addressQueue ?? defaultTestStateTreeAccounts().addressQueue;
@@ -7555,7 +7557,7 @@ async function createAccountWithLamports(rpc, payer, seed, lamports, programId,
 /// TODO: add support for payer != owner
 async function decompress(rpc, payer, lamports, recipient, outputStateTree, confirmOptions) {
     /// TODO: use dynamic state tree and nullifier queue
-    const userCompressedAccountsWithMerkleContext = await rpc.getCompressedAccountsByOwner(payer.publicKey);
+    const userCompressedAccountsWithMerkleContext = (await rpc.getCompressedAccountsByOwner(payer.publicKey)).items;
     lamports = bn(lamports);
     const inputLamports = sumUpLamports(userCompressedAccountsWithMerkleContext);
     if (lamports.gt(inputLamports)) {
@@ -7605,7 +7607,7 @@ async function transfer(rpc, payer, lamports, owner, toAddress,
 merkleTree, confirmOptions) {
     lamports = bn(lamports);
     const compressedAccounts = await rpc.getCompressedAccountsByOwner(owner.publicKey);
-    const [inputAccounts] = selectMinCompressedSolAccountsForTransfer(compressedAccounts, lamports);
+    const [inputAccounts] = selectMinCompressedSolAccountsForTransfer(compressedAccounts.items, lamports);
     const proof = await rpc.getValidityProof(inputAccounts.map(account => bn(account.hash)));
     const ix = await LightSystemProgram.transfer({
         payer: payer.publicKey,
@@ -12446,14 +12448,14 @@ const MultipleCompressedAccountsResult = type({
  */
 const CompressedAccountsByOwnerResult = type({
     items: array(CompressedAccountResult),
-    cursor: nullable(PublicKeyFromString),
+    cursor: nullable(string()),
 });
 /**
  * @internal
  */
 const CompressedTokenAccountsByOwnerOrDelegateResult = type({
     items: array(CompressedTokenAccountResult),
-    cursor: nullable(PublicKeyFromString),
+    cursor: nullable(string()),
 });
 /**
  * @internal
@@ -12548,7 +12550,7 @@ const TokenBalanceResult = type({
 });
 const TokenBalanceListResult = type({
     tokenBalances: array(TokenBalanceResult),
-    cursor: nullable(PublicKeyFromString),
+    cursor: nullable(string()),
 });
 const AccountProofResult = type({
     hash: array(number()),
@@ -12571,7 +12573,7 @@ const SignatureListWithCursorResult = type({
         signature: string(),
         slot: number(),
     })),
-    cursor: nullable(PublicKeyFromString),
+    cursor: nullable(string()),
 });
 const CompressedTransactionResult = type({
     compressionInfo: type({
@@ -12638,7 +12640,10 @@ async function getCompressedTokenAccountsByOwnerOrDelegate(rpc, ownerOrDelegate,
         });
     });
     /// TODO: consider custom or different sort. Most recent here.
-    return accounts.sort((a, b) => b.compressedAccount.leafIndex - a.compressedAccount.leafIndex);
+    return {
+        items: accounts.sort((a, b) => b.compressedAccount.leafIndex - a.compressedAccount.leafIndex),
+        cursor: res.result.value.cursor,
+    };
 }
 /** @internal */
 function buildCompressedAccountWithMaybeTokenData(accountStructWithOptionalTokenData) {
@@ -12930,14 +12935,20 @@ class Rpc extends Connection {
             throw new SolanaJSONRPCError(res.error, `failed to get info for compressed accounts owned by ${owner.toBase58()}`);
         }
         if (res.result.value === null) {
-            return [];
+            return {
+                items: [],
+                cursor: null,
+            };
         }
         const accounts = [];
         res.result.value.items.map(item => {
             const account = createCompressedAccountWithMerkleContext(createMerkleContext(item.tree, mockNullifierQueue, item.hash.toArray('be', 32), item.leafIndex), item.owner, bn(item.lamports), item.data ? parseAccountData(item.data) : undefined, item.address || undefined);
             accounts.push(account);
         });
-        return accounts.sort((a, b) => b.leafIndex - a.leafIndex);
+        return {
+            items: accounts.sort((a, b) => b.leafIndex - a.leafIndex),
+            cursor: res.result.value.cursor,
+        };
     }
     /**
      * Fetch all the compressed token accounts owned by the specified public
@@ -12993,7 +13004,10 @@ class Rpc extends Connection {
         const maybeFiltered = options.mint
             ? res.result.value.tokenBalances.filter(tokenBalance => tokenBalance.mint.toBase58() === options.mint.toBase58())
             : res.result.value.tokenBalances;
-        return maybeFiltered;
+        return {
+            items: maybeFiltered,
+            cursor: res.result.value.cursor,
+        };
     }
     /**
      * Returns confirmed compression signatures for transactions involving the specified
@@ -13073,7 +13087,7 @@ class Rpc extends Connection {
         if (res.result.value === null) {
             throw new Error(`failed to get signatures for address ${address.toBase58()}`);
         }
-        return res.result.value.items;
+        return res.result.value;
     }
     /**
      * Returns confirmed signatures for compression transactions involving the
@@ -13091,7 +13105,7 @@ class Rpc extends Connection {
         if (res.result.value === null) {
             throw new Error(`failed to get signatures for owner ${owner.toBase58()}`);
         }
-        return res.result.value.items;
+        return res.result.value;
     }
     /// TODO(photon): needs mint
     /**
@@ -13108,7 +13122,7 @@ class Rpc extends Connection {
         if (res.result.value === null) {
             throw new Error(`failed to get signatures for owner ${owner.toBase58()}`);
         }
-        return res.result.value.items;
+        return res.result.value;
     }
     /**
      * Fetch the current indexer health status
@@ -18768,13 +18782,19 @@ async function getCompressedTokenAccountsByOwnerTest(rpc, owner, mint) {
     const events = await getParsedEvents(rpc);
     const compressedTokenAccounts = await getCompressedTokenAccounts(events);
     const accounts = compressedTokenAccounts.filter(acc => acc.parsed.owner.equals(owner) && acc.parsed.mint.equals(mint));
-    return accounts.sort((a, b) => b.compressedAccount.leafIndex - a.compressedAccount.leafIndex);
+    return {
+        items: accounts.sort((a, b) => b.compressedAccount.leafIndex - a.compressedAccount.leafIndex),
+        cursor: null,
+    };
 }
 async function getCompressedTokenAccountsByDelegateTest(rpc, delegate, mint) {
     const events = await getParsedEvents(rpc);
     const compressedTokenAccounts = await getCompressedTokenAccounts(events);
-    return compressedTokenAccounts.filter(acc => acc.parsed.delegate?.equals(delegate) &&
-        acc.parsed.mint.equals(mint));
+    return {
+        items: compressedTokenAccounts.filter(acc => acc.parsed.delegate?.equals(delegate) &&
+            acc.parsed.mint.equals(mint)),
+        cursor: null,
+    };
 }
 async function getCompressedTokenAccountByHashTest(rpc, hash) {
     const events = await getParsedEvents(rpc);
@@ -18889,7 +18909,7 @@ class TestRpc extends Connection {
      */
     async getCompressedBalanceByOwner(owner) {
         const accounts = await this.getCompressedAccountsByOwner(owner);
-        return accounts.reduce((acc, account) => acc.add(account.lamports), bn(0));
+        return accounts.items.reduce((acc, account) => acc.add(account.lamports), bn(0));
     }
     /**
      * Fetch the latest merkle proof for the specified account hash from the
@@ -18964,7 +18984,10 @@ class TestRpc extends Connection {
      */
     async getCompressedAccountsByOwner(owner) {
         const accounts = await getCompressedAccountsByOwnerTest(this, owner);
-        return accounts;
+        return {
+            items: accounts,
+            cursor: null,
+        };
     }
     /**
      * Fetch the latest compression signatures on the cluster. Results are
@@ -19006,10 +19029,13 @@ class TestRpc extends Connection {
      */
     async getCompressedTokenBalancesByOwner(publicKey, options) {
         const accounts = await getCompressedTokenAccountsByOwnerTest(this, publicKey, options.mint);
-        return accounts.map(account => ({
-            balance: bn(account.parsed.amount),
-            mint: account.parsed.mint,
-        }));
+        return {
+            items: accounts.items.map(account => ({
+                balance: bn(account.parsed.amount),
+                mint: account.parsed.mint,
+            })),
+            cursor: null,
+        };
     }
     /**
      * Returns confirmed signatures for transactions involving the specified