@agglayer/sdk 1.0.0-beta.15 → 1.0.0-beta.17

package/dist/index.mjs

@@ -1395,6 +1395,9 @@ var NETWORKS = {
   CARDONA: 2442
 };
 var DEFAULT_NETWORK = NETWORKS.SEPOLIA;
+var DEFAULT_CHAINS_PER_PAGE = 100;
+var DEFAULT_CHAINS_WITH_TOKENS_PER_PAGE = 1;
+var MAX_TRANSACTIONS_PER_PAGE = 100;
 
 // src/native/index.ts
 var NativeClient = class {
@@ -1623,11 +1626,12 @@ var HttpClient = class {
         continue;
       }
       if (Array.isArray(value)) {
-        value.forEach((item, index) => {
-          if (item !== void 0 && item !== null) {
-            result[`${fullKey}[${index}]`] = String(item);
-          }
-        });
+        const filteredValues = value.filter(
+          (item) => item !== void 0 && item !== null
+        );
+        if (filteredValues.length > 0) {
+          result[fullKey] = filteredValues.join(",");
+        }
       } else if (typeof value === "object") {
         Object.assign(
           result,
@@ -1657,16 +1661,17 @@ var ArcApiService = class {
     this.httpClient = new HttpClient({ baseUrl, timeout });
   }
   // responsible for both chains metadata and tokens
+  // supports limit/offset based pagination
   async chains({
     withSupportedTokens = false,
-    limit = 20,
-    startAfter,
+    limit = 10,
+    offset,
     chainIds
   } = {}) {
     return this.httpClient.get("/metadata/chains", {
       withSupportedTokens,
       limit,
-      startAfter,
+      offset,
       chainIds
     });
   }
@@ -1679,6 +1684,13 @@ var ArcApiService = class {
       builtTransactionRequestBody
     );
   }
+  async buildClaimTransaction(sourceNetworkId, depositCount) {
+    return this.httpClient.get("/routes/build-transaction-for-claim", {
+      sourceNetworkId,
+      depositCount
+    });
+  }
+  // supports cursor based pagination only
   async transactions(transactionsRequestQueryParams) {
     return this.httpClient.get("/transactions", {
       transactionsRequestQueryParams
@@ -1702,69 +1714,144 @@ var CoreClient = class {
       timeout: apiTimeout ?? 3e4
     });
   }
+  /**
+   * Generic pagination helper for chains API calls (limit and offset based pagination)
+   * Handles automatic pagination to fetch all available data
+   * @param params - Parameters for the chains API call
+   * @param pageSize - Number of items per page (defaults to DEFAULT_CHAINS_PER_PAGE)
+   */
+  async getAllChainsPaginated(params, pageSize = DEFAULT_CHAINS_PER_PAGE) {
+    const firstResponse = await this.arcApiService.chains({
+      ...params,
+      limit: pageSize
+    });
+    if (firstResponse.data.status !== "success") {
+      throw new Error(firstResponse.data.message);
+    }
+    const firstPageData = firstResponse.data.data;
+    const pagination = firstResponse.data.pagination;
+    const firstPageChains = Array.isArray(firstPageData) ? firstPageData : [];
+    if (!pagination?.total || pagination.total <= pageSize) {
+      return {
+        chains: firstPageChains
+      };
+    }
+    const totalPages = Math.ceil(pagination.total / pageSize);
+    const remainingPages = totalPages - 1;
+    if (remainingPages === 0) {
+      return {
+        chains: firstPageChains
+      };
+    }
+    const remainingPagePromises = Array.from(
+      { length: remainingPages },
+      (_, index) => {
+        const offset = (index + 1) * pageSize;
+        return this.arcApiService.chains({
+          ...params,
+          limit: pageSize,
+          offset
+        });
+      }
+    );
+    const remainingResponses = await Promise.all(remainingPagePromises);
+    for (const response of remainingResponses) {
+      if (response.data.status !== "success") {
+        throw new Error(response.data.message);
+      }
+    }
+    const allChains = [
+      ...firstPageChains,
+      ...remainingResponses.flatMap((response) => {
+        if (response.data.status === "success") {
+          return Array.isArray(response.data.data) ? response.data.data : [];
+        }
+        return [];
+      })
+    ];
+    return {
+      chains: allChains
+    };
+  }
   /**
    * Get all chains metadata from AggLayer API
+   * Handles pagination automatically to fetch all available chains
    */
   async getAllChains() {
-    const response = await this.arcApiService.chains();
-    if (response.data.status === "success") {
-      return response.data.data;
-    }
-    throw new Error(response.data.message);
+    return this.getAllChainsPaginated({});
   }
   /**
    * Get chain metadata by id from AggLayer API
+   * Handles pagination automatically to fetch all available chain metadata
    * @param ids - the ids of the chains to get metadata for
    */
   async getChainMetadataByChainIds(ids) {
-    const response = await this.arcApiService.chains({ chainIds: ids });
-    if (response.data.status === "success") {
-      return response.data.data;
-    }
-    throw new Error(response.data.message);
+    return this.getAllChainsPaginated({ chainIds: ids });
   }
   /**
    * Get all tokens from AggLayer API
-   */
-  async getTokens() {
-    const response = await this.arcApiService.chains({
-      withSupportedTokens: true
-    });
-    if (response.data.status === "success") {
-      return response.data.data;
-    }
-    throw new Error(response.data.message);
+   *
+   * Developer Note: This method is not recommended to use frequently or from frontend.
+   * As it can be very slow and resource intensive.
+   * It is recommended to use getChainDataAndTokensByChainIds instead.
+   */
+  async getAllTokens() {
+    return this.getAllChainsPaginated(
+      { withSupportedTokens: true },
+      DEFAULT_CHAINS_WITH_TOKENS_PER_PAGE
+    );
   }
   /**
    * Get chain data and tokens by AggLayer API
    * @param ids - the ids of the chains to get data and tokens for
    */
   async getChainDataAndTokensByChainIds(ids) {
-    const response = await this.arcApiService.chains({
+    return this.getAllChainsPaginated({
       chainIds: ids,
       withSupportedTokens: true
     });
+  }
+  /**
+   * Get all routes from AggLayer API
+   */
+  async getRoutes(routesRequestParams) {
+    const response = await this.arcApiService.routes(routesRequestParams);
     if (response.data.status === "success") {
       return response.data.data;
     }
     throw new Error(response.data.message);
   }
   /**
-   * Get all routes from AggLayer API
+   * Get calldata from a route
+   * If route has transactionRequest field, return it directly as calldata
+   * Otherwise, call buildTransaction on route.steps[0] and return that as calldata
    */
-  async getRoutes(routesRequestParams) {
-    const response = await this.arcApiService.routes(routesRequestParams);
+  async getUnsignedTransaction(route) {
+    if (route.transactionRequest) {
+      return route.transactionRequest;
+    }
+    if (route.steps.length === 0 || !route.steps[0]) {
+      throw new Error("Route has no steps to build transaction from");
+    }
+    const response = await this.arcApiService.buildTransaction(route.steps[0]);
     if (response.data.status === "success") {
       return response.data.data;
     }
     throw new Error(response.data.message);
   }
   /**
-   * Build transaction from a step object
+   * Get calldata for claim step
+   * Needs to be called separately as claim step is not part of route.
+   *
+   * @developer Note: Do not misinterpret network ID as chain ID.
+   *
+   * @param sourceNetworkId - The source network ID where the transfer was initiated.
+   * @param depositCount - The deposit count associated with the transfer.
    */
-  async buildTransaction(builtTransactionRequestBody) {
-    const response = await this.arcApiService.buildTransaction(
-      builtTransactionRequestBody
+  async getClaimUnsignedTransaction(buildClaimTxParams) {
+    const response = await this.arcApiService.buildClaimTransaction(
+      buildClaimTxParams.sourceNetworkId,
+      buildClaimTxParams.depositCount
     );
     if (response.data.status === "success") {
       return response.data.data;
@@ -1775,6 +1862,11 @@ var CoreClient = class {
    * Get all transactions via web sockets
    */
   async getTransactions(transactionsRequestQueryParams) {
+    if (transactionsRequestQueryParams.limit && transactionsRequestQueryParams.limit > MAX_TRANSACTIONS_PER_PAGE) {
+      throw new Error(
+        `Limit cannot be greater than ${MAX_TRANSACTIONS_PER_PAGE}`
+      );
+    }
     const response = await this.arcApiService.transactions(
       transactionsRequestQueryParams
     );