@lightprotocol/stateless.js 0.8.0 → 0.9.0

package/dist/es/browser/index.js

@@ -7508,7 +7508,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 +7555,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 +7605,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 +12446,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 +12548,7 @@ const TokenBalanceResult = type({
 });
 const TokenBalanceListResult = type({
     tokenBalances: array(TokenBalanceResult),
-    cursor: nullable(PublicKeyFromString),
+    cursor: nullable(string()),
 });
 const AccountProofResult = type({
     hash: array(number()),
@@ -12571,7 +12571,7 @@ const SignatureListWithCursorResult = type({
         signature: string(),
         slot: number(),
     })),
-    cursor: nullable(PublicKeyFromString),
+    cursor: nullable(string()),
 });
 const CompressedTransactionResult = type({
     compressionInfo: type({
@@ -12638,7 +12638,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 +12933,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 +13002,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 +13085,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 +13103,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 +13120,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 +18780,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 +18907,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 +18982,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 +19027,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