@gardenfi/orderbook 2.5.3 → 3.0.0

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

@@ -0,0 +1,43 @@
+import { Network } from '@gardenfi/utils';
+import { Config } from './asset';
+import { ChainAsset } from '../chainAsset/chainAsset';
+
+export declare enum BlockchainType {
+    bitcoin = "bitcoin",
+    evm = "evm",
+    solana = "solana",
+    starknet = "starknet",
+    sui = "sui"
+}
+export type AddressSchema = {
+    address: string;
+    schema: string | null;
+};
+export type Asset = {
+    id: ChainAsset | string;
+    name: string;
+    chain: Chain;
+    symbol: string;
+    icon?: string;
+    htlc: AddressSchema | null;
+    token: AddressSchema | null;
+    decimals: number;
+    min_amount?: string;
+    max_amount?: string;
+    price?: number;
+};
+export type Chain = keyof typeof Config;
+export type ChainsByNetwork<T extends Network> = {
+    [K in keyof typeof Config]: (typeof Config)[K]['network'] extends T ? K : never;
+}[keyof typeof Config];
+export type MainnetOnlyChains = ChainsByNetwork<Network.MAINNET>;
+export type TestnetOnlyChains = ChainsByNetwork<Network.TESTNET>;
+export type LocalnetOnlyChains = ChainsByNetwork<Network.LOCALNET>;
+export type ChainsByBlockchainType<T extends BlockchainType> = {
+    [K in keyof typeof Config]: (typeof Config)[K]['type'] extends T ? K : never;
+}[keyof typeof Config];
+export type EVMChains = ChainsByBlockchainType<BlockchainType.evm>;
+export type BitcoinChains = ChainsByBlockchainType<BlockchainType.bitcoin>;
+export type SolanaChains = ChainsByBlockchainType<BlockchainType.solana>;
+export type StarknetChains = ChainsByBlockchainType<BlockchainType.starknet>;
+export type SuiChains = ChainsByBlockchainType<BlockchainType.sui>;

package/dist/src/lib/constants/localnetConstants.d.ts

@@ -0,0 +1,47 @@
+import { Chain as viemChain } from 'viem';
+
+export declare const StarknetLocalnet: viemChain;
+export declare const ArbitrumLocalnet: viemChain;
+export declare const EthereumLocalnet: viemChain;
+export declare const SOLSolanaLocalnetAsset: {
+    name: string;
+    decimals: number;
+    symbol: string;
+    atomicSwapAddress: string;
+    tokenAddress: string;
+};
+export declare const bitcoinRegtestAsset: {
+    name: string;
+    decimals: number;
+    symbol: string;
+    atomicSwapAddress: string;
+    tokenAddress: string;
+};
+export declare const WBTCArbitrumLocalnetAsset: {
+    name: string;
+    decimals: number;
+    symbol: string;
+    atomicSwapAddress: string;
+    tokenAddress: string;
+};
+export declare const WBTCEthereumLocalnetAsset: {
+    name: string;
+    decimals: number;
+    symbol: string;
+    atomicSwapAddress: string;
+    tokenAddress: string;
+};
+export declare const STRKStarknetLocalnetAsset: {
+    name: string;
+    decimals: number;
+    symbol: string;
+    atomicSwapAddress: string;
+    tokenAddress: string;
+};
+export declare const ETHStarknetLocalnetAsset: {
+    name: string;
+    decimals: number;
+    symbol: string;
+    atomicSwapAddress: string;
+    tokenAddress: string;
+};

package/dist/src/lib/constants/utils.d.ts

@@ -0,0 +1,15 @@
+import { Asset } from './asset.types';
+
+/** Strip meta keys network & type from a chain object */
+type StripMeta<T> = Omit<T, 'network' | 'type'>;
+type ChainKeyOf<T extends Record<string, any>> = Extract<keyof T, string>;
+type TokenNoChain = Omit<Asset, 'chain'>;
+/** For a chain object T[C], produce a token map where each token is Asset<C> */
+type WithChainForChainObj<ChainObj extends Record<string, TokenNoChain>> = {
+    readonly [TokenKey in keyof ChainObj]: Asset;
+};
+export type AssetsType<T extends Record<string, any>> = {
+    readonly [C in ChainKeyOf<T>]: WithChainForChainObj<StripMeta<T[C]>>;
+};
+export declare function buildAssetsWithChain<T extends Record<string, any>>(cfg: T): AssetsType<T>;
+export {};

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

@@ -0,0 +1,14 @@
+import { OrderStatus } from '../constants/asset';
+import { Order } from '../orderbook/orderbook.types';
+
+export declare const ParseOrderStatus: (order: Order) => OrderStatus;
+export declare const isDeadlinePassed: (date: Date, tillHours?: number) => boolean;
+export declare const isCompleted: (order: Order) => boolean;
+export declare enum OrderAction {
+    Initiate = "Initiate",
+    PostRefundSACP = "PostRefundSACP",
+    Redeem = "Redeem",
+    Refund = "Refund",
+    Idle = "Idle"
+}
+export declare const parseAction: (order: Order) => OrderAction.Redeem | OrderAction.Idle;

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

@@ -1,6 +1,6 @@
-import { CreateOrder, CreateOrderReqWithStrategyId, IOrderbook, MatchedOrder, OrderStatus, PaginatedData, PaginationConfig, Status } from './orderbook.types';
-import { AsyncResult, IAuth, Url, Request as UtilsRequest } from '@gardenfi/utils';
-import { Chain } from '../asset';
+import { IOrderbook, CreateOrderResponse, PaginatedData, CreateOrderRequest, GetOrderQueryParams, OrderWithStatus } from './orderbook.types';
+import { AsyncResult, IAuth, Url, Request } from '@gardenfi/utils';
+import { BlockchainType } from '../constants/asset.types';
 
 /**
  * A class that allows you to create and manage orders with the orderbook url.
@@ -8,26 +8,19 @@ import { Chain } from '../asset';
  * @implements {IOrderbook}
  */
 export declare class Orderbook implements IOrderbook {
-    private Url;
+    private url;
     constructor(url: Url);
+    createOrder<T extends BlockchainType>(order: CreateOrderRequest, auth: IAuth): AsyncResult<CreateOrderResponse<T>, string>;
+    getOrder(id: string, request?: Request): AsyncResult<OrderWithStatus, string>;
+    getOrders(queryParams: GetOrderQueryParams, request?: Request): AsyncResult<PaginatedData<OrderWithStatus>, string>;
     /**
-     * Creates an order
-     * @param {CreateOrderRequestWithAdditionalData} order - The configuration for the creating the order.
-     * @param {IAuth} auth - The auth object.
-     * @returns {string} The create order ID.
+     * Subscribe to orders
+     * @param account - The account of the order
+     * @param interval - The interval of the order
+     * @param cb - The callback function
+     * @param status - The status of the order
+     * @param paginationConfig - The pagination configuration
+     * @returns {Promise<() => void>} A promise that resolves to the unsubscribe function.
      */
-    createOrder(order: CreateOrderReqWithStrategyId, auth: IAuth): AsyncResult<MatchedOrder, string>;
-    getOrder<T extends boolean>(id: string, matched: T, request?: UtilsRequest): AsyncResult<T extends true ? MatchedOrder : CreateOrder, string>;
-    getMatchedOrders(address: string, status: Status, paginationConfig?: PaginationConfig, request?: UtilsRequest): AsyncResult<PaginatedData<MatchedOrder>, string>;
-    getUnMatchedOrders(address: string, paginationConfig?: PaginationConfig, request?: UtilsRequest): AsyncResult<PaginatedData<CreateOrder>, string>;
-    getOrders<T extends boolean>(matched: T, filters: {
-        address?: string;
-        tx_hash?: string;
-        from_chain?: Chain;
-        to_chain?: Chain;
-        status?: OrderStatus | OrderStatus[];
-        [key: string]: string | string[] | undefined;
-    }, paginationConfig?: PaginationConfig, request?: UtilsRequest): 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>, status?: Status, paginationConfig?: PaginationConfig, request?: UtilsRequest): Promise<() => void>;
-    getOrdersCount(address: string, request?: UtilsRequest): AsyncResult<number, string>;
+    subscribeOrders(queryParams: GetOrderQueryParams, cb: (orders: PaginatedData<OrderWithStatus>) => Promise<void>, interval?: number, request?: Request): Promise<() => void>;
 }

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

@@ -1,223 +1,69 @@
-import { APIResponse, AsyncResult, IAuth, IStore, Request as UtilsRequest } from '@gardenfi/utils';
-import { Asset, Chain } from '../asset';
+import { AsyncResult, IAuth, Request } from '@gardenfi/utils';
+import { OrderLifecycle, OrderStatus } from '../constants/asset';
+import { BlockchainType, Chain } from '../constants/asset.types';
+import { Calldata, RawArgs, TypedData } from 'starknet';
+import { ChainAsset } from '../chainAsset/chainAsset';
 
-/**
- * Configuration for creating an order
- */
-export interface CreateOrderConfig {
-    /**
-     * The asset the user wants to send.
-     */
-    fromAsset: Asset;
-    /**
-     * The asset the user wants to receive.
-     */
-    toAsset: Asset;
-    /**
-     * The address from the which the user is sending funds from.
-     */
-    sendAddress: string;
-    /**
-     * The address at which the user wants to receive funds.
-     */
-    receiveAddress: string;
-    /**
-     * The input amount the user wants to send in it's lowest denomination
-     */
-    sendAmount: string;
-    /**
-     * The amount you receive amount
-     */
-    receiveAmount: string;
-    /**
-     * The hash of the secret the user wants to use for the swap.
-     */
-    secretHash: string;
-    /**
-     * The time lock for the swap. (current blocknumber + 48 hours)
-     * @NOTE 7200 blocks per day in ethereum.
-     * @NOTE 144 blocks per day in bitcoin.
-     */
-    timelock: number;
-    /**
-     * The nonce for the order.
-     * This is used for secret generation.
-     */
-    nonce: string;
-    /**
-     * The address of the user's btc wallet. The funds will be sent to this address in case of a redeem or refund.
-     * @NOTE This is only required if the destination chain is bitcoin.
-     */
-    btcInputAddress?: string;
-    /**
-     * The min number of confirmations required for the user before redeeming in the destination chain.
-     * @default 0
-     */
-    minDestinationConfirmations?: number;
-}
-/**
- * Additional configuration options for the orderbook
- *
- */
-export type OrderbookOpts = {
-    /**
-     * The domain of your dApp. Optional.
-     */
-    domain?: string;
-    /**
-     * The store used for storing the auth token. Optional.
-     */
-    store?: IStore;
-};
-/**
- * Configuration for the orders you want to receive
- */
-export type OrderConfig = {
-    isPending: boolean;
-    pagination?: {
-        page?: number;
-        /**
-         * default is 10
-         */
-        per_page?: number;
-    };
-};
 export interface IOrderbook {
     /**
      * Creates an order
-     * @param {CreateOrderConfig} orderConfig - The configuration for the creating the order.
-     * @returns {number} The create order ID.
+     * @param {CreateOrderRequest} order - The configuration for the creating the order.
+     * @param {IAuth} auth - The auth object.
+     * @returns {CreateOrderResponse} The create order ID.
      */
-    createOrder(order: CreateOrderReqWithStrategyId, auth: IAuth): AsyncResult<MatchedOrder, string>;
+    createOrder(order: CreateOrderRequest, auth: IAuth): AsyncResult<CreateOrderResponse, string>;
     /**
-     * Get the order from orderbook based on provided Id and match status.
+     * Get the order from orderbook based on provided Id.
      * @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, status: Status, 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.
+     * @returns {AsyncResult<Order, string>} A promise that resolves to the order.
      */
-    getUnMatchedOrders(address: string, paginationConfig?: PaginationConfig): AsyncResult<PaginatedData<CreateOrder>, string>;
+    getOrder(id: string, request?: Request): AsyncResult<OrderWithStatus, string>;
     /**
-     * Get all orders from the orderbook based on the match status.
-     * @param matched - If true, returns matched orders, else returns unmatched orders.
-     * @param filters - Object containing filter parameters like: `address`, `tx_hash`, `from_chain`, `to_chain`, `status` and any additional key-value pairs for query parameters.
+     * Get all orders from the orderbook based on the provided filters.
+     * @param {GetOrdersFilters} filters - Object containing filter parameters like: `address`, `tx_hash`, `from_chain`, `to_chain`, `status` and any additional key-value pairs for query parameters.
      * @param paginationConfig - The configuration for the pagination.
-     * @param request - Optional request configuration.
-     * @returns {AsyncResult<PaginatedData<T extends true ? MatchedOrder : CreateOrder>, string>} A promise that resolves to the orders.
+     * @returns {AsyncResult<PaginatedData<Order>, string>} A promise that resolves to the orders.
      */
-    getOrders<T extends boolean>(matched: T, filters: {
-        address?: string;
-        tx_hash?: string;
-        from_chain?: Chain;
-        to_chain?: Chain;
-        status?: OrderStatus;
-        [key: string]: string | undefined;
-    }, paginationConfig?: PaginationConfig, request?: UtilsRequest): AsyncResult<PaginatedData<T extends true ? MatchedOrder : CreateOrder>, string>;
+    getOrders(queryParams: GetOrderQueryParams, request?: Request): AsyncResult<PaginatedData<OrderWithStatus>, 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);
-     * ```
+     * A wrapper around getOrders that polls for every provided interval and returns orders based on the provided filters.
+     * @param {GetOrdersFilters} filters - The filters to get the orders for.
+     * @param {function} cb - The callback to be called when the orders are updated.
+     * @param {number} interval - The interval to poll for updates. Default is 5000ms.
+     * @param {PaginationConfig} paginationConfig - The configuration for the pagination.
+     * @returns {Promise<() => void>} A promise that resolves to a function to unsubscribe from the orders.
      */
-    subscribeOrders<T extends boolean>(account: string, matched: T, interval: number, cb: (orders: PaginatedData<T extends true ? MatchedOrder : CreateOrder>) => Promise<void>, status?: Status, 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>;
+    subscribeOrders(queryParams: GetOrderQueryParams, cb: (orders: PaginatedData<OrderWithStatus>) => Promise<void>, interval?: number, request?: Request): Promise<() => void>;
 }
-export type DecodedAuthToken = {
-    userWallet: string;
-    exp: number;
-    iat: number;
-};
-export type Orders = {
-    unmatched: PaginatedData<CreateOrder[]>;
-    matched: PaginatedData<MatchedOrder[]>;
+export type GetOrdersFilters = {
+    address?: string;
+    tx_hash?: string;
+    from_chain?: Chain;
+    to_chain?: Chain;
+    from_owner?: string;
+    to_owner?: string;
+    status?: OrderLifecycle | OrderLifecycle[];
+    [key: string]: string | string[] | number | undefined;
 };
-export type AdditionalData = {
-    additional_data: {
-        strategy_id: string;
-        sig: string;
-        input_token_price: number;
-        output_token_price: number;
-        deadline: number;
-        bitcoin_optional_recipient?: string;
-        [key: string]: any;
+export type GetOrderQueryParams = GetOrdersFilters & PaginationConfig;
+export type CreateOrderRequest = {
+    source: {
+        asset: string;
+        owner: string;
+        delegate: string | null;
+        amount: string;
     };
-};
-export type AdditionalDataWithStrategyId = {
-    additional_data: {
-        strategy_id: string;
-        bitcoin_optional_recipient?: string;
-        [key: string]: any;
+    destination: {
+        asset: string;
+        owner: string;
+        delegate: string | null;
+        amount: string;
     };
-};
-export type CreateOrderReqWithStrategyId = CreateOrderRequest & AdditionalDataWithStrategyId & AffiliateFeeList<AffiliateFee>;
-export type AffiliateFee = {
-    fee: number;
-    address: string;
-    chain: string;
-    asset: string;
-};
-export type AffiliateFeeWithAmount = AffiliateFee & {
-    amount: string;
-};
-export type AffiliateFeeList<T extends AffiliateFee | AffiliateFeeWithAmount> = {
-    affiliate_fees?: T[];
-};
-export type AffiliateFeeOptionalChainAsset = Omit<AffiliateFee, 'chain' | 'asset'> & Partial<Pick<AffiliateFee, 'chain' | 'asset'>>;
-export type CreateOrderRequest = {
-    source_chain: string;
-    destination_chain: string;
-    source_asset: string;
-    destination_asset: string;
-    source_amount: string;
-    destination_amount: string;
-    nonce: string;
-    initiator_source_address?: string;
-    initiator_destination_address?: string;
+    solver_id: string;
+    slippage?: 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;
-    create_id: string;
-    block_number: string;
-    user_id: string;
+    nonce: number;
+    affiliate_fees?: AffiliateFee[];
 };
 export type Swap = {
     created_at: string;
@@ -226,8 +72,6 @@ export type Swap = {
     swap_id: string;
     chain: Chain;
     asset: string;
-    htlc_address: string;
-    token_address: string;
     initiator: string;
     redeemer: string;
     timelock: number;
@@ -242,18 +86,42 @@ export type Swap = {
     redeem_block_number: string | null;
     refund_block_number: string | null;
     required_confirmations: number;
+    delegate: string;
+    asset_price: number;
+    instant_refund_tx: string;
+    initiate_timestamp: string;
+    redeem_timestamp: string;
+    refund_timestamp: string;
     current_confirmations: number;
-    initiate_timestamp: string | null;
-    redeem_timestamp: string | null;
-    refund_timestamp: string | null;
 };
-export type MatchedOrder = {
+export type Order = {
+    order_id: string;
     created_at: string;
-    updated_at: string;
-    deleted_at: string | null;
     source_swap: Swap;
     destination_swap: Swap;
-    create_order: CreateOrder;
+    slippage: number;
+    nonce: string;
+    affiliate_fees: AffiliateFee[];
+    integrator: string;
+    version: string;
+};
+export type OrderWithStatus = Order & {
+    status: OrderStatus;
+};
+export type AssetHTLCInfo = {
+    id: string;
+    htlc: {
+        address: string;
+        schema: string;
+    } | null;
+    token: {
+        address: string;
+        schema: string;
+    } | null;
+    decimals: number;
+    min_amount: string;
+    max_amount: string;
+    price: number;
 };
 export type PaginatedData<T> = {
     data: T[];
@@ -262,10 +130,78 @@ export type PaginatedData<T> = {
     total_items: number;
     per_page: number;
 };
-export type CreateOrderResponse = APIResponse<MatchedOrder>;
 export type PaginationConfig = {
     page?: number;
     per_page?: number;
 };
-export type Status = 'all' | 'pending' | 'fulfilled';
-export type OrderStatus = 'refunded' | 'expired' | 'completed' | 'in-progress' | 'not-initiated';
+export type AffiliateFee = {
+    address: string;
+    asset: ChainAsset;
+    fee: number;
+};
+export type AffiliateFeeWithAmount = AffiliateFee & {
+    amount: string;
+};
+export type AffiliateFeeList<T extends AffiliateFee | AffiliateFeeWithAmount> = {
+    affiliate_fees?: T[];
+};
+export type AffiliateFeeOptionalAsset = Omit<AffiliateFee, 'asset'> & Partial<Pick<AffiliateFee, 'asset'>>;
+export type EVMTransaction = {
+    to: string;
+    value: string;
+    data: string;
+    gas_limit: string;
+    chain_id: number;
+};
+export type StarknetCall = {
+    to: string;
+    calldata?: RawArgs | Calldata;
+    selector?: string;
+};
+export type BaseCreateOrderResponse = {
+    order_id: string;
+};
+export type BitcoinOrderResponse = BaseCreateOrderResponse & {
+    to: string;
+    amount: number;
+};
+type WithTypedData<T, D> = T & {
+    typed_data: D | null;
+};
+type EvmTypedData = {
+    domain: Record<string, unknown>;
+    types: Record<string, unknown>;
+    primaryType: string;
+    message: {
+        amount: string;
+        secretHash: string;
+        timelock: string;
+        redeemer: string;
+    };
+};
+export type EvmOrderResponse = WithTypedData<BaseCreateOrderResponse & {
+    approval_transaction: EVMTransaction | null;
+    initiate_transaction: EVMTransaction;
+}, EvmTypedData>;
+export type StarknetOrderResponse = WithTypedData<BaseCreateOrderResponse & {
+    approval_transaction: StarknetCall;
+    initiate_transaction: StarknetCall;
+}, TypedData>;
+export type SolanaOrderResponse = BaseCreateOrderResponse & {
+    versioned_tx: string;
+    versioned_tx_gasless: string | null;
+};
+export type SuiOrderResponse = BaseCreateOrderResponse & {
+    ptb_bytes: number[];
+};
+type OrderResponseMap = {
+    [BlockchainType.evm]: EvmOrderResponse;
+    [BlockchainType.bitcoin]: BitcoinOrderResponse;
+    [BlockchainType.starknet]: StarknetOrderResponse;
+    [BlockchainType.solana]: SolanaOrderResponse;
+    [BlockchainType.sui]: SuiOrderResponse;
+};
+export type CreateOrderResponse<T extends BlockchainType = BlockchainType> = {
+    type: T;
+} & OrderResponseMap[T];
+export {};

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

@@ -1,4 +1,6 @@
 import { Url } from '@gardenfi/utils';
+import { BaseCreateOrderResponse, CreateOrderResponse, Order, StarknetOrderResponse, EvmOrderResponse, BitcoinOrderResponse, SolanaOrderResponse, SuiOrderResponse } from './orderbook/orderbook.types';
+import { BlockchainType } from './constants/asset.types';
 
 /**
  * Constructs a URL with the given base URL, endpoint and parameters (query params)
@@ -9,3 +11,38 @@ import { Url } from '@gardenfi/utils';
 export declare const ConstructUrl: (baseUrl: Url, endPoint: string, params?: {
     [key: string]: string | string[] | number | boolean | undefined;
 }) => URL;
+type OrderResponseTypeGuard<T> = (response: any) => response is T;
+/**
+ * Type guard for EVM order responses
+ */
+export declare const isEvmOrderResponse: OrderResponseTypeGuard<EvmOrderResponse>;
+/**
+ * Type guard for Starknet order responses
+ */
+export declare const isStarknetOrderResponse: OrderResponseTypeGuard<StarknetOrderResponse>;
+/**
+ * Type guard for Bitcoin order responses
+ */
+export declare const isBitcoinOrderResponse: OrderResponseTypeGuard<BitcoinOrderResponse>;
+/**
+ * Type guard for Solana order responses
+ */
+export declare const isSolanaOrderResponse: OrderResponseTypeGuard<SolanaOrderResponse>;
+/**
+ * Type guard for Sui order responses
+ */
+export declare const isSuiOrderResponse: OrderResponseTypeGuard<SuiOrderResponse>;
+/**
+ * Type guard for Order objects (matched orders)
+ */
+export declare const isOrder: OrderResponseTypeGuard<Order>;
+/**
+ * Discriminated union type guard that determines the specific order response type
+ * and returns the appropriate typed response
+ */
+export declare function discriminateOrderResponse(response: BaseCreateOrderResponse): CreateOrderResponse<BlockchainType.evm> | CreateOrderResponse<BlockchainType.starknet> | CreateOrderResponse<BlockchainType.bitcoin> | CreateOrderResponse<BlockchainType.solana> | CreateOrderResponse<BlockchainType.sui> | null;
+/**
+ * Utility function to get the blockchain type from an order response
+ */
+export declare function getOrderResponseType(response: any): BlockchainType | null;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gardenfi/orderbook",
-  "version": "2.5.3",
+  "version": "3.0.0",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -28,8 +28,9 @@
   },
   "dependencies": {
     "@coral-xyz/anchor": "^0.31.1",
-    "@gardenfi/utils": "2.5.3",
+    "@gardenfi/utils": "3.0.0",
     "bufferutil": "^4.0.8",
+    "node-cache": "^5.1.2",
     "siwe": "^2.1.4",
     "utf-8-validate": "^6.0.3",
     "ws": "^8.14.2"