@gardenfi/core 0.2.0-beta.4 → 0.2.0-beta.41

package/dist/src/lib/evm/htlc/evmHTLC.types.d.ts

@@ -0,0 +1,29 @@
+import { MarkRequired } from '@catalogfi/utils';
+import { OnChainIdentifier } from '@catalogfi/wallets';
+import { Address } from 'viem';
+
+export type AtomicSwapConfig = {
+    secretHash: string;
+    /**
+     * The number of blocks before the swap expires
+     */
+    expiryBlocks: number;
+    /**
+     * Amount in it's lowest denomination
+     */
+    amount: bigint;
+    recipientAddress: OnChainIdentifier;
+    refundAddress: OnChainIdentifier;
+    initiatorAddress: OnChainIdentifier;
+    contractAddress?: Address;
+    chain?: number;
+};
+export type EVMSwapConfig = MarkRequired<AtomicSwapConfig, 'chain' | 'contractAddress'>;
+export declare const EVMHTLCErrors: {
+    INVALID_SECRET_HASH: string;
+    INSUFFICIENT_TOKENS: string;
+    ORDER_INITIATED: string;
+    INVALID_SECRET: string;
+    ORDER_NOT_EXPIRED: string;
+    INSUFFICIENT_FUNDS: (balance: string, required: string) => string;
+};

package/dist/src/lib/{evmRelay → evm/relay}/evmRelay.d.ts

@@ -1,13 +1,14 @@
 import { WalletClient } from 'viem';
 import { MatchedOrder } from '@gardenfi/orderbook';
-import { EVMRelayOpts, IEVMRelay } from './evmRelay.types';
+import { IEVMRelay } from './evmRelay.types';
 import { AsyncResult } from '@catalogfi/utils';
+import { IAuth } from '@gardenfi/utils';
 
 export declare class EvmRelay implements IEVMRelay {
-    private walletClient;
     private url;
     private auth;
-    constructor(url: string, walletClient: WalletClient, opts?: EVMRelayOpts);
-    init(order: MatchedOrder, currentL1BlockNumber: number): AsyncResult<string, string>;
+    private order;
+    constructor(order: MatchedOrder, url: string, auth: IAuth);
+    init(walletClient: WalletClient, currentL1BlockNumber?: number): AsyncResult<string, string>;
     redeem(orderId: string, secret: string): AsyncResult<string, string>;
 }

package/dist/src/lib/{evmRelay → evm/relay}/evmRelay.types.d.ts

@@ -1,6 +1,6 @@
 import { AsyncResult } from '@catalogfi/utils';
-import { MatchedOrder } from '@gardenfi/orderbook';
 import { IStore } from '@gardenfi/utils';
+import { WalletClient } from 'viem';
 
 export type EVMRelayOpts = {
     store?: IStore;
@@ -12,10 +12,10 @@ export interface IEVMRelay {
      * Sends the signature to the relay service.
      * @param order Matched Order
      * @param currentL1BlockNumber Current L1 block number. Used to calculate the swap expiry.
-     * @NOTE send the current block number of the L1 chain even if the order is on L2 chain.
+     * @NOTE send the current block number of the L1 chain, if the order is on L2 chain (arbitrum).
      * @returns txHash of Initiation
      */
-    init(order: MatchedOrder, currentL1BlockNumber: number): AsyncResult<string, string>;
+    init(walletClient: WalletClient, currentL1BlockNumber: number): AsyncResult<string, string>;
     /**
      * Redeems funds from the EVM atomic swap contract using relay service.
      * Sends the secret to the relay service.

package/dist/src/lib/garden/cache/executorCache.d.ts

@@ -0,0 +1,9 @@
+import { MatchedOrder } from '@gardenfi/orderbook';
+import { IOrderExecutorCache, OrderActions, OrderCacheValue } from '../garden.types';
+
+export declare class ExecutorCache implements IOrderExecutorCache {
+    private cache;
+    set(order: MatchedOrder, action: OrderActions, txHash: string, utxo?: string): void;
+    get(order: MatchedOrder, action: OrderActions): OrderCacheValue | null;
+    remove(order: MatchedOrder, action: OrderActions): void;
+}

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

@@ -1,22 +1,50 @@
 import { ISecretManager } from './../secretManager/secretManager.types';
 import { AsyncResult } from '@catalogfi/utils';
-import { IGardenJS, SwapParams } from './garden.types';
-import { IOrderbook, MatchedOrder } from '@gardenfi/orderbook';
-import { IStore } from '@gardenfi/utils';
-import { IOrderExecutor } from '../orderExecutor/orderExecutor.types';
+import { GardenEvents, IGardenJS, SwapParams } from './garden.types';
+import { MatchedOrder } from '@gardenfi/orderbook';
+import { IAuth } from '@gardenfi/utils';
+import { IQuote } from '../quote/quote.types';
+import { WalletClient } from 'viem';
+import { IBitcoinWallet } from '@catalogfi/wallets';
 
 export declare class Garden implements IGardenJS {
     private secretManager;
+    private readonly eventListeners;
     private orderBook;
-    private relayURL;
     private quote;
-    private opts;
     private getOrderThreshold;
-    constructor(orderbook: IOrderbook, secretManager: ISecretManager, relayUrl: string, quoteUrl: string, opts?: {
-        store?: IStore;
-        domain?: string;
+    private pendingOrdersCount;
+    private orderbookUrl;
+    private auth;
+    private useRelay;
+    private wallets;
+    private evmAddress;
+    private orderExecutorCache;
+    constructor(config: {
+        orderbookURl: string;
+        secretManager: ISecretManager;
+        quote: IQuote;
+        auth: IAuth;
+        wallets: {
+            evmWallet: WalletClient;
+            btcWallet?: IBitcoinWallet;
+        };
     });
+    getPendingOrderCount(): number;
+    setUseRelay(useRelay: boolean): void;
     swap(params: SwapParams): AsyncResult<MatchedOrder, string>;
-    subscribeOrders(cb: (executor: IOrderExecutor) => Promise<void>, interval?: number): Promise<() => void>;
-    private validateSwapParams;
+    private validateAndFillParams;
+    private getAddresses;
+    private validateAmount;
+    private getTimelock;
+    private pollOrder;
+    private emit;
+    execute(interval?: number): Promise<() => void>;
+    private evmRedeem;
+    private btcRedeem;
+    private btcRefund;
+    private getWallet;
+    on<E extends keyof GardenEvents>(event: E, cb: GardenEvents[E]): void;
+    off<E extends keyof GardenEvents>(event: E, cb: GardenEvents[E]): void;
+    private fetchCurrentBlockNumbers;
 }

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

@@ -1,6 +1,5 @@
 import { AsyncResult } from '@catalogfi/utils';
 import { Asset, MatchedOrder } from '@gardenfi/orderbook';
-import { IOrderExecutor } from '../orderExecutor/orderExecutor.types';
 
 export type SwapParams = {
     /**
@@ -19,18 +18,6 @@ export type SwapParams = {
      * Amount in lowest denomination of the asset.
      */
     receiveAmount: string;
-    /**
-     * EVM - The address from the which the user is sending funds from.
-     *
-     * Bitcoin - Provide public key if the source chain is bitcoin.
-     */
-    sendAddress: string;
-    /**
-     * EVM - The address at which the user wants to receive funds.
-     *
-     * Bitcoin - Provide public key if the destination chain is bitcoin.
-     */
-    receiveAddress: string;
     /**
      * Time lock for the swap.
      */
@@ -57,6 +44,13 @@ export declare enum TimeLocks {
     evm = 14400,
     btc = 288
 }
+export type GardenEvents = {
+    error: (order: MatchedOrder, error: string) => void;
+    success: (order: MatchedOrder, action: OrderActions, result: string) => void;
+    onPendingOrdersChanged: (orders: MatchedOrder[]) => void;
+    log: (id: string, message: string) => void;
+};
+export type EventCallback = (...args: any[]) => void;
 export interface IGardenJS {
     /**
      * Create Order
@@ -68,5 +62,26 @@ export interface IGardenJS {
      * @param cb - Callback function to be called for each order. This callback will take orderExecutor as an argument.
      * @param interval - Polling interval in milliseconds.
      */
-    subscribeOrders(cb: (orderExecutor: IOrderExecutor) => Promise<void>, interval?: number): Promise<() => void>;
+    execute(): Promise<() => void>;
+    getPendingOrderCount(): number;
+    on<E extends keyof GardenEvents>(event: E, cb: GardenEvents[E]): void;
+}
+export type OrderCacheValue = {
+    txHash: string;
+    timeStamp: number;
+    btcRedeemUTXO?: string;
+};
+export interface IOrderExecutorCache {
+    set(order: MatchedOrder, action: OrderActions, txHash: string, utxo?: string): void;
+    get(order: MatchedOrder, action: OrderActions): OrderCacheValue | null;
+    remove(order: MatchedOrder, action: OrderActions): void;
+}
+/**
+ * Actions that can be performed on the order.
+ */
+export declare enum OrderActions {
+    Idle = "Idle",
+    Initiate = "Initiate",
+    Redeem = "Redeem",
+    Refund = "Refund"
 }

package/dist/src/lib/{orderExecutor → garden}/orderStatusParser.d.ts

@@ -1,5 +1,6 @@
 import { MatchedOrder, Swap } from '@gardenfi/orderbook';
-import { OrderActions, OrderStatus, SwapStatus } from './orderExecutor.types';
+import { OrderActions } from './garden.types';
+import { OrderStatus, SwapStatus } from '../status';
 
 /**
  * Parse the order status based on the current block number and checks if its expired or initiated or redeemed or refunded
@@ -25,3 +26,4 @@ export declare const ParseSwapStatus: (swap: Swap, currentBlockNumber: number) =
  * @returns {OrderActions} The action to be performed on the order
  */
 export declare const parseAction: (order: MatchedOrder, sourceChainCurrentBlockNumber: number, destChainCurrentBlockNumber: number) => OrderActions;
+export declare const isExpired: (unixTime: number, tillHours?: number) => boolean;

package/dist/src/lib/{orderExecutor/orderExecutor.types.d.ts → status.d.ts}

@@ -1,8 +1,3 @@
-import { AsyncResult } from '@catalogfi/utils';
-import { IBitcoinWallet } from '@catalogfi/wallets';
-import { WalletClient } from 'viem';
-import { MatchedOrder } from '@gardenfi/orderbook';
-
 /**
  * Order statuses
  */
@@ -90,11 +85,13 @@ export declare enum OrderStatus {
     CounterPartyRefunded = "CounterPartyRefunded",
     /**
      * - Order is cancelled
-     * - There are some cases where the order is cancelled:
-     *   1) Not matched within 1 hour.
-     *   2) Both parties refund.
      */
-    Cancelled = "Cancelled"
+    Cancelled = "Cancelled",
+    /**
+     * - DeadLine exceeded
+     * - Initiate not detected before 1 hour of deadline or initiate not confirmed before 12 hours of deadline
+     */
+    DeadLineExceeded = "DeadLineExceeded"
 }
 export declare enum SwapStatus {
     /**
@@ -131,65 +128,3 @@ export declare enum SwapStatus {
      */
     Expired = "Expired"
 }
-export declare enum OrderActions {
-    Idle = "Idle",
-    Initiate = "Initiate",
-    Redeem = "Redeem",
-    Refund = "Refund"
-}
-export type ExecuteParams = {
-    wallets: {
-        source: IBitcoinWallet | WalletClient;
-        destination: IBitcoinWallet | WalletClient;
-    };
-    blockNumbers?: {
-        source: number;
-        destination: number;
-    };
-};
-/**
- * This is a generic interface for Order. Use this interface to perform operations on the order (init, redeem, refund, execute).
- */
-export interface IOrderExecutor {
-    /**
-     * Get the order details.
-     * @returns MatchedOrder
-     */
-    getOrder(): MatchedOrder;
-    /**
-     * Initiate the atomic swap contract.
-     * @param wallet - Wallet to initiate the swap.
-     * @param currentBlockNumber - Current block number of the chain. Provide L1 block number if chain is arbitrum or arbitrum_sepolia.
-     */
-    init(wallet: WalletClient | IBitcoinWallet, currentBlockNumber?: number): AsyncResult<string, string>;
-    /**
-     * Redeem the funds from the atomic swap contract.
-     */
-    redeem(wallet: WalletClient | IBitcoinWallet, secret: string): AsyncResult<string, string>;
-    /**
-     * Refund the funds from the atomic swap contract after expiry.
-     */
-    refund(wallet: IBitcoinWallet): AsyncResult<string, string>;
-    /**
-     * This will take care of order execution according to its current status, i.e., redeem or refund.
-     *
-     * Redeem:- Both EVM and BTC redeems are done by executor, and only BTC refund is done by executor.
-     * EVM refund is done automatically by the relayer service.
-     */
-    execute(params: ExecuteParams): AsyncResult<string | void, string>;
-}
-export declare enum OrderCacheAction {
-    init = "init",
-    redeem = "redeem",
-    refund = "refund"
-}
-export type OrderCacheValue = {
-    txHash: string;
-    timeStamp: number;
-};
-export interface IOrderCache {
-    getOrder(): MatchedOrder;
-    set(action: OrderCacheAction, txHash: string): void;
-    get(action: OrderCacheAction): OrderCacheValue | null;
-    remove(action: OrderCacheAction): void;
-}

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

@@ -1,5 +1,8 @@
+import { Chain as viemChain } from 'viem/chains';
 import { IBaseWallet } from '@catalogfi/wallets';
-import { Chain } from '@gardenfi/orderbook';
+import { Chain, EvmChain } from '@gardenfi/orderbook';
+import { WalletClient } from 'viem';
+import { AsyncResult } from '@catalogfi/utils';
 
 export declare const computeSecret: (fromChain: Chain, toChain: Chain, wallets: Partial<Record<Chain, IBaseWallet>>, nonce: number) => Promise<string>;
 export declare const isFromChainBitcoin: (chain: Chain) => chain is "bitcoin" | "bitcoin_testnet" | "bitcoin_regtest";
@@ -9,13 +12,24 @@ export declare const isFromChainBitcoin: (chain: Chain) => chain is "bitcoin" |
 export declare function xOnlyPubkey(pubkey: Buffer | string): Buffer;
 export declare function assert(condition: boolean, message: string): void;
 /**
- * concats the leaf version, the length of the script, and the script itself
+ * concat the leaf version, the length of the script, and the script itself
  */
 export declare function serializeScript(leafScript: Buffer): Buffer;
 /**
- * concats the length of the script and the script itself
+ * concat the length of the script and the script itself
  */
 export declare function prefixScriptLength(s: Buffer): Buffer;
 export declare function sortLeaves(leaf1: Buffer, leaf2: Buffer): Buffer[];
 export declare const toXOnly: (pubKey: string) => string;
 export declare const isValidBitcoinPubKey: (pubKey: string) => boolean;
+export declare const ChainToID: Record<EvmChain, viemChain>;
+/**
+ * Switches or adds a network to the wallet
+ * @param chain Garden supported chain
+ * @param walletClient
+ * @returns new walletClient with updated chain
+ */
+export declare const switchOrAddNetwork: (chain: Chain, walletClient: WalletClient) => AsyncResult<{
+    message: string;
+    walletClient: WalletClient;
+}, string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gardenfi/core",
-  "version": "0.2.0-beta.4",
+  "version": "0.2.0-beta.41",
   "type": "module",
   "files": [
     "dist"
@@ -27,8 +27,10 @@
   },
   "dependencies": {
     "@catalogfi/utils": "^0.1.6",
-    "@catalogfi/wallets": "^0.2.49",
-    "@gardenfi/orderbook": "^0.2.0-beta.4",
+    "@catalogfi/wallets": "^0.2.50",
+    "@gardenfi/orderbook": "^0.2.0-beta.14",
+    "@gardenfi/utils": "^0.0.1-beta.18",
+    "bignumber.js": "^9.1.2",
     "bitcoinjs-lib": "^6.1.6",
     "tiny-secp256k1": "^2.2.3",
     "varuint-bitcoin": "^1.1.2",

package/dist/src/lib/orderExecutor/blockNumber.d.ts

@@ -1,17 +0,0 @@
-import { AsyncResult } from '@catalogfi/utils';
-import { IBitcoinProvider } from '@catalogfi/wallets';
-import { WalletClient, Chain } from 'viem';
-
-/**
- * Fetches the latest block number of EVM chain
- * @param walletClient Wallet client
- * @returns EVM latest block number
- */
-export declare const fetchEVMBlockNumber: (walletClient: WalletClient) => AsyncResult<number, string>;
-export declare const _fetchEVMBlockNumber: (chain: Chain) => Promise<import('@catalogfi/utils').Result<never, string> | import('@catalogfi/utils').Result<number, never>>;
-/**
- * Fetches the latest block number of Bitcoin chain
- * @param btcProvider Bitcoin provider
- * @returns bitcoin latest block number
- */
-export declare const fetchBitcoinBlockNumber: (btcProvider: IBitcoinProvider) => AsyncResult<number, string>;

package/dist/src/lib/orderExecutor/orderCache.d.ts

@@ -1,13 +0,0 @@
-import { MatchedOrder } from '@gardenfi/orderbook';
-import { IStore } from '@gardenfi/utils';
-import { IOrderCache, OrderCacheAction, OrderCacheValue } from './orderExecutor.types';
-
-export declare class OrderCache implements IOrderCache {
-    private order;
-    private store;
-    constructor(order: MatchedOrder, store?: IStore);
-    getOrder(): MatchedOrder;
-    set(action: OrderCacheAction, txHash: string): void;
-    get(action: OrderCacheAction): OrderCacheValue | null;
-    remove(action: OrderCacheAction): void;
-}

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

@@ -1,25 +0,0 @@
-import { WalletClient } from 'viem';
-import { ExecuteParams, IOrderExecutor } from './orderExecutor.types';
-import { IBitcoinWallet } from '@catalogfi/wallets';
-import { MatchedOrder } from '@gardenfi/orderbook';
-import { IStore } from '@gardenfi/utils';
-import { AsyncResult } from '@catalogfi/utils';
-import { ISecretManager } from '../secretManager/secretManager.types';
-
-export declare class OrderExecutor implements IOrderExecutor {
-    private order;
-    private relayURL;
-    private secretManager;
-    private opts;
-    private orderCache;
-    constructor(order: MatchedOrder, relayURL: string, secretManager: ISecretManager, opts?: {
-        store?: IStore;
-        domain?: string;
-    });
-    getOrder(): MatchedOrder;
-    init(walletClient: WalletClient, currentBlockNumber?: number): AsyncResult<string, string>;
-    redeem(wallet: WalletClient | IBitcoinWallet, secret: string): AsyncResult<string, string>;
-    refund(wallet: IBitcoinWallet): AsyncResult<string, string>;
-    execute(params: ExecuteParams): AsyncResult<string | void, string>;
-    private fetchCurrentBlockNumber;
-}