@agglayer/sdk 1.0.0-beta.19 → 1.0.0-beta.8

package/dist/index.mjs

@@ -11,33 +11,7 @@ var ChainRegistry = class _ChainRegistry {
     }
     return _ChainRegistry.instance;
   }
-  // DEV: if adding new default chains, also update README.md
   initializeDefaultChains() {
-    this.registerChain({
-      chainId: 1,
-      networkId: 0,
-      name: "Ethereum",
-      rpcUrl: "https://eth.llamarpc.com",
-      nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
-      blockExplorer: { name: "Etherscan", url: "https://etherscan.io" },
-      bridgeAddress: "",
-      proofApiUrl: "https://api-gateway.polygon.technology/api/v3/proof/mainnet/",
-      isTestnet: false
-    });
-    this.registerChain({
-      chainId: 747474,
-      networkId: 20,
-      name: "Katana",
-      rpcUrl: "https://rpc.katana.network",
-      nativeCurrency: { name: "Ethereum", symbol: "ETH", decimals: 18 },
-      blockExplorer: {
-        name: "Katana Explorer",
-        url: "https://katanascan.com"
-      },
-      bridgeAddress: "",
-      proofApiUrl: "https://api-gateway.polygon.technology/api/v3/proof/mainnet/",
-      isTestnet: false
-    });
     this.registerChain({
       chainId: 11155111,
       networkId: 0,
@@ -52,6 +26,20 @@ var ChainRegistry = class _ChainRegistry {
       proofApiUrl: "https://api-gateway.polygon.technology/api/v3/proof/testnet/",
       isTestnet: true
     });
+    this.registerChain({
+      chainId: 2442,
+      networkId: 1,
+      name: "Polygon Cardona",
+      rpcUrl: "https://rpc.cardona.zkevm-rpc.com",
+      nativeCurrency: { name: "Ethereum", symbol: "ETH", decimals: 18 },
+      blockExplorer: {
+        name: "Cardona PolygonScan",
+        url: "https://cardona-zkevm.polygonscan.com"
+      },
+      bridgeAddress: "0x528e26b25a34a4A5d0dbDa1d57D318153d2ED582",
+      proofApiUrl: "https://api-gateway.polygon.technology/api/v3/proof/testnet/",
+      isTestnet: true
+    });
   }
   /**
    * Register a new chain
@@ -1402,16 +1390,11 @@ var ERC20 = class extends BaseContract {
 import { createPublicClient as createPublicClient3, http as http3 } from "viem";
 
 // src/constants.ts
-var ARC_API_BASE_URL = "https://arc-api.polygon.technology";
-var ARC_API_DEFAULT_TIMEOUT = 3e4;
-var DEFAULT_CHAINS_PER_PAGE = 100;
-var DEFAULT_CHAINS_WITH_TOKENS_PER_PAGE = 1;
-var MAX_TRANSACTIONS_PER_PAGE = 100;
 var NETWORKS = {
-  ETHEREUM: 1,
-  KATANA: 747474
+  SEPOLIA: 11155111,
+  CARDONA: 2442
 };
-var DEFAULT_NETWORK = NETWORKS.ETHEREUM;
+var DEFAULT_NETWORK = NETWORKS.SEPOLIA;
 
 // src/native/index.ts
 var NativeClient = class {
@@ -1601,6 +1584,9 @@ var HttpClient = class {
         signal: controller.signal
       });
       clearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
       let data;
       const contentType = response.headers.get("content-type");
       if (contentType?.includes("application/json")) {
@@ -1608,12 +1594,6 @@ var HttpClient = class {
       } else {
         data = await response.text();
       }
-      if (!response.ok) {
-        if (contentType?.includes("application/json")) {
-        } else {
-          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-      }
       return {
         data,
         status: response.status,
@@ -1643,12 +1623,11 @@ var HttpClient = class {
         continue;
       }
       if (Array.isArray(value)) {
-        const filteredValues = value.filter(
-          (item) => item !== void 0 && item !== null
-        );
-        if (filteredValues.length > 0) {
-          result[fullKey] = filteredValues.join(",");
-        }
+        value.forEach((item, index) => {
+          if (item !== void 0 && item !== null) {
+            result[`${fullKey}[${index}]`] = String(item);
+          }
+        });
       } else if (typeof value === "object") {
         Object.assign(
           result,
@@ -1678,17 +1657,16 @@ 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 = 10,
-    offset,
+    limit = 20,
+    startAfter = 0,
     chainIds
   } = {}) {
     return this.httpClient.get("/metadata/chains", {
       withSupportedTokens,
       limit,
-      offset,
+      startAfter,
       chainIds
     });
   }
@@ -1697,338 +1675,135 @@ var ArcApiService = class {
   }
   async buildTransaction(builtTransactionRequestBody) {
     return this.httpClient.post(
-      "/routes/build-transaction",
+      "/build-transaction",
       builtTransactionRequestBody
     );
   }
-  async buildClaimTransaction(sourceNetworkId, depositCount) {
-    return this.httpClient.post("/routes/build-transaction-for-claim", {
-      sourceNetworkId,
-      depositCount
-    });
-  }
-  // supports cursor based pagination only
   async transactions(transactionsRequestQueryParams) {
     return this.httpClient.get("/transactions", {
       transactionsRequestQueryParams
     });
   }
-  async tokenMappings(tokenMappingQueryParams) {
-    const { tokenAddress } = tokenMappingQueryParams;
-    return this.httpClient.get(`/token-mappings/${tokenAddress}`);
-  }
-};
-
-// src/core/utils/apiError.ts
-var ApiError = class _ApiError extends Error {
-  constructor(errorResponse) {
-    super(errorResponse.message);
-    this.name = errorResponse.name;
-    this.code = errorResponse.code;
-    this.details = errorResponse.details;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _ApiError);
-    }
-  }
-  /**
-   * Create API error from error response
-   */
-  static fromErrorResponse(errorResponse) {
-    return new _ApiError(errorResponse);
-  }
-  /**
-   * Create fallback error when API completely fails
-   */
-  static createFallbackError(originalError, operation) {
-    return new _ApiError({
-      status: "error",
-      message: `${operation} failed: ${originalError.message}`,
-      name: "ApiConnectionError",
-      code: 500,
-      details: {
-        originalError: originalError.message,
-        operation
-      }
-    });
-  }
-  /**
-   * Convert to plain object for serialization
-   */
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      code: this.code,
-      details: this.details
-    };
-  }
 };
 
 // src/core/index.ts
 var CoreClient = class {
   constructor(config) {
-    this.config = {
-      ...config,
-      apiBaseUrl: config?.apiBaseUrl || ARC_API_BASE_URL,
-      apiTimeout: config?.apiTimeout || ARC_API_DEFAULT_TIMEOUT
-    };
+    this.config = config;
+    if (!this.config) {
+      throw new Error("Config is required");
+    }
+    if (!this.config.apiBaseUrl) {
+      throw new Error("API base URL is required");
+    }
     const { apiBaseUrl, apiTimeout } = this.config;
     this.arcApiService = new ArcApiService({
-      baseUrl: apiBaseUrl || ARC_API_BASE_URL,
-      timeout: apiTimeout || ARC_API_DEFAULT_TIMEOUT
+      baseUrl: apiBaseUrl,
+      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) {
-    try {
-      const firstResponse = await this.arcApiService.chains({
-        ...params,
-        limit: pageSize
-      });
-      if (firstResponse.data.status !== "success") {
-        throw ApiError.fromErrorResponse(firstResponse.data);
-      }
-      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 ApiError.fromErrorResponse(response.data);
-        }
-      }
-      const allChains = [
-        ...firstPageChains,
-        ...remainingResponses.flatMap((response) => {
-          if (response.data.status === "success") {
-            return Array.isArray(response.data.data) ? response.data.data : [];
-          }
-          return [];
-        })
-      ];
-      return {
-        chains: allChains
-      };
-    } catch (error) {
-      if (error instanceof ApiError) {
-        throw error;
-      }
-      throw ApiError.createFallbackError(error, "Get chains metadata");
-    }
-  }
   /**
    * Get all chains metadata from AggLayer API
-   * Handles pagination automatically to fetch all available chains
    */
   async getAllChains() {
-    return this.getAllChainsPaginated({});
+    const response = await this.arcApiService.chains();
+    if (response.data.status === "success") {
+      return response.data.data;
+    }
+    throw new Error(response.data.message);
   }
   /**
    * 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) {
-    return this.getAllChainsPaginated({ chainIds: ids });
+    const response = await this.arcApiService.chains({ chainIds: ids });
+    if (response.data.status === "success") {
+      return response.data.data;
+    }
+    throw new Error(response.data.message);
   }
   /**
    * Get all tokens from AggLayer API
-   *
-   * 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
-    );
+   */
+  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);
   }
   /**
    * Get chain data and tokens by AggLayer API
    * @param ids - the ids of the chains to get data and tokens for
    */
   async getChainDataAndTokensByChainIds(ids) {
-    return this.getAllChainsPaginated({
+    const response = await this.arcApiService.chains({
       chainIds: ids,
       withSupportedTokens: true
     });
+    if (response.data.status === "success") {
+      return response.data.data;
+    }
+    throw new Error(response.data.message);
   }
   /**
    * Get all routes from AggLayer API
    */
   async getRoutes(routesRequestParams) {
-    try {
-      const response = await this.arcApiService.routes(routesRequestParams);
-      if (response.data.status === "success") {
-        return response.data.data;
-      }
-      throw ApiError.fromErrorResponse(response.data);
-    } catch (error) {
-      if (error instanceof ApiError) {
-        throw error;
-      }
-      throw ApiError.createFallbackError(error, "Get routes");
+    const response = await this.arcApiService.routes(routesRequestParams);
+    if (response.data.status === "success") {
+      return response.data.data;
     }
+    throw new Error(response.data.message);
   }
   /**
-   * 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
+   * Build transaction from a step object
    */
-  async getUnsignedTransaction(route) {
-    if (route.transactionRequest) {
-      return route.transactionRequest;
-    }
-    if (route.steps.length === 0 || !route.steps[0]) {
-      throw ApiError.createFallbackError(
-        new Error("Route has no steps to build transaction from"),
-        "Get unsigned transaction"
-      );
-    }
-    try {
-      const response = await this.arcApiService.buildTransaction(
-        route.steps[0]
-      );
-      if (response.data.status === "success") {
-        return response.data.data;
-      }
-      throw ApiError.fromErrorResponse(response.data);
-    } catch (error) {
-      if (error instanceof ApiError) {
-        throw error;
-      }
-      throw ApiError.createFallbackError(
-        error,
-        "Get unsigned transaction"
-      );
-    }
-  }
-  /**
-   * 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 getClaimUnsignedTransaction(buildClaimTxParams) {
-    try {
-      const response = await this.arcApiService.buildClaimTransaction(
-        buildClaimTxParams.sourceNetworkId,
-        buildClaimTxParams.depositCount
-      );
-      if (response.data.status === "success") {
-        return response.data.data;
-      }
-      throw ApiError.fromErrorResponse(response.data);
-    } catch (error) {
-      if (error instanceof ApiError) {
-        throw error;
-      }
-      throw ApiError.createFallbackError(
-        error,
-        "Get claim unsigned transaction"
-      );
+  async buildTransaction(builtTransactionRequestBody) {
+    const response = await this.arcApiService.buildTransaction(
+      builtTransactionRequestBody
+    );
+    if (response.data.status === "success") {
+      return response.data.data;
     }
+    throw new Error(response.data.message);
   }
   /**
    * Get all transactions via web sockets
    */
   async getTransactions(transactionsRequestQueryParams) {
-    if (transactionsRequestQueryParams.limit && transactionsRequestQueryParams.limit > MAX_TRANSACTIONS_PER_PAGE) {
-      throw ApiError.createFallbackError(
-        new Error(`Limit cannot be greater than ${MAX_TRANSACTIONS_PER_PAGE}`),
-        "Get transactions"
-      );
-    }
-    try {
-      const response = await this.arcApiService.transactions(
-        transactionsRequestQueryParams
-      );
-      if (response.data.status === "success") {
-        return response.data.data;
-      }
-      throw ApiError.fromErrorResponse(response.data);
-    } catch (error) {
-      if (error instanceof ApiError) {
-        throw error;
-      }
-      throw ApiError.createFallbackError(error, "Get transactions");
-    }
-  }
-  /**
-   * Get token mappings by token address
-   * @developer Note: Do not misinterpret network ID as chain ID.
-   *
-   * @param tokenAddress
-   */
-  async getTokenMappings(tokenMappingQueryParams) {
-    try {
-      const response = await this.arcApiService.tokenMappings(
-        tokenMappingQueryParams
-      );
-      if (response.data.status === "success") {
-        return response.data.data;
-      }
-      throw ApiError.fromErrorResponse(response.data);
-    } catch (error) {
-      if (error instanceof ApiError) {
-        throw error;
-      }
-      throw ApiError.createFallbackError(
-        error,
-        "Get custom token mappings"
-      );
+    const response = await this.arcApiService.transactions(
+      transactionsRequestQueryParams
+    );
+    if (response.data.status === "success") {
+      return response.data.data;
     }
+    throw new Error(response.data.message);
   }
 };
 
 // src/index.ts
-var defaultConfig = {
-  mode: [SDK_MODES.CORE]
-};
 var AggLayerSDK = class {
-  constructor(config = defaultConfig) {
+  constructor(config) {
     this.config = config;
     if (!config.mode || config.mode && config.mode.length === 0) {
       this.config.mode = ["CORE"];
     }
-    if (this.config.mode?.includes(SDK_MODES.CORE)) {
-      this.core = new CoreClient(this.config?.core);
+    if (config.mode.includes(SDK_MODES.CORE)) {
+      if (!this.config.core) {
+        throw new Error("Core config is required");
+      }
+      this.core = new CoreClient(this.config.core);
     }
     if (this.config.mode?.includes(SDK_MODES.NATIVE)) {
+      if (!this.config.native) {
+        throw new Error("NATIVE config is required");
+      }
       const nativeConfig = {
-        defaultNetwork: this.config.native?.defaultNetwork ?? DEFAULT_NETWORK,
+        defaultNetwork: this.config.native?.defaultNetwork || DEFAULT_NETWORK,
         ...this.config.native?.chains && {
           chains: this.config.native.chains
         },
@@ -2062,7 +1837,6 @@ var AggLayerSDK = class {
 };
 export {
   AggLayerSDK,
-  ApiError,
   SDK_MODES
 };
 //# sourceMappingURL=index.mjs.map