@gardenfi/core 0.1.14 → 0.2.0-beta.0

package/dist/src/index.d.ts

@@ -1,3 +1,10 @@
-export { GardenJS } from './lib/garden';
-export { SwapperActions, SwapperRole } from './lib/swapper';
-export { catalogWalletActions } from './lib/catalogActions';
+export { Garden } from './lib/garden/garden';
+export type { IGardenJS, SwapParams, TimeLocks, } from './lib/garden/garden.types';
+export { EvmRelay } from './lib/evmRelay/evmRelay';
+export type { IEVMRelay } from './lib/evmRelay/evmRelay.types';
+export { OrderExecutor } from './lib/orderExecutor/orderExecutor';
+export type { IOrderExecutor, OrderStatus, SwapStatus, OrderActions, } from './lib/orderExecutor/orderExecutor.types';
+export { fetchBitcoinBlockNumber, fetchL1BlockNumber, fetchEVMBlockNumber, } from './lib/orderExecutor/blockNumber';
+export { parseAction, ParseOrderStatus, ParseSwapStatus, } from './lib/orderExecutor/orderStatusParser';
+export { SecretManager } from './lib/secretManager/secretManager';
+export type { ISecretManager, Secret, } from './lib/secretManager/secretManager.types';

package/dist/src/lib/bitcoin/htlc.d.ts

@@ -0,0 +1,105 @@
+import { IBitcoinWallet, IHTLCWallet } from '@catalogfi/wallets';
+
+export declare enum Leaf {
+    REFUND = 0,
+    REDEEM = 1,
+    INSTANT_REFUND = 2
+}
+export declare class GardenHTLC implements IHTLCWallet {
+    /**
+     * Signer of the HTLC can be either the initiator or the redeemer
+     */
+    private signer;
+    private secretHash;
+    /**
+     * redeemer's x-only public key without 02 or 03 prefix
+     */
+    private redeemerPubkey;
+    /**
+     * initiator's x-only public key without 02 or 03 prefix
+     */
+    private initiatorPubkey;
+    private expiry;
+    /**
+     * NUMS internal key which blocks key path spending
+     */
+    private internalPubkey;
+    private network;
+    private initiateAmount;
+    /**
+     * Note: redeemerAddress and initiatorAddress should be x-only public key without 02 or 03 prefix
+     */
+    private constructor();
+    /**
+     * Creates a GardenHTLC instance
+     * @param signer Bitcoin wallet of the initiator or redeemer
+     * @param secretHash 32 bytes secret hash
+     * @param initiatorPubkey initiator's x-only public key without 02 or 03 prefix
+     * @param redeemerPubkey redeemer's x-only public key without 02 or 03 prefix
+     * @param expiry block height after which the funds can be refunded
+     * @returns GardenHTLC instance
+     *
+     *
+     * Note: When the signer is the initiator, only refund and instant refund can be done
+     * When the signer is the redeemer, only redeem can be done
+     */
+    static from(signer: IBitcoinWallet, initiateAmount: number, secretHash: string, initiatorPubkey: string, redeemerPubkey: string, expiry: number): Promise<GardenHTLC>;
+    /**
+     * Generates a taproot address for receiving the funds
+     */
+    address(): string;
+    /**
+     * returns the address of the HTLC
+     */
+    id(): string;
+    private _buildRawTx;
+    /**
+     * Builds a raw unsigned transaction with utxos from gardenHTLC address
+     * and uses signer's address as the output address
+     */
+    private buildRawTx;
+    /**
+     * prevout script for the gardenHTLC address
+     */
+    private getOutputScript;
+    init(fee?: number): Promise<string>;
+    /**
+     * Instantly refunds the funds to the initiator given the counterparty's signatures and pubkey
+     *
+     * Note: If there are multiple UTXOs being spend, there should be a signature for each UTXO in counterPartySigs
+     */
+    instantRefund(counterPartySigs: {
+        utxo: string;
+        sig: string;
+    }[], fee?: number): Promise<string>;
+    /**
+     * Reveals the secret and redeems the HTLC
+     */
+    redeem(secret: string, receiver?: string, fee?: number): Promise<string>;
+    /**
+     * Refunds the funds back to the initiator if the expiry block height + 1 is reached
+     */
+    refund(receiver?: string, fee?: number): Promise<string>;
+    /**
+     * Given a list of UTXOs, checks if the HTLC can be refunded
+     */
+    private canRefund;
+    /**
+     * Given a leaf, generates the control block necessary for spending the leaf
+     */
+    private generateControlBlockFor;
+    /**
+     * Generates the hash of the leaf script
+     * @param leaf Use leaf enum or pass 0 for refund, 1 for redeem, 2 for instant refund
+     * @returns hash of the leaf script
+     */
+    leafHash(leaf: Leaf): Buffer;
+    private refundLeaf;
+    private redeemLeaf;
+    private instantRefundLeaf;
+    private leaves;
+    /**
+     * Generates the merkle proof for the leaf script
+     */
+    private generateMerkleProofFor;
+}

package/dist/src/lib/bitcoin/internalKey.d.ts

@@ -0,0 +1,8 @@
+import * as ecc from 'tiny-secp256k1';
+/**
+ * Generates NUMS internal key
+ *
+ * Uses Standard ECDSA secp256k1 curve's G point
+ */
+export declare function generateInternalkey(): Buffer;
+export declare function tweakPubkey(pubkey: Buffer, hash: Buffer): ecc.XOnlyPointAddTweakResult;

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

@@ -1,4 +1,4 @@
-export declare const CatalogErrors: {
+export declare const GardenErrors: {
     WALLET_NOT_FOUND: (from: boolean) => string;
     CHAIN_WALLET_NOT_FOUND: (blockchain: "EVM" | "Bitcoin") => string;
 };
@@ -7,3 +7,17 @@ export declare const SwapperErrors: {
     NO_SECRET: string;
     INVALID_ACTION: (action: "init" | "redeem" | "refund", status: number) => string;
 };
+export declare const htlcErrors: {
+    secretMismatch: string;
+    secretHashLenMismatch: string;
+    pubkeyLenMismatch: string;
+    zeroOrNegativeExpiry: string;
+    htlcAddressGenerationFailed: string;
+    notFunded: string;
+    noCounterpartySigs: string;
+    counterPartySigNotFound: (utxo: string) => string;
+    invalidCounterpartySigForUTXO: (utxo: string) => string;
+    htlcNotExpired: (blocks: number) => string;
+    controlBlockGenerationFailed: string;
+    invalidLeaf: string;
+};

package/dist/src/lib/evmRelay/abi.d.ts

@@ -0,0 +1,305 @@
+export declare const AtomicSwapABI: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "token_";
+        readonly type: "address";
+    }, {
+        readonly internalType: "string";
+        readonly name: "name";
+        readonly type: "string";
+    }, {
+        readonly internalType: "string";
+        readonly name: "version";
+        readonly type: "string";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "constructor";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "InvalidShortString";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "str";
+        readonly type: "string";
+    }];
+    readonly name: "StringTooLong";
+    readonly type: "error";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [];
+    readonly name: "EIP712DomainChanged";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+        readonly name: "orderID";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+        readonly name: "secretHash";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "Initiated";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+        readonly name: "orderID";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+        readonly name: "secretHash";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "bytes";
+        readonly name: "secret";
+        readonly type: "bytes";
+    }];
+    readonly name: "Redeemed";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+        readonly name: "orderID";
+        readonly type: "bytes32";
+    }];
+    readonly name: "Refunded";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "eip712Domain";
+    readonly outputs: readonly [{
+        readonly internalType: "bytes1";
+        readonly name: "fields";
+        readonly type: "bytes1";
+    }, {
+        readonly internalType: "string";
+        readonly name: "name";
+        readonly type: "string";
+    }, {
+        readonly internalType: "string";
+        readonly name: "version";
+        readonly type: "string";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "chainId";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "address";
+        readonly name: "verifyingContract";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "salt";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "uint256[]";
+        readonly name: "extensions";
+        readonly type: "uint256[]";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "redeemer";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "timelock";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "secretHash";
+        readonly type: "bytes32";
+    }];
+    readonly name: "initiate";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "redeemer";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "timelock";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "secretHash";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "signature";
+        readonly type: "bytes";
+    }];
+    readonly name: "initiateWithSignature";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "orderID";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "signature";
+        readonly type: "bytes";
+    }];
+    readonly name: "instantRefund";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "address";
+            readonly name: "redeemer";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "expiry";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "amount";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "secretHash";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "signature";
+            readonly type: "bytes";
+        }];
+        readonly internalType: "struct HTLC.InitWithSig[]";
+        readonly name: "inits";
+        readonly type: "tuple[]";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "orderID";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "secret";
+            readonly type: "bytes";
+        }];
+        readonly internalType: "struct HTLC.Redeem[]";
+        readonly name: "redeems";
+        readonly type: "tuple[]";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "bytes32";
+            readonly name: "orderID";
+            readonly type: "bytes32";
+        }];
+        readonly internalType: "struct HTLC.Refund[]";
+        readonly name: "refunds";
+        readonly type: "tuple[]";
+    }];
+    readonly name: "multicall";
+    readonly outputs: readonly [{
+        readonly internalType: "bool[]";
+        readonly name: "results";
+        readonly type: "bool[]";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "";
+        readonly type: "bytes32";
+    }];
+    readonly name: "orders";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "isFulfilled";
+        readonly type: "bool";
+    }, {
+        readonly internalType: "address";
+        readonly name: "initiator";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "redeemer";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "initiatedAt";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "timelock";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "orderID";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "secret";
+        readonly type: "bytes";
+    }];
+    readonly name: "redeem";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "orderID";
+        readonly type: "bytes32";
+    }];
+    readonly name: "refund";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "token";
+    readonly outputs: readonly [{
+        readonly internalType: "contract IERC20";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];

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

@@ -0,0 +1,13 @@
+import { WalletClient } from 'viem';
+import { MatchedOrder } from '@gardenfi/orderbook';
+import { EVMRelayOpts, IEVMRelay } from './evmRelay.types';
+import { AsyncResult } from '@catalogfi/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>;
+    redeem(orderId: string, secret: string): AsyncResult<string, string>;
+}

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

@@ -0,0 +1,26 @@
+import { AsyncResult } from '@catalogfi/utils';
+import { MatchedOrder } from '@gardenfi/orderbook';
+import { IStore } from '@gardenfi/utils';
+
+export type EVMRelayOpts = {
+    store?: IStore;
+    domain?: string;
+};
+export interface IEVMRelay {
+    /**
+     * Deposits funds to the EVM atomic swap contract using relay service.
+     * 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.
+     * @returns txHash of Initiation
+     */
+    init(order: MatchedOrder, currentL1BlockNumber: number): AsyncResult<string, string>;
+    /**
+     * Redeems funds from the EVM atomic swap contract using relay service.
+     * Sends the secret to the relay service.
+     * @param orderId Create order Id of the order
+     * @param secret Secret of the HTLC generated when creating the order
+     */
+    redeem(orderId: string, secret: string): AsyncResult<string, string>;
+}

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

@@ -0,0 +1,19 @@
+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';
+
+export declare class Garden implements IGardenJS {
+    private secretManager;
+    private orderBook;
+    private relayURL;
+    private opts;
+    constructor(orderbook: IOrderbook, relayUrl: string, secretManager: ISecretManager, opts?: {
+        store?: IStore;
+        domain?: string;
+    });
+    swap(params: SwapParams): AsyncResult<string, string>;
+    subscribeOrders(cb: (executor: IOrderExecutor) => Promise<void>, interval?: number): Promise<() => void>;
+}

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

@@ -0,0 +1,34 @@
+import { AsyncResult } from '@catalogfi/utils';
+import { Asset } from '@gardenfi/orderbook';
+import { IOrderExecutor } from '../orderExecutor/orderExecutor.types';
+
+export type SwapParams = {
+    fromAsset: Asset;
+    toAsset: Asset;
+    sendAmount: string;
+    receiveAmount: string;
+    sendAddress: string;
+    receiveAddress: string;
+    timelock?: number;
+    minDestinationConfirmations?: number;
+    additionalData?: {
+        btcAddress: string;
+    };
+};
+export declare enum TimeLocks {
+    evm = 14400,
+    btc = 288
+}
+export interface IGardenJS {
+    /**
+     * Create Order
+     * @param {SwapParams} - The parameters for creating the order.
+     */
+    swap(params: SwapParams): AsyncResult<string, 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>;
+}

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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,25 @@
+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;
+}