@gardenfi/core 2.5.2-beta.5 → 2.5.3-beta.0

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

@@ -0,0 +1,46 @@
+import { Order } from '@gardenfi/orderbook';
+import { OrderAction } from 'src/lib/orderStatus/orderStatus';
+
+export declare enum CacheType {
+    OrderExecutor = "orderExecutor",
+    BitcoinRedeem = "bitcoinRedeem",
+    RefundSacp = "refundSacp"
+}
+export type OrderExecutorCacheValue = {
+    txHash: string;
+    timeStamp: number;
+    btcRedeemUTXO?: string;
+};
+export type RefundSacpCacheValue = {
+    initTxHash: string;
+};
+export type BitcoinRedeemCacheValue = {
+    redeemedFromUTXO: string;
+    redeemedAt: number;
+    redeemTxHash: string;
+};
+interface CacheOptions {
+    max?: number;
+    ttl?: number;
+}
+export declare class GardenCache {
+    private cache;
+    constructor(options?: CacheOptions);
+    private makeKey;
+    set<T>(type: CacheType, key: string, value: T, ttl?: number): void;
+    get<T>(type: CacheType, key: string): T | undefined;
+    remove(type: CacheType, key: string): void;
+    clear(type?: CacheType): void;
+    setBitcoinRedeem(orderId: string, data: BitcoinRedeemCacheValue, ttl?: number): void;
+    getBitcoinRedeem(orderId: string): BitcoinRedeemCacheValue | undefined;
+    setOrderExecution(order: Order, action: OrderAction | string, txHash: string, utxo?: string, ttl?: number): void;
+    getOrderExecution(order: Order, action: OrderAction | string): OrderExecutorCacheValue | undefined;
+    removeOrderExecution(order: Order, action: OrderAction | string): void;
+    private makeOrderKey;
+    setSacpCache(orderId: string, data: RefundSacpCacheValue, ttl?: number): void;
+    getSacpCache(orderId: string): RefundSacpCacheValue | undefined;
+    has(type: CacheType, key: string): boolean;
+    peek<T>(type: CacheType, key: string): T | undefined;
+    getRemainingTTL(type: CacheType, key: string): number;
+}
+export {};

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

@@ -0,0 +1,26 @@
+import { DigestKey, IAuth } from '@gardenfi/utils';
+import { GardenEventEmitter, GardenHTLCModules } from './../garden.types';
+import { IOrderbook } from '@gardenfi/orderbook';
+import { Api } from '../../constants';
+
+export declare class Executor {
+    #private;
+    private htlcs;
+    private events;
+    private isBackgroundServiceRunning;
+    private executorStop;
+    constructor(digestKey: DigestKey, htlcs: GardenHTLCModules, orderbook: IOrderbook, auth: IAuth, api: Api, events: GardenEventEmitter);
+    private getAddressesFromHTLCs;
+    startBackgroundService(interval: number | undefined, redeemServiceEnabled: boolean): void;
+    stopBackgroundService(): void;
+    execute(interval?: number): Promise<() => void>;
+    private processOrderActions;
+    private handleRedeemAction;
+    private evmRedeem;
+    private starknetRedeem;
+    private solRedeem;
+    private suiRedeem;
+    private btcRedeem;
+    private postRefundSACP;
+    private broadcastRedeemTx;
+}

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

@@ -1,67 +1,60 @@
 import { ISecretManager } from './../secretManager/secretManager.types';
-import { GardenEvents, IGardenJS, SwapParams, GardenConfigWithHTLCs, GardenConfigWithWallets } from './garden.types';
-import { IOrderbook, MatchedOrder } from '@gardenfi/orderbook';
-import { EventBroker, IAuth, DigestKey, AsyncResult } from '@gardenfi/utils';
+import { IGardenJS, SwapParams, GardenConfigWithHTLCs, GardenConfigWithWallets, GardenEvents } from './garden.types';
+import { CreateOrderRequest, IOrderbook, Orderbook } from '@gardenfi/orderbook';
+import { IAuth, DigestKey, AsyncResult } from '@gardenfi/utils';
 import { IQuote } from '../quote/quote.types';
-import { IBlockNumberFetcher } from '../blockNumberFetcher/blockNumber';
-import { IEVMHTLC } from '../evm/htlc.types';
-import { IStarknetHTLC } from '../starknet/starknetHTLC.types';
-import { IBitcoinWallet } from '../bitcoin/wallet/wallet.interface';
-import { ISolanaHTLC } from '../solana/htlc/ISolanaHTLC';
-import { ISuiHTLC } from '../sui/suiHTLC.types';
+import { Executor } from './executor/executor';
 
-export declare class Garden extends EventBroker<GardenEvents> implements IGardenJS {
-    private environment;
-    private _secretManager;
-    private _orderbook;
+export declare class Garden extends Orderbook implements IGardenJS {
+    private network;
     private _quote;
-    private getOrderThreshold;
     private _auth;
-    private orderExecutorCache;
-    private _blockNumberFetcher;
-    private refundSacpCache;
-    private _evmHTLC;
-    private _starknetHTLC;
-    private _solanaHTLC;
-    private _suiHTLC;
-    private _btcWallet;
-    private bitcoinRedeemCache;
-    private _digestKey;
+    private _htlcs;
     private _api;
-    private isSecretManagementEnabled;
+    private _executor;
+    private _events;
+    /**
+     * If true, the redeem service will be enabled.
+     */
+    private redeemServiceEnabled;
+    private _secretManager;
+    private _digestKey;
+    private executeInterval;
     constructor(config: GardenConfigWithHTLCs);
-    handleSecretManagement(enabled: boolean): this;
+    /**
+     * Enables or disables the auto-redeem service provided by Garden API.
+     *
+     * If enabled, make sure to pass DigestKey to the constructor.
+     * @default true
+     * @param enabled - boolean
+     * @returns this
+     */
+    setRedeemServiceEnabled(enabled: boolean): this;
     static fromWallets(config: GardenConfigWithWallets): Garden;
-    get evmHTLC(): IEVMHTLC | undefined;
-    get starknetHTLC(): IStarknetHTLC | undefined;
-    get solanaHTLC(): ISolanaHTLC | undefined;
-    get suiHTLC(): ISuiHTLC | undefined;
+    get htlcs(): {
+        readonly evm: import('../..').IEVMHTLC | undefined;
+        readonly starknet: import('../..').IStarknetHTLC | undefined;
+        readonly solana: import('../..').ISolanaHTLC | undefined;
+        readonly sui: import('../sui/suiHTLC.types').ISuiHTLC | undefined;
+        readonly bitcoin: import('../bitcoin/bitcoinhtlc.types').IBitcoinHTLC | undefined;
+    };
     get quote(): IQuote;
-    get btcWallet(): IBitcoinWallet | undefined;
     get orderbook(): IOrderbook;
-    get blockNumberFetcher(): IBlockNumberFetcher;
     get secretManager(): ISecretManager;
     get auth(): IAuth;
-    get digestKey(): DigestKey;
+    get digestKey(): DigestKey | undefined;
+    get executor(): Executor | undefined;
+    /**
+     * Creates an order for a swap operation and initiates the HTLC on the source chain.
+     * @param params SwapParams
+     * @returns AsyncResult<Order, string>
+     */
+    createSwap(params: SwapParams): AsyncResult<string, string>;
     /**
-     * This method takes in the `SwapParams` and returns a placed order
-     * It internally calls `getAttestedQuote`, `createOrder` and `pollOrder`
-     * @param swapParams
-     * @returns MatchedOrder
+     * Create an order
      */
-    swap(params: SwapParams): AsyncResult<MatchedOrder, string>;
-    private withDefaultAffiliateFees;
+    createOrder(arg: CreateOrderRequest | SwapParams, auth?: IAuth): AsyncResult<any, string>;
     private validateAndFillParams;
-    private getAddresses;
-    private validateAmount;
-    execute(interval?: number): Promise<() => void>;
-    private solRedeem;
-    private suiRedeem;
-    private evmRedeem;
-    private starknetRedeem;
-    private btcRedeem;
-    private btcRefund;
-    private postRefundSACP;
-    private assignStatus;
-    private broadcastRedeemTx;
+    on<K extends keyof GardenEvents>(event: K, listener: GardenEvents[K]): this;
+    off<K extends keyof GardenEvents>(event: K, listener: GardenEvents[K]): this;
 }

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

@@ -1,29 +1,30 @@
-import { AffiliateFeeOptionalChainAsset, Asset, IOrderbook, MatchedOrder } from '@gardenfi/orderbook';
-import { OrderStatus } from '../orderStatus/status';
-import { AsyncResult, Environment, EventBroker, IAuth, DigestKey } from '@gardenfi/utils';
+import { AffiliateFee, Asset, BlockchainType, ChainAsset, ChainAssetString, IOrderbook, Order } from '@gardenfi/orderbook';
+import { OrderAction, OrderStatus } from '../orderStatus/orderStatus';
+import { ApiKey, AsyncResult, IAuth, Network, DigestKey } from '@gardenfi/utils';
 import { ISecretManager } from '../secretManager/secretManager.types';
 import { IQuote } from '../quote/quote.types';
-import { IBlockNumberFetcher } from '../blockNumberFetcher/blockNumber';
 import { IEVMHTLC } from '../evm/htlc.types';
 import { IStarknetHTLC } from '../starknet/starknetHTLC.types';
 import { AccountInterface } from 'starknet';
 import { WalletClient } from 'viem';
-import { Api } from '../constants';
 import { IBitcoinWallet } from '../bitcoin/wallet/wallet.interface';
 import { ISolanaHTLC } from '../solana/htlc/ISolanaHTLC';
 import { AnchorProvider } from '@coral-xyz/anchor';
+import { Api } from '../constants';
 import { ISuiHTLC } from '../sui/suiHTLC.types';
 import { WalletWithRequiredFeatures } from '@mysten/wallet-standard';
+import { IBitcoinHTLC } from '../bitcoin/bitcoinhtlc.types';
+import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
 
 export type SwapParams = {
     /**
      * Asset to be sent.
      */
-    fromAsset: Asset;
+    fromAsset: Asset | ChainAsset | ChainAssetString;
     /**
      * Asset to be received.
      */
-    toAsset: Asset;
+    toAsset: Asset | ChainAsset | ChainAssetString;
     /**
      * Amount in lowest denomination of the sendAsset.
      */
@@ -33,101 +34,57 @@ export type SwapParams = {
      */
     receiveAmount: string;
     /**
-     * Time lock for the swap.
+     * Slippage for the order.
      */
-    timelock?: number;
+    slippage?: number;
     /**
-     * This will wait for the specified number of confirmations before redeeming the funds.
+     * Addresses for the order.
      */
-    minDestinationConfirmations?: number;
-    /**
-     * Unique nonce for generating secret and secret hashes. If not provided, it will be generated as the total order count until now + 1.
-     */
-    nonce?: number;
-    /**
-     * 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;
-    };
+    addresses?: Partial<Record<BlockchainType, string>>;
     /**
      * Integrator fee for the order.
      */
-    affiliateFee?: AffiliateFeeOptionalChainAsset[];
+    affiliateFee?: AffiliateFee[];
 };
-export type OrderWithStatus = MatchedOrder & {
+export type OrderWithStatus = Order & {
     status: OrderStatus;
 };
 export type GardenEvents = {
-    error: (order: MatchedOrder, error: string) => void;
-    success: (order: MatchedOrder, action: OrderActions, result: string) => void;
+    error: (order: Order, error: string) => void;
+    success: (order: Order, action: OrderAction, result: string) => void;
     onPendingOrdersChanged: (orders: OrderWithStatus[]) => void;
     log: (id: string, message: string) => void;
-    rbf: (order: MatchedOrder, result: string) => void;
+    rbf: (order: Order, result: string) => void;
+};
+export type GardenEventEmitter = {
+    emit: <K extends keyof GardenEvents>(event: K, ...args: Parameters<GardenEvents[K]>) => void;
 };
 export type EventCallback = (...args: any[]) => void;
 /**
  * Interface representing the GardenJS library.
  */
-export interface IGardenJS extends EventBroker<GardenEvents> {
+export interface IGardenJS extends IOrderbook {
     /**
      * Create Order
      * @param {SwapParams} params - The parameters for creating the order.
-     * @returns {AsyncResult<MatchedOrder, string>} The result of the swap operation.
-     */
-    swap(params: SwapParams): AsyncResult<MatchedOrder, string>;
-    /**
-     * Execute an action.
-     * @returns {Promise<() => void>} A promise that resolves to a function to cancel the execution.
-     */
-    execute(): Promise<() => void>;
-    /**
-     * The EVM relay.
-     * @readonly
-     */
-    get evmHTLC(): IEVMHTLC | undefined;
-    /**
-     * The Starknet relay.
-     * @readonly
-     */
-    get starknetHTLC(): IStarknetHTLC | undefined;
-    /**
-     * The Solana relay.
-     * @readonly
+     * @returns {AsyncResult<string, string>} The result of the swap operation.
      */
-    get solanaHTLC(): ISolanaHTLC | undefined;
-    /**
-     * The Sui relay.
-     * @readonly
-     */
-    get suiHTLC(): ISuiHTLC | undefined;
+    createSwap(params: SwapParams): AsyncResult<string, string>;
     /**
      * The current quote.
      * @readonly
      */
     get quote(): IQuote;
     /**
-     * The BTC wallet.
+     * All HTLC modules at once.
      * @readonly
      */
-    get btcWallet(): IBitcoinWallet | undefined;
+    get htlcs(): GardenHTLCModules;
     /**
      * The orderbook.
      * @readonly
      */
     get orderbook(): IOrderbook;
-    /**
-     * The block number fetcher.
-     * @readonly
-     */
-    get blockNumberFetcher(): IBlockNumberFetcher;
     /**
      * The secret manager.
      * @readonly
@@ -142,7 +99,15 @@ export interface IGardenJS extends EventBroker<GardenEvents> {
      * The digest key.
      * @readonly
      */
-    get digestKey(): DigestKey;
+    get digestKey(): DigestKey | undefined;
+    /**
+     * The events.
+     */
+    on<K extends keyof GardenEvents>(event: K, listener: GardenEvents[K]): this;
+    /**
+     * The events.
+     */
+    off<K extends keyof GardenEvents>(event: K, listener: GardenEvents[K]): this;
 }
 export type OrderCacheValue = {
     txHash: string;
@@ -150,51 +115,43 @@ export type OrderCacheValue = {
     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;
+    set(order: Order, action: OrderAction, txHash: string, utxo?: string): void;
+    get(order: Order, action: OrderAction): OrderCacheValue | null;
+    remove(order: Order, action: OrderAction): void;
 }
-export type ApiConfig = Environment | (Partial<Api> & {
-    environment: Environment;
+export type ApiConfig = Network | (Partial<Api> & {
+    network: Network;
 });
 export type GardenCoreConfig = {
     environment: ApiConfig;
-    digestKey: string | DigestKey;
+    apiKey: string | ApiKey;
+    digestKey?: string | DigestKey;
     secretManager?: ISecretManager;
     auth?: IAuth;
     orderbook?: IOrderbook;
     quote?: IQuote;
-    blockNumberFetcher?: IBlockNumberFetcher;
-    btcWallet?: IBitcoinWallet;
     solanaProgramAddress?: {
         native?: string;
         spl?: string;
     };
 };
 export type GardenHTLCModules = {
-    htlc: {
-        evm?: IEVMHTLC;
-        starknet?: IStarknetHTLC;
-        solana?: ISolanaHTLC;
-        sui?: ISuiHTLC;
-    };
+    evm?: IEVMHTLC;
+    starknet?: IStarknetHTLC;
+    solana?: ISolanaHTLC;
+    sui?: ISuiHTLC;
+    bitcoin?: IBitcoinHTLC;
 };
 export type GardenWalletModules = {
-    wallets: {
-        evm?: WalletClient;
-        starknet?: AccountInterface;
-        solana?: AnchorProvider;
-        sui?: WalletWithRequiredFeatures;
-    };
+    evm?: WalletClient;
+    starknet?: AccountInterface;
+    solana?: AnchorProvider;
+    sui?: WalletWithRequiredFeatures | Ed25519Keypair;
+    bitcoin?: IBitcoinWallet;
+};
+export type GardenConfigWithWallets = GardenCoreConfig & {
+    wallets?: GardenWalletModules;
+};
+export type GardenConfigWithHTLCs = GardenCoreConfig & {
+    htlc?: GardenHTLCModules;
 };
-export type GardenConfigWithWallets = GardenCoreConfig & GardenWalletModules;
-export type GardenConfigWithHTLCs = GardenCoreConfig & GardenHTLCModules;
-/**
- * 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/utils.d.ts

@@ -0,0 +1,4 @@
+import { ApiKey, DigestKey } from '@gardenfi/utils';
+
+export declare const resolveDigestKey: (digestKey: string | DigestKey | undefined) => DigestKey | undefined;
+export declare const resolveApiKey: (apiKey: string | ApiKey) => ApiKey;

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

@@ -0,0 +1,25 @@
+import { Order } from '@gardenfi/orderbook';
+
+export declare enum OrderStatus {
+    Created = "Created",
+    InitiateDetected = "Initiate Detected",
+    Initiated = "Initiated",
+    AwaitingRedeem = "Awaiting Redeem",
+    RedeemDetected = "Redeem Detected",
+    Redeemed = "Redeemed",
+    AwaitingRefund = "Awaiting Refund",
+    RefundDetected = "Refund Detected",
+    Refunded = "Refunded",
+    Expired = "Expired"
+}
+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/quote/quote.d.ts

@@ -1,13 +1,14 @@
 import { Err, Ok, Request as UtilsRequest } from '@gardenfi/utils';
 import { IQuote, QuoteParamsForAssets, QuoteResponse, Strategies } from './quote.types';
+import { ChainAsset } from '@gardenfi/orderbook';
 
 export declare class Quote implements IQuote {
     private quoteUrl;
     constructor(quoteUrl: string);
-    getQuoteFromAssets({ fromAsset, toAsset, amount, isExactOut, options, }: QuoteParamsForAssets): Promise<Err<string> | Ok<QuoteResponse>>;
-    getQuote(orderpair: string, amount: number, isExactOut?: boolean, options?: {
+    getQuoteFromAssets({ fromAsset, toAsset, amount, isExactOut, options, }: QuoteParamsForAssets): Promise<Err<string> | Ok<QuoteResponse[]>>;
+    getQuote(from: ChainAsset, to: ChainAsset, amount: number, isExactOut?: boolean, options?: {
         affiliateFee?: number;
         request?: UtilsRequest;
-    }): Promise<Err<string> | Ok<QuoteResponse>>;
+    }): Promise<Err<string> | Ok<QuoteResponse[]>>;
     getStrategies(): Promise<Err<string> | Ok<Strategies>>;
 }

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

@@ -1,4 +1,4 @@
-import { Asset, Chain } from '@gardenfi/orderbook';
+import { Asset, Chain, ChainAsset } from '@gardenfi/orderbook';
 import { APIResponse, AsyncResult, Request } from '@gardenfi/utils';
 
 export interface IQuote {
@@ -12,7 +12,7 @@ export interface IQuote {
      * @param options { affiliateFee?: number; request?: Request } - The options for the quote request, affiliate fee in bps and request object
      *
      */
-    getQuoteFromAssets(params: QuoteParamsForAssets): AsyncResult<QuoteResponse, string>;
+    getQuoteFromAssets(params: QuoteParamsForAssets): AsyncResult<QuoteResponse[], string>;
     /**
      * Get a quote for the given orderpair and amount
      * @param orderpair - A string representing the order pair for which the quote is requested.
@@ -24,7 +24,7 @@ export interface IQuote {
      * @param isExactOut - Whether the amount is exact out
      * @param options { affiliateFee?: number; request?: Request } - The options for the quote request, affiliate fee in bps and request object
      */
-    getQuote(orderpair: string, amount: number, isExactOut: boolean, options?: QuoteOptions): AsyncResult<QuoteResponse, string>;
+    getQuote(from: ChainAsset, to: ChainAsset, amount: number, isExactOut: boolean, options?: QuoteOptions): AsyncResult<QuoteResponse[], string>;
     /**
      * Get the strategies available for quoting
      * @returns {Strategies} The strategies available
@@ -45,14 +45,23 @@ export type QuoteParamsForAssets = BaseQuoteParams & {
     toAsset: Asset;
 };
 export type QuoteParamsForOrderPair = BaseQuoteParams & {
-    orderpair: string;
+    from: ChainAsset;
+    to: ChainAsset;
 };
 export type QuoteResponse = {
-    quotes: {
-        [strategy_id: string]: string;
+    source: {
+        asset: string;
+        amount: string;
+        display: string;
+        value: string;
     };
-    input_token_price: number;
-    output_token_price: number;
+    destination: {
+        asset: string;
+        amount: string;
+        display: string;
+        value: string;
+    };
+    solver_id: string;
 };
 export type Strategies = Record<string, {
     id: string;

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

@@ -0,0 +1,30 @@
+import { ChainAsset } from '@gardenfi/orderbook';
+
+interface RoutePolicy {
+    default: 'open' | 'closed';
+    isolation_groups: string[];
+    blacklist_pairs: string[];
+    whitelist_overrides: string[];
+}
+declare class RouteValidator {
+    private apiBaseUrl;
+    private apiKey;
+    private policy;
+    constructor(apiBaseUrl: string, apiKey: string);
+    loadPolicy(): Promise<void>;
+    isValidRoute(fromAsset: ChainAsset, toAsset: ChainAsset): boolean;
+    getValidDestinations(fromAsset: ChainAsset, allAssets: ChainAsset[]): ChainAsset[];
+    getAllValidRoutes(assets: ChainAsset[]): Array<{
+        from: ChainAsset;
+        to: ChainAsset;
+    }>;
+    private isInIsolationGroup;
+    private isValidIsolationGroup;
+    private isWhitelistOverride;
+    private isBlacklisted;
+    private parseIsolationGroup;
+    private matchesPattern;
+    private matchesAssetPattern;
+}
+declare function buildRouteMatrix(assets: ChainAsset[], validator: RouteValidator): Record<string, ChainAsset[]>;
+export { RouteValidator, buildRouteMatrix, type RoutePolicy };

package/dist/src/lib/solana/htlc/ISolanaHTLC.d.ts

@@ -1,4 +1,4 @@
-import { MatchedOrder } from '@gardenfi/orderbook';
+import { Order, SolanaOrderResponse } from '@gardenfi/orderbook';
 import { AsyncResult } from '@gardenfi/utils';
 
 export interface ISolanaHTLC {
@@ -11,18 +11,18 @@ export interface ISolanaHTLC {
      * @param order - The matched order.
      * @returns A promise resolving to the transaction hash of the initiation.
      */
-    initiate(order: MatchedOrder): AsyncResult<string, string>;
+    initiate(order: Order | SolanaOrderResponse): AsyncResult<string, string>;
     /**
      * Redeems funds from the HTLC contract to the actor's address.
      * @param order - The matched order.
      * @param secret - The secret required to unlock the htlc.
      * @returns A promise resolving to the transaction hash of the redemption.
      */
-    redeem(order: MatchedOrder, secret: string): AsyncResult<string, string>;
+    redeem(order: Order, secret: string): AsyncResult<string, string>;
     /**
      * Refunds funds from the HTLC contract back to the actor's address upon expiration.
      * @param order - The matched order.
      * @returns A promise resolving to the transaction hash of the refund.
      */
-    refund(order: MatchedOrder): AsyncResult<string, string>;
+    refund(order: Order): AsyncResult<string, string>;
 }

package/dist/src/lib/solana/htlc/solanaHTLC.d.ts

@@ -1,6 +1,6 @@
 import { AnchorProvider } from '@coral-xyz/anchor';
 import { ISolanaHTLC } from './ISolanaHTLC';
-import { MatchedOrder } from '@gardenfi/orderbook';
+import { Order } from '@gardenfi/orderbook';
 import { AsyncResult } from '@gardenfi/utils';
 
 /**
@@ -30,27 +30,27 @@ export declare class SolanaHTLC implements ISolanaHTLC {
     get htlcActorAddress(): string;
     /**
      * Initiates a swap by creating a new swap account and locking funds.
-     * @param {MatchedOrder} order - The matched order containing swap details
+     * @param {Order} order - The matched order containing swap details
      * @returns {Promise<AsyncResult<string, string>>} A promise that resolves to either:
      *   - Ok with the transaction ID on success
      *   - Err with an error message on failure
      */
-    initiate(order: MatchedOrder): AsyncResult<string, string>;
+    initiate(order: Order): AsyncResult<string, string>;
     /**
      * Redeems a swap by providing the secret.
-     * @param {MatchedOrder} order - Matched order object containing swap details
+     * @param {Order} order - Matched order object containing swap details
      * @param {string} secret - Secret key in hex format
      * @returns {AsyncResult<string, string>} A promise that resolves to either:
      *   - Ok with the transaction ID on success
      *   - Err with an error message on failure
      */
-    redeem(order: MatchedOrder, secret: string): AsyncResult<string, string>;
+    redeem(order: Order, secret: string): AsyncResult<string, string>;
     /**
      * Refunds the swap back to the initiator.
-     * @param {MatchedOrder} order - Matched order object
+     * @param {Order} order - Matched order object
      * @returns {AsyncResult<string, string>} A promise that resolves to either:
      *   - Ok with the transaction ID on success
      *   - Err with an error message on failure
      */
-    refund(order: MatchedOrder): AsyncResult<string, string>;
+    refund(order: Order): AsyncResult<string, string>;
 }