@gardenfi/core 0.2.0-beta.2 → 0.2.0-beta.21

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/garden.d.ts

@@ -1,19 +1,47 @@
 import { ISecretManager } from './../secretManager/secretManager.types';
 import { AsyncResult } from '@catalogfi/utils';
-import { IGardenJS, SwapParams } from './garden.types';
-import { IOrderbook } 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 opts;
-    constructor(orderbook: IOrderbook, relayUrl: string, secretManager: ISecretManager, opts?: {
-        store?: IStore;
-        domain?: string;
+    private quote;
+    private getOrderThreshold;
+    private pendingOrdersCount;
+    private orderbookUrl;
+    private auth;
+    private useRelay;
+    private wallets;
+    private evmAddress;
+    private store;
+    constructor(config: {
+        orderbookURl: string;
+        secretManager: ISecretManager;
+        quote: IQuote;
+        auth: IAuth;
+        wallets: {
+            evmWallet: WalletClient;
+            btcWallet?: IBitcoinWallet;
+        };
     });
-    swap(params: SwapParams): AsyncResult<string, string>;
-    subscribeOrders(cb: (executor: IOrderExecutor) => Promise<void>, interval?: number): Promise<() => void>;
+    getPendingOrderCount(): number;
+    setUseRelay(useRelay: boolean): void;
+    swap(params: SwapParams): AsyncResult<MatchedOrder, string>;
+    private validateAndFillParams;
+    private getAddresses;
+    private validateAmount;
+    private getTimelock;
+    private pollOrder;
+    private emit;
+    execute(interval?: number): Promise<() => void>;
+    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,34 +1,86 @@
 import { AsyncResult } from '@catalogfi/utils';
-import { Asset } from '@gardenfi/orderbook';
-import { IOrderExecutor } from '../orderExecutor/orderExecutor.types';
+import { Asset, MatchedOrder } from '@gardenfi/orderbook';
 
 export type SwapParams = {
+    /**
+     * Asset to be sent.
+     */
     fromAsset: Asset;
+    /**
+     * Asset to be received.
+     */
     toAsset: Asset;
+    /**
+     * Amount in lowest denomination of the asset.
+     */
     sendAmount: string;
+    /**
+     * Amount in lowest denomination of the asset.
+     */
     receiveAmount: string;
-    sendAddress: string;
-    receiveAddress: string;
+    /**
+     * Time lock for the swap.
+     */
     timelock?: number;
+    /**
+     * This will wait for the specified number of confirmations before redeeming the funds.
+     */
     minDestinationConfirmations?: number;
-    additionalData?: {
-        btcAddress: string;
+    /**
+     * Additional data for the order.
+     */
+    additionalData: {
+        /**
+         * Get strategy id from the quote
+         */
+        strategyId: string;
+        /**
+         * Provide btcAddress if the destination or source chain is bitcoin. This address is used as refund address if source chain is bitcoin, and as redeem address if destination chain is bitcoin.
+         */
+        btcAddress?: string;
     };
 };
 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;
+};
+export type EventCallback = (...args: any[]) => void;
 export interface IGardenJS {
     /**
      * Create Order
      * @param {SwapParams} - The parameters for creating the order.
      */
-    swap(params: SwapParams): AsyncResult<string, string>;
+    swap(params: SwapParams): AsyncResult<MatchedOrder, string>;
     /**
      * Subscribe to orders. This will poll the orderbook and call callback for each order.
      * @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;
+};
+export interface IOrderCache {
+    getOrder(): MatchedOrder;
+    set(action: OrderActions, txHash: string): void;
+    get(action: OrderActions): OrderCacheValue | null;
+    remove(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/garden/orderCache.d.ts

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

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

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

@@ -0,0 +1,10 @@
+import { AsyncResult } from '@catalogfi/utils';
+import { IQuote, QuoteResponse } from './quote.types';
+import { CreateOrderRequestWithAdditionalData, CreateOrderReqWithStrategyId } from '@gardenfi/orderbook';
+
+export declare class Quote implements IQuote {
+    private quoteUrl;
+    constructor(quoteUrl: string);
+    getQuote(orderpair: string, amount: number, isExactOut?: boolean): Promise<import('@catalogfi/utils').Result<never, string> | import('@catalogfi/utils').Result<QuoteResponse, never>>;
+    getAttestedQuote(order: CreateOrderReqWithStrategyId): AsyncResult<CreateOrderRequestWithAdditionalData, string>;
+}

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

@@ -0,0 +1,29 @@
+import { AsyncResult } from '@catalogfi/utils';
+import { CreateOrderRequestWithAdditionalData, CreateOrderReqWithStrategyId } from '@gardenfi/orderbook';
+
+export interface IQuote {
+    /**
+     * Get a quote for the given orderpair and amount
+     * @param orderpair - A string representing the order pair for which the quote is requested.
+     *
+     * ``eg:- bitcoin_regtest:primary::arbitrum_localnet:0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9``
+     *
+     * Chain name and asset are separated by a colon(:) and chain pairs are separated by double colon(::)
+     * @param amount - The amount to quote
+     * @param isExactOut - Whether the amount is exact out
+     */
+    getQuote(orderpair: string, amount: number, isExactOut: boolean): AsyncResult<QuoteResponse, string>;
+    /**
+     * Attest the quote, server will return a signature by verifying and signing the quote according to the provided `strategy_id`
+     * @param order - The order for which the attestation is requested. Order should include `strategy_id` in the `additional_data` field.
+     * @returns {string} The attestation signature
+     */
+    getAttestedQuote(order: CreateOrderReqWithStrategyId): AsyncResult<CreateOrderRequestWithAdditionalData, string>;
+}
+export type QuoteResponse = {
+    quotes: {
+        [strategy_id: string]: string;
+    };
+    input_token_price: number;
+    output_token_price: number;
+};

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
  */
@@ -131,60 +126,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;
-    /**
-     * 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;
-    deleteHistory(): 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,12 +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.2",
+  "version": "0.2.0-beta.21",
   "type": "module",
   "files": [
     "dist"
@@ -27,21 +27,19 @@
   },
   "dependencies": {
     "@catalogfi/utils": "^0.1.6",
-    "@catalogfi/wallets": "^0.2.49",
-    "@gardenfi/orderbook": "^0.2.0-beta.2",
+    "@catalogfi/wallets": "^0.2.50",
+    "@gardenfi/orderbook": "^0.2.0-beta.10",
+    "@gardenfi/utils": "^0.0.1-beta.17",
     "bitcoinjs-lib": "^6.1.6",
     "tiny-secp256k1": "^2.2.3",
     "varuint-bitcoin": "^1.1.2",
-    "viem": "^2.21.15",
-    "vite-plugin-node-polyfills": "^0.22.0"
+    "viem": "^2.21.15"
   },
   "devDependencies": {
     "dotenv": "^16.3.1",
     "typescript": "^5.2.2",
     "vite": "^5.1.6",
     "vite-plugin-dts": "^3.7.3",
-    "vite-plugin-top-level-await": "^1.4.1",
-    "vite-plugin-wasm": "^3.3.0",
     "vitest": "^1.6.0"
   },
   "sideEffects": false

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

@@ -1,21 +0,0 @@
-import { AsyncResult } from '@catalogfi/utils';
-import { IBitcoinProvider } from '@catalogfi/wallets';
-import { WalletClient } 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>;
-/**
- * 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>;
-/**
- * Returns L1 blockNumber
- * @returns Ethereum chain latest block number
- */
-export declare const fetchL1BlockNumber: () => Promise<import('@catalogfi/utils').Result<never, string> | import('@catalogfi/utils').Result<number, never>>;

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

@@ -1,15 +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;
-    private cacheExpirationDuration;
-    constructor(order: MatchedOrder, store: IStore);
-    getOrder(): MatchedOrder;
-    set(action: OrderCacheAction, txHash: string): void;
-    get(action: OrderCacheAction): OrderCacheValue | null;
-    remove(action: OrderCacheAction): void;
-    deleteHistory(): 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;
-}