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

package/dist/index.mjs

@@ -11,7 +11,33 @@ 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,
@@ -26,20 +52,6 @@ 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
@@ -1390,14 +1402,16 @@ var ERC20 = class extends BaseContract {
 import { createPublicClient as createPublicClient3, http as http3 } from "viem";
 
 // src/constants.ts
-var NETWORKS = {
-  SEPOLIA: 11155111,
-  CARDONA: 2442
-};
-var DEFAULT_NETWORK = NETWORKS.SEPOLIA;
+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
+};
+var DEFAULT_NETWORK = NETWORKS.ETHEREUM;
 
 // src/native/index.ts
 var NativeClient = class {
@@ -1587,9 +1601,6 @@ 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")) {
@@ -1597,6 +1608,12 @@ 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,
@@ -1685,7 +1702,7 @@ var ArcApiService = class {
     );
   }
   async buildClaimTransaction(sourceNetworkId, depositCount) {
-    return this.httpClient.get("/routes/build-transaction-for-claim", {
+    return this.httpClient.post("/routes/build-transaction-for-claim", {
       sourceNetworkId,
       depositCount
     });
@@ -1696,22 +1713,69 @@ var ArcApiService = class {
       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;
-    if (!this.config) {
-      throw new Error("Config is required");
-    }
-    if (!this.config.apiBaseUrl) {
-      throw new Error("API base URL is required");
-    }
+    this.config = {
+      ...config,
+      apiBaseUrl: config?.apiBaseUrl || ARC_API_BASE_URL,
+      apiTimeout: config?.apiTimeout || ARC_API_DEFAULT_TIMEOUT
+    };
     const { apiBaseUrl, apiTimeout } = this.config;
     this.arcApiService = new ArcApiService({
-      baseUrl: apiBaseUrl,
-      timeout: apiTimeout ?? 3e4
+      baseUrl: apiBaseUrl || ARC_API_BASE_URL,
+      timeout: apiTimeout || ARC_API_DEFAULT_TIMEOUT
     });
   }
   /**
@@ -1721,57 +1785,64 @@ var CoreClient = class {
    * @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) {
+    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: firstPageChains
+        chains: allChains
       };
-    }
-    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);
+    } catch (error) {
+      if (error instanceof ApiError) {
+        throw error;
       }
+      throw ApiError.createFallbackError(error, "Get chains metadata");
     }
-    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
@@ -1815,11 +1886,18 @@ var CoreClient = class {
    * 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;
+    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");
     }
-    throw new Error(response.data.message);
   }
   /**
    * Get calldata from a route
@@ -1831,13 +1909,28 @@ var CoreClient = class {
       return route.transactionRequest;
     }
     if (route.steps.length === 0 || !route.steps[0]) {
-      throw new Error("Route has no steps to build transaction from");
+      throw ApiError.createFallbackError(
+        new Error("Route has no steps to build transaction from"),
+        "Get unsigned transaction"
+      );
     }
-    const response = await this.arcApiService.buildTransaction(route.steps[0]);
-    if (response.data.status === "success") {
-      return response.data.data;
+    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"
+      );
     }
-    throw new Error(response.data.message);
   }
   /**
    * Get calldata for claim step
@@ -1849,53 +1942,93 @@ var CoreClient = class {
    * @param depositCount - The deposit count associated with the transfer.
    */
   async getClaimUnsignedTransaction(buildClaimTxParams) {
-    const response = await this.arcApiService.buildClaimTransaction(
-      buildClaimTxParams.sourceNetworkId,
-      buildClaimTxParams.depositCount
-    );
-    if (response.data.status === "success") {
-      return response.data.data;
+    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"
+      );
     }
-    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 new Error(
-        `Limit cannot be greater than ${MAX_TRANSACTIONS_PER_PAGE}`
+      throw ApiError.createFallbackError(
+        new Error(`Limit cannot be greater than ${MAX_TRANSACTIONS_PER_PAGE}`),
+        "Get transactions"
       );
     }
-    const response = await this.arcApiService.transactions(
-      transactionsRequestQueryParams
-    );
-    if (response.data.status === "success") {
-      return response.data.data;
+    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"
+      );
     }
-    throw new Error(response.data.message);
   }
 };
 
 // src/index.ts
+var defaultConfig = {
+  mode: [SDK_MODES.CORE]
+};
 var AggLayerSDK = class {
-  constructor(config) {
+  constructor(config = defaultConfig) {
     this.config = config;
     if (!config.mode || config.mode && config.mode.length === 0) {
       this.config.mode = ["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.CORE)) {
+      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
         },
@@ -1929,6 +2062,7 @@ var AggLayerSDK = class {
 };
 export {
   AggLayerSDK,
+  ApiError,
   SDK_MODES
 };
 //# sourceMappingURL=index.mjs.map