@gardenfi/core 0.1.14 → 0.2.0-beta.0

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

@@ -0,0 +1,190 @@
+import { AsyncResult } from '@catalogfi/utils';
+import { IBitcoinWallet } from '@catalogfi/wallets';
+import { WalletClient } from 'viem';
+import { MatchedOrder } from '@gardenfi/orderbook';
+
+/**
+ * Order statuses
+ */
+export declare enum OrderStatus {
+    /**
+     * - Order is created
+     * - Waiting for match
+     */
+    Created = "Created",
+    /**
+     * - Order is matched
+     * - User has to initiate
+     */
+    Matched = "Matched",
+    /**
+     * - User initiate tx detected on-chain but not confirmed
+     */
+    InitiateDetected = "InitiateDetected",
+    /**
+     * - User initiated
+     * - Waiting for counter party to initiate
+     */
+    Initiated = "Initiated",
+    /**
+     * - Counter party initiate tx detected on-chain but not confirmed
+     */
+    CounterPartyInitiateDetected = "CounterPartyInitiateDetected",
+    /**
+     * - Counter party initiated
+     * - User has to redeem
+     */
+    CounterPartyInitiated = "CounterPartyInitiated",
+    /**
+     * - User redeem tx detected on-chain but not confirmed
+     */
+    RedeemDetected = "RedeemDetected",
+    /**
+     * - User redeemed
+     * - Counter party has to redeem
+     * - We also consider user redemption as completed order.
+     */
+    Redeemed = "Redeemed",
+    /**
+     * - Counter party redeem tx detected on-chain but not confirmed
+     */
+    CounterPartyRedeemDetected = "CounterPartyRedeemDetected",
+    /**
+     * - Counter party redeemed
+     * - Order is completed
+     */
+    CounterPartyRedeemed = "CounterPartyRedeemed",
+    /**
+     * - Counter party redeemed
+     * - Order is completed
+     */
+    Completed = "Completed",
+    /**
+     * - The counterparty's swap has expired, and they will refund their funds.
+     * - The user can no longer redeem the funds. The user must wait for their swap to expire and then refund their funds.
+     * - Typically, in our system, the counterparty's swap expires in 24 hours, and the user's swap expires in 48 hours.
+     */
+    CounterPartySwapExpired = "CounterPartySwapExpired",
+    /**
+     * - The user's swap has expired, and they have to refund their funds.
+     * - The user's expiry only happens after counterparty's expiry.
+     * - Typically, in our system, the counterparty's swap expires in 24 hours, and the user's swap expires in 48 hours.
+     */
+    Expired = "Expired",
+    /**
+     * - User refund tx detected on-chain but not confirmed
+     */
+    RefundDetected = "RefundDetected",
+    /**
+     * - User refunded
+     * - User can only refund if their swap has expired
+     */
+    Refunded = "Refunded",
+    /**
+     * - Counter party refund tx detected on-chain but not confirmed
+     */
+    CounterPartyRefundDetected = "CounterPartyRefundDetected",
+    /**
+     * - Counter party refunded
+     */
+    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"
+}
+export declare enum SwapStatus {
+    /**
+     * - Swap is idle
+     */
+    Idle = "Idle",
+    /**
+     * - Initiate tx detected on-chain but not confirmed
+     */
+    InitiateDetected = "InitiateDetected",
+    /**
+     * - Swap is initiated
+     */
+    Initiated = "Initiated",
+    /**
+     * - Redeem tx detected on-chain but not confirmed
+     */
+    RedeemDetected = "RedeemDetected",
+    /**
+     * - Redeemed
+     */
+    Redeemed = "Redeemed",
+    /**
+     * - Refund tx detected on-chain but not confirmed
+     */
+    RefundDetected = "RefundDetected",
+    /**
+     * - Refunded
+     */
+    Refunded = "Refunded",
+    /**
+     * - Swap is expired.
+     * - Should refund.
+     */
+    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/orderExecutor/orderStatusParser.d.ts

@@ -0,0 +1,27 @@
+import { MatchedOrder, Swap } from '@gardenfi/orderbook';
+import { OrderActions, OrderStatus, SwapStatus } from './orderExecutor.types';
+
+/**
+ * Parse the order status based on the current block number and checks if its expired or initiated or redeemed or refunded
+ * @param order Order object
+ * @param sourceChainCurrentBlockNumber source chain current block number
+ * @param destChainCurrentBlockNumber destination chain current block number
+ * @note send the current block number of the L1 chain even if the order is on L2 chain.
+ * @returns {OrderStatus} The status of the order
+ */
+export declare const ParseOrderStatus: (order: MatchedOrder, sourceChainCurrentBlockNumber: number, destChainCurrentBlockNumber: number) => OrderStatus;
+/**
+ * Parse the swap status based on the current block number and checks if its expired or initiated or redeemed or refunded
+ * @param swap The swap object
+ * @param currentBlockNumber
+ */
+export declare const ParseSwapStatus: (swap: Swap, currentBlockNumber: number) => SwapStatus;
+/**
+ * Parse the action to be performed on the.
+ * @param order Order object
+ * @param sourceChainCurrentBlockNumber source chain current block number
+ * @param destChainCurrentBlockNumber destination chain current block number
+ * @note send the current block number of the L1 chain even if the order is on L2 chain.
+ * @returns {OrderActions} The action to be performed on the order
+ */
+export declare const parseAction: (order: MatchedOrder, sourceChainCurrentBlockNumber: number, destChainCurrentBlockNumber: number) => OrderActions;

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

@@ -0,0 +1,15 @@
+import { WalletClient } from 'viem';
+import { ISecretManager } from './secretManager.types';
+
+export declare class SecretManager implements ISecretManager {
+    private privKey;
+    private constructor();
+    static fromPrivKey(privKey: string): SecretManager;
+    static fromWalletClient(walletClient: WalletClient): Promise<import('@catalogfi/utils').Result<never, string> | import('@catalogfi/utils').Result<SecretManager, never>>;
+    getMasterPrivKey(): string;
+    generateSecret(nonce: number): import('@catalogfi/utils').Result<{
+        secret: `0x${string}`;
+        secretHash: `0x${string}`;
+    }, never>;
+    private signMessage;
+}

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

@@ -0,0 +1,26 @@
+import { Result } from '@catalogfi/utils';
+
+export type Secret = {
+    secretHash: string;
+    secret: string;
+};
+/**
+ * Secret Manager Interface.
+ * This interface is used to generate and retrieve secrets and secretHashes.
+ * The secret is generated by hashing the signature and the secretHash is generated by hashing the secret.
+ */
+export interface ISecretManager {
+    /**
+     * Generates a new master private key.
+     * If the master private key already exists, it will return the existing master private key.
+     * Else, it will generate a new master private key by hashing a signature generated by signing a message with the wallet client.
+     * @returns Master private key
+     */
+    getMasterPrivKey: () => string;
+    /**
+     * Generates secret and secretHash by signing the nonce. Secret is generated by hashing the signature and secretHash is generated by hashing the secret.
+     * @param nonce
+     * @returns {AsyncResult<Secret, string>} secret,secretHash
+     */
+    generateSecret: (nonce: number) => Result<Secret, string>;
+}

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

@@ -3,3 +3,18 @@ import { Chain } from '@gardenfi/orderbook';
 
 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";
+/**
+ * Given a hex string or a buffer, return the x-only pubkey. (removes y coordinate the prefix)
+ */
+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
+ */
+export declare function serializeScript(leafScript: Buffer): Buffer;
+/**
+ * concats 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;

package/package.json

@@ -1,18 +1,13 @@
 {
   "name": "@gardenfi/core",
-  "version": "0.1.14",
+  "version": "0.2.0-beta.0",
   "type": "module",
-  "dependencies": {
-    "@catalogfi/utils": "^0.1.6",
-    "@catalogfi/wallets": "^0.2.45",
-    "@gardenfi/orderbook": "^0.1.9",
-    "ethers": "6.8.0"
-  },
   "files": [
     "dist"
   ],
   "scripts": {
     "build": "vite build",
+    "test": "vitest run",
     "dev": "vite build --watch"
   },
   "main": "./dist/index.cjs",
@@ -30,15 +25,24 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
+  "dependencies": {
+    "@catalogfi/utils": "^0.1.6",
+    "@catalogfi/wallets": "^0.2.49",
+    "@gardenfi/orderbook": "workspace:^",
+    "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"
+  },
   "devDependencies": {
-    "@types/jest": "^29.5.12",
     "dotenv": "^16.3.1",
-    "jest": "^29.7.0",
     "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"
+    "vite-plugin-wasm": "^3.3.0",
+    "vitest": "^1.6.0"
   },
   "sideEffects": false
-}
+}

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

@@ -1,3 +0,0 @@
-export declare const catalogWalletActions: {
-    createOrderAndSwap: string;
-};

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

@@ -1,46 +0,0 @@
-import { Orders, Order, Asset, IOrderbook } from '@gardenfi/orderbook';
-import { ISwapper } from './swapper';
-import { IGardenJS, Wallets } from './garden.types';
-
-/**
- * GardenJS is the core component of the Garden SDK. It allows you to create orders,
- * subscribe to order updates, and perform initiates, redeems, and refunds on swaps.
- *
- * Visit the [GardenJS documentation](https://docs.garden.finance/developers/sdk/) for more information.
- */
-export declare class GardenJS implements IGardenJS {
-    private readonly orderbook;
-    private readonly wallets;
-    /**
-     * @constructor
-     *
-     * @param {IOrderbook} orderbook - The orderbook you want to connect to
-     * @param {Partial<Wallets>} wallets - Each field in the wallet corresponds to the chain name and it's corresponding value is the wallet
-     *
-     */
-    constructor(orderbook: IOrderbook, wallets: Partial<Wallets>);
-    subscribeOrders(address: string, callback: (orders: Orders) => void): void;
-    unsubscribeOrders(): void;
-    /**
-     * Creates a swap order in the orderbook backend. Checkout `Assets` from @gardenfi/orderbook for the available assets
-     * @param from from asset (e.g. Assets.ethereum.WBTC)
-     * @param to to asset (e.g. Assets.bitcoin.BTC)
-     * @param amt send amount
-     * @param receiveAmount receive amount
-     * @param opts if the swap destination is bitcoin, you can provide a btcInputAddress to redeem funds to.
-     * @returns order id
-     *
-     * Note: localnet assets require `merry` running, else it will throw an error saying unsupported asset.
-     */
-    swap(from: Asset, to: Asset, amt: number, receiveAmount: number, opts?: {
-        btcUserAddress?: string;
-    }): Promise<number>;
-    /**
-     * Given an order, returns a Swapper instance to progress the swap (init, redeem, refund)
-     */
-    getSwap(order: Order): ISwapper;
-    /**
-     * Calculates the receive amount for the given send amount
-     */
-    calculateReceiveAmt(from: Asset, to: Asset, sendAmt: number): Promise<number>;
-}

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

@@ -1,53 +0,0 @@
-import { Asset, Chain, EvmChain, Order, Orders } from '@gardenfi/orderbook';
-import { IBitcoinWallet, IEVMWallet } from '@catalogfi/wallets';
-import { ISwapper } from './swapper';
-
-export interface IGardenJS {
-    /**
-     *
-     * Creates an order
-     *
-     * @method
-     * @param {Asset} from - The asset you want to swap from
-     * @param {Asset} to - The asset you want to swap to
-     * @param {number} amt - The amount you want to swap in it's lowest denomination
-     * @param {number} receiveAmount - The amount you want to receive in it's lowest denomination
-     * @param {Object} [opts] - Additional options for creating an order
-     * @param {string} [opts.btcUserAddress] - If specified, BTC will be sent to this address
-     * @returns {Promise<number>} The order ID
-     */
-    swap(from: Asset, to: Asset, amt: number, receiveAmount: number, opts?: {
-        btcUserAddress?: string;
-    }): Promise<number>;
-    /**
-     * Calculates the amount you receive. Currently deducts 0.3% of the amount you send.
-     */
-    calculateReceiveAmt(from: Asset, to: Asset, sendAmt: number): Promise<number>;
-    /**
-     * Subscribes to order updates
-     *
-     * @method
-     * @param {string} address - The address to subscribe to, currently each CatalogJS instance can only connect to a single address
-     * @param {(orders: Orders) => void} callback - The callback to call when the orders are updated. The first response are all the orders created by a given address
-     *
-     * @returns {void}
-     */
-    subscribeOrders(address: string, callback: (orders: Orders) => void): void;
-    /**
-     * Unsubscribes from order updates
-     *
-     * @method
-     * @returns {void}
-     */
-    unsubscribeOrders(): void;
-    /**
-     * Gets the swapper for an order, which allows you to progess (init, redeem, refund) the swap
-     *
-     * @param {Order} order - The order to get the swapper for
-     * @returns {ISwapper} The swapper
-     */
-    getSwap(order: Order): ISwapper;
-}
-export type Wallets<T extends Chain = Chain> = {
-    [K in T]: K extends EvmChain ? IEVMWallet : IBitcoinWallet;
-};

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

@@ -1,35 +0,0 @@
-import { Actions, Order, Chain } from '@gardenfi/orderbook';
-import { IBaseWallet } from '@catalogfi/wallets';
-
-export interface ISwapper {
-    id(): string;
-    next(): Promise<SwapOutput>;
-}
-export declare class Swapper implements ISwapper {
-    private order;
-    private wallets;
-    constructor(order: Order, wallet: Partial<Record<Chain, IBaseWallet>>);
-    get action(): Actions;
-    get status(): number;
-    next(): Promise<SwapOutput>;
-    private init;
-    private redeem;
-    private refund;
-    id(): string;
-    private getWallet;
-}
-export declare enum SwapperRole {
-    INITIATOR = "initiator",
-    REDEEMER = "redeemer"
-}
-export declare enum SwapperActions {
-    Init = "Initiate",
-    Redeem = "Redeem",
-    Refund = "Refund",
-    None = "None"
-}
-export type SwapOutput = {
-    user: SwapperRole;
-    action: SwapperActions;
-    output: string;
-};