@gardenfi/orderbook 2.1.8-beta.2 → 2.1.8

package/dist/index6.js

@@ -1,9 +1,190 @@
-const i = (o, e, t) => {
-  const r = o.endpoint(e);
-  return t && Object.entries(t).forEach(([c, n]) => {
-    n !== void 0 && r.searchParams.append(c, n.toString());
-  }), r;
+var p = (e, t, a) => {
+  if (!t.has(e))
+    throw TypeError("Cannot " + a);
+}, h = (e, t, a) => (p(e, t, "read from private field"), a ? a.call(e) : t.get(e)), u = (e, t, a) => {
+  if (t.has(e))
+    throw TypeError("Cannot add the same private member more than once");
+  t instanceof WeakSet ? t.add(e) : t.set(e, a);
+}, w = (e, t, a, r) => (p(e, t, "write to private field"), t.set(e, a), a);
+const d = (e) => new Promise((t) => setTimeout(t, e));
+class g {
+  /**
+   * @param {number} maxRetries - The maximum number of retries, if less < 0 then it is set to 0
+   * @param {number} delay - The delay between retries
+   */
+  constructor(t, a) {
+    this.maxRetries = Math.max(t, 0), this.delay = a;
+  }
+  /**
+   * Retries a function until it succeeds or the max number of retries is reached
+   *
+   * @param {() => Promise<T>} fn - The function to retry
+   * @return {Promise<T>} a Promise that resolves to the result of the function
+   */
+  async retry(t) {
+    let a = 0, r;
+    for (; a < this.maxRetries + 1; )
+      try {
+        return await t();
+      } catch (i) {
+        a++, r = i, await d(this.delay * a);
+      }
+    throw r;
+  }
+}
+const v = (e) => {
+  try {
+    return JSON.parse(e);
+  } catch {
+    return e;
+  }
+};
+class m {
+  static async _postWithFallback(t, a) {
+    let r = "";
+    for (const i of t)
+      try {
+        const s = await fetch(i, {
+          method: "POST",
+          ...a
+        });
+        if (s.status >= 500) {
+          r = await (s.text() || s.json());
+          continue;
+        }
+        return await this.parse(s);
+      } catch (s) {
+        r = y(s);
+        continue;
+      }
+    throw new Error(r || "All APIs failed");
+  }
+  /**
+   * Asynchronously sends a POST request to multiple URLs with fallback logic.
+   *
+   * @param {string[]} input - array of URLs to send the POST request to
+   * @param {RequestInit} [init] - optional request initialization options
+   * @return {Promise<T>} a Promise that resolves to the parsed response data
+   */
+  static async postWithFallback(t, a) {
+    return await n(a).retry(
+      () => this._postWithFallback(t, a)
+    );
+  }
+  static async _getWithFallback(t, a) {
+    let r = "";
+    for (const i of t)
+      try {
+        const s = await fetch(i, a);
+        if (s.status >= 500) {
+          r = await (s.text() || s.json());
+          continue;
+        }
+        return await this.parse(s);
+      } catch (s) {
+        r = y(s);
+        continue;
+      }
+    throw new Error(r || "All APIs failed");
+  }
+  /**
+   * Asynchronously sends a POST request to multiple URLs with fallback mechanism.
+   *
+   * @param {string[]} input - An array of URLs to retrieve data from.
+   * @param {RequestInit} [init] - Optional request options.
+   * @return {Promise<T>} A promise that resolves to the retrieved data.
+   */
+  static async getWithFallback(t, a) {
+    return await n(a).retry(
+      () => this._getWithFallback(t, a)
+    );
+  }
+  static async _get(t, a) {
+    return await this.parse(await fetch(t, a));
+  }
+  /**
+   * Asynchronously retrieves data of type T from the specified URL or RequestInfo, with optional initialization options.
+   *
+   * @param {RequestInfo | URL} input - The URL or RequestInfo to fetch data from
+   * @param {RequestInit} init - Optional initialization options for the fetch request
+   * @return {Promise<T>} The retrieved data of type T
+   */
+  static async get(t, a) {
+    return await n(a).retry(() => this._get(t, a));
+  }
+  static async _post(t, a) {
+    return await this.parse(
+      await fetch(t, {
+        method: "POST",
+        ...a
+      })
+    );
+  }
+  /**
+   * Asynchronously sends a POST request to the specified URL or RequestInfo, with optional initialization options.
+   */
+  static async post(t, a) {
+    return await n(a).retry(() => this._post(t, a));
+  }
+  /**
+   * Parses the response and returns the result as the specified type.
+   *
+   * @param {Response} res - the response object to be parsed
+   * @return {Promise<T>} the parsed result of type T
+   */
+  static async parse(t) {
+    const a = await t.text();
+    if (t.status >= 200 && t.status < 300)
+      return v(a);
+    throw new Error(a);
+  }
+}
+function y(e) {
+  return (e == null ? void 0 : e.message) || (e == null ? void 0 : e.toString()) || "unknown error";
+}
+const n = (e) => new g((e == null ? void 0 : e.retryCount) ?? 2, (e == null ? void 0 : e.retryDelay) ?? 1e3);
+var o, c, l;
+class f {
+  constructor(t, a, r = void 0) {
+    u(this, o, void 0), u(this, c, void 0), u(this, l, void 0), w(this, o, t), w(this, l, r), w(this, c, a);
+  }
+  get ok() {
+    return h(this, o);
+  }
+  get error() {
+    return h(this, l);
+  }
+  get val() {
+    return h(this, c);
+  }
+}
+o = /* @__PURE__ */ new WeakMap(), c = /* @__PURE__ */ new WeakMap(), l = /* @__PURE__ */ new WeakMap();
+const k = (e) => new f(!0, e), W = (e, ...t) => {
+  if (typeof e == "string" && t && t.length > 0) {
+    let a = [e, ...t].map((r) => {
+      if (r) {
+        if (r instanceof Error)
+          return r.message;
+        if (typeof r == "string")
+          return r;
+        if (r != null && r.toString)
+          return r.toString();
+      }
+    });
+    return new f(
+      !1,
+      null,
+      a.filter((r) => r !== void 0).join(" ")
+    );
+  }
+  return new f(!1, null, e);
 };
 export {
-  i as ConstructUrl
+  W as Err,
+  m as Fetcher,
+  k as Ok,
+  f as Result,
+  g as Retry,
+  v as safeParseJson,
+  d as sleep
 };

package/dist/index7.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const i=(n,o,t)=>{const r=n.endpoint(o);return t&&Object.entries(t).forEach(([c,e])=>{e!==void 0&&r.searchParams.append(c,e.toString())}),r};exports.ConstructUrl=i;

package/dist/index7.js

@@ -0,0 +1,9 @@
+const i = (o, e, t) => {
+  const r = o.endpoint(e);
+  return t && Object.entries(t).forEach(([c, n]) => {
+    n !== void 0 && r.searchParams.append(c, n.toString());
+  }), r;
+};
+export {
+  i as ConstructUrl
+};

package/dist/src/index.d.ts

@@ -1,5 +1,7 @@
 export { Orderbook } from './lib/orderbook/orderbook';
 export type * from './lib/orderbook/orderbook.types';
 export type { Chain, EvmChain, Asset } from './lib/asset';
-export { Chains, BlockchainType, isMainnet, isBitcoin, isEVM, isStarknet, getBlockchainType, NetworkType, NativeTokenAddress, isEvmNativeToken, } from './lib/asset';
+export { Chains, BlockchainType, isMainnet, isBitcoin, isEVM, isStarknet, getBlockchainType, NetworkType, TimeLocks, getTimeLock, NativeTokenAddress, isEvmNativeToken, } from './lib/asset';
+export { OrdersProvider } from './lib/orders/ordersProvider';
+export type { IOrderProvider } from './lib/orders/orders.types';
 export { WBTCArbitrumLocalnetAsset, WBTCEthereumLocalnetAsset, ArbitrumLocalnet, EthereumLocalnet, bitcoinRegtestAsset, SupportedAssets, StarknetLocalnet, STRKStarknetLocalnetAsset, } from './lib/constants';

package/dist/src/lib/asset.d.ts

@@ -61,6 +61,8 @@ export declare const isMainnet: (chain: Chain) => chain is "bitcoin" | "ethereum
 export declare const isBitcoin: (chain: Chain) => chain is "bitcoin" | "bitcoin_testnet" | "bitcoin_regtest";
 export declare const isEVM: (chain: Chain) => chain is "ethereum" | "base" | "arbitrum" | "ethereum_sepolia" | "arbitrum_localnet" | "arbitrum_sepolia" | "ethereum_localnet" | "base_sepolia" | "bera_testnet" | "citrea_testnet" | "bera" | "monad_testnet" | "hyperliquid_testnet" | "hyperliquid" | "unichain" | "corn" | "botanix";
 export declare const isStarknet: (chain: Chain) => chain is "starknet" | "starknet_sepolia" | "starknet_devnet";
+export declare const TimeLocks: Record<Chain, number>;
 export declare const getBlockchainType: (chain: Chain) => BlockchainType;
+export declare const getTimeLock: (chain: Chain) => number;
 export declare const NativeTokenAddress = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
 export declare const isEvmNativeToken: (chain: Chain, tokenAddress: string) => boolean;

package/dist/src/lib/orderbook/orderbook.d.ts

@@ -1,5 +1,5 @@
 import { AsyncResult } from '@catalogfi/utils';
-import { CreateOrder, CreateOrderReqWithStrategyId, IOrderbook, MatchedOrder, PaginatedData, PaginationConfig, Status } from './orderbook.types';
+import { CreateOrder, CreateOrderRequestWithAdditionalData, IOrderbook, MatchedOrder, PaginatedData, PaginationConfig, Status } from './orderbook.types';
 import { IAuth, Url } from '@gardenfi/utils';
 
 /**
@@ -16,7 +16,7 @@ export declare class Orderbook implements IOrderbook {
      * @param {IAuth} auth - The auth object.
      * @returns {string} The create order ID.
      */
-    createOrder(order: CreateOrderReqWithStrategyId, auth: IAuth): AsyncResult<MatchedOrder, string>;
+    createOrder(order: CreateOrderRequestWithAdditionalData, auth: IAuth): AsyncResult<string, string>;
     getOrder<T extends boolean>(id: string, matched: T): AsyncResult<T extends true ? MatchedOrder : CreateOrder, string>;
     getMatchedOrders(address: string, status: Status, paginationConfig?: PaginationConfig): AsyncResult<PaginatedData<MatchedOrder>, string>;
     getUnMatchedOrders(address: string, paginationConfig?: PaginationConfig): AsyncResult<PaginatedData<CreateOrder>, string>;

package/dist/src/lib/orderbook/orderbook.types.d.ts

@@ -89,7 +89,7 @@ export interface IOrderbook {
      * @param {CreateOrderConfig} orderConfig - The configuration for the creating the order.
      * @returns {number} The create order ID.
      */
-    createOrder(order: CreateOrderReqWithStrategyId, auth: IAuth): AsyncResult<MatchedOrder, string>;
+    createOrder(order: CreateOrderRequestWithAdditionalData, auth: IAuth): AsyncResult<string, string>;
     /**
      * Get the order from orderbook based on provided Id and match status.
      * @param id - The create Id of the order
@@ -192,18 +192,18 @@ export type CreateOrderRequest = {
     destination_chain: string;
     source_asset: string;
     destination_asset: string;
+    initiator_source_address: string;
+    initiator_destination_address: string;
     source_amount: string;
     destination_amount: string;
+    fee: string;
     nonce: string;
-    initiator_source_address?: string;
-    initiator_destination_address?: string;
-    secret_hash?: string;
+    min_destination_confirmations: number;
+    timelock: number;
+    secret_hash: string;
 };
 export type CreateOrderRequestWithAdditionalData = CreateOrderRequest & AdditionalData & AffiliateFeeList<AffiliateFeeWithAmount>;
 export type CreateOrder = CreateOrderRequestWithAdditionalData & {
-    fee: string;
-    min_destination_confirmations: number;
-    timelock: number;
     created_at: string;
     updated_at: string;
     deleted_at: string | null;
@@ -247,7 +247,7 @@ export type PaginatedData<T> = {
     total_items: number;
     per_page: number;
 };
-export type CreateOrderResponse = APIResponse<MatchedOrder>;
+export type CreateOrderResponse = APIResponse<string>;
 export type PaginationConfig = {
     page?: number;
     per_page?: number;

package/dist/src/lib/orders/orders.types.d.ts

@@ -0,0 +1,60 @@
+import { AsyncResult } from '@catalogfi/utils';
+import { CreateOrder, MatchedOrder, PaginatedData, PaginationConfig } from '../orderbook/orderbook.types';
+
+export interface IOrderProvider {
+    /**
+     * Get the order from orderbook based on provided Id and match status.
+     * @param id - The create Id of the order
+     * @template T - If true, returns matched order, else returns create order (unmatched Order).
+     * @returns {AsyncResult<T extends true ? MatchedOrder : CreateOrder, string>} A promise that resolves to the order.
+     */
+    getOrder<T extends boolean>(id: string, matched: T): AsyncResult<T extends true ? MatchedOrder : CreateOrder, string>;
+    /**
+     * Get all matched orders from the orderbook associated with the `address`.
+     * @param address The address to get the orders for.
+     * @param pending If true, returns pending orders, else returns all matched orders.
+     * @param paginationConfig - The configuration for the pagination.
+     * @returns {AsyncResult<PaginatedData<MatchedOrder>, string>} A promise that resolves to the orders.
+     */
+    getMatchedOrders(address: string, pending: boolean, paginationConfig?: PaginationConfig): AsyncResult<PaginatedData<MatchedOrder>, string>;
+    /**
+     * Get all unmatched orders from the orderbook associated with the `address`.
+     * @param address The address to get the orders for.
+     * @param paginationConfig - The configuration for the pagination.
+     * @returns {AsyncResult<PaginatedData<CreateOrder>, string>} A promise that resolves to the orders.
+     */
+    getUnMatchedOrders(address: string, paginationConfig?: PaginationConfig): AsyncResult<PaginatedData<CreateOrder>, string>;
+    /**
+     * Get all orders from the orderbook based on the match status.
+     * @param matched - If true, returns matched orders, else returns unmatched orders.
+     * @param paginationConfig - The configuration for the pagination.
+     * @returns {AsyncResult<PaginatedData<T extends true ? MatchedOrder : CreateOrder>, string>} A promise that resolves to the orders.
+     */
+    getOrders<T extends boolean>(matched: T, paginationConfig?: PaginationConfig): AsyncResult<PaginatedData<T extends true ? MatchedOrder : CreateOrder>, string>;
+    /**
+     * Polls for every provided interval and returns matched and unmatched orders associated on the account.
+     * @param account The account to subscribe to
+     * @param matched If true, returns matched orders, else returns unmatched orders
+     * @param cb Th ack to be called when the orders are updated
+     * @param interval The interval to poll for updates
+     *
+     * Example usage:
+     *
+     * ```js
+     * const unsubscribe =await orderbook.subscribeOrders(account, matched, interval, handleOrders, paginationConfig);
+     *
+     * // Unsubscribe after 20 seconds
+     * setTimeout(() => {
+     *   unsubscribe();
+     *   console.log('Unsubscribed from orders');
+     * }, 20000);
+     * ```
+     */
+    subscribeOrders<T extends boolean>(account: string, matched: T, interval: number, cb: (orders: PaginatedData<T extends true ? MatchedOrder : CreateOrder>) => Promise<void>, pending?: boolean, paginationConfig?: PaginationConfig): Promise<() => void>;
+    /**
+     * Returns the current orders count associated with the provided address. Used to calculate nonce for secret generation.
+     * @param address The address to get the orders count for.
+     * @returns {AsyncResult<number, string>} A promise that resolves to the orders count.
+     */
+    getOrdersCount(address: string): AsyncResult<number, string>;
+}

package/dist/src/lib/orders/ordersProvider.d.ts

@@ -0,0 +1,15 @@
+import { AsyncResult } from '@catalogfi/utils';
+import { IOrderProvider } from './orders.types';
+import { CreateOrder, MatchedOrder, PaginatedData, PaginationConfig } from '../orderbook/orderbook.types';
+import { Url } from '@gardenfi/utils';
+
+export declare class OrdersProvider implements IOrderProvider {
+    private url;
+    constructor(url: string | Url);
+    getOrder<T extends boolean>(id: string, matched: T): AsyncResult<T extends true ? MatchedOrder : CreateOrder, string>;
+    getMatchedOrders(address: string, pending: boolean, paginationConfig?: PaginationConfig): AsyncResult<PaginatedData<MatchedOrder>, string>;
+    getUnMatchedOrders(address: string, paginationConfig?: PaginationConfig): AsyncResult<PaginatedData<CreateOrder>, string>;
+    getOrders<T extends boolean>(matched: T, paginationConfig?: PaginationConfig): AsyncResult<PaginatedData<T extends true ? MatchedOrder : CreateOrder>, string>;
+    subscribeOrders<T extends boolean>(account: string, matched: T, interval: number, cb: (orders: PaginatedData<T extends true ? MatchedOrder : CreateOrder>) => Promise<void>, pending?: boolean, paginationConfig?: PaginationConfig): Promise<() => void>;
+    getOrdersCount(address: string): AsyncResult<number, string>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gardenfi/orderbook",
-  "version": "2.1.8-beta.2",
+  "version": "2.1.8",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",