@gardenfi/core 2.5.3 → 3.0.0

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

@@ -1,4 +1,4 @@
-import { MatchedOrder } from '@gardenfi/orderbook';
+import { EvmOrderResponse, Order } from '@gardenfi/orderbook';
 import { AsyncResult } from '@gardenfi/utils';
 
 export interface IEVMHTLC {
@@ -12,18 +12,18 @@ export interface IEVMHTLC {
      * @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 | EvmOrderResponse): 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/evm/relay/evmRelay.d.ts

@@ -1,18 +1,16 @@
 import { AsyncResult, IAuth, Url } from '@gardenfi/utils';
+import { EvmOrderResponse, Order } from '@gardenfi/orderbook';
 import { WalletClient } from 'viem';
-import { MatchedOrder } from '@gardenfi/orderbook';
-import { IEVMHTLC } from '../htlc.types';
 
-export declare class EvmRelay implements IEVMHTLC {
-    private url;
-    private auth;
+export declare class EvmRelay {
     private wallet;
+    private auth;
+    private url;
+    private relayer;
     constructor(url: string | Url, wallet: WalletClient, auth: IAuth);
-    get htlcActorAddress(): string;
-    initiate(order: MatchedOrder): AsyncResult<string, string>;
-    private getTokenAddress;
-    private _initiateOnNativeHTLC;
-    private _initiateOnErc20HTLC;
-    redeem(order: MatchedOrder, secret: string): AsyncResult<string, string>;
+    get htlcActorAddress(): `0x${string}`;
+    initiate(order: Order | EvmOrderResponse): AsyncResult<string, string>;
+    private initiateFromAPI;
+    redeem(order: Order, secret: string): AsyncResult<string, string>;
     refund(): AsyncResult<string, string>;
 }

package/dist/src/lib/evm/relay/htlcInitiate.d.ts

@@ -0,0 +1,25 @@
+import { AsyncResult, Url, IAuth } from '@gardenfi/utils';
+import { WalletClient } from 'viem';
+
+export declare const initiateNative: (wallet: WalletClient, data: {
+    htlc: string;
+    redeemer: string;
+    timelock: bigint;
+    amount: bigint;
+    secretHash: string;
+}) => AsyncResult<string, string>;
+export declare const initiateERC20: (wallet: WalletClient, url: Url, auth: IAuth, data: {
+    htlc: string;
+    token: string;
+    orderId: string;
+    redeemer: string;
+    timelock: bigint;
+    amount: bigint;
+    secretHash: string;
+}) => AsyncResult<string, string>;
+export declare const executeApprovalTransaction: (wallet: WalletClient, approvalTx: {
+    to: string;
+    value: string;
+    data: string;
+    gas_limit: string;
+}) => AsyncResult<string, string>;

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

@@ -0,0 +1,45 @@
+import { Order, OrderAction } from '@gardenfi/orderbook';
+
+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 stopBackgroundExecution;
+    constructor(digestKey: DigestKey, htlcs: GardenHTLCModules, orderbook: IOrderbook, auth: IAuth, api: Api, events: GardenEventEmitter);
+    private getAddressesFromHTLCs;
+    start(interval: number | undefined, redeemServiceEnabled: boolean): void;
+    stop(): 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,58 @@
 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 { BlockchainType, CreateOrderRequest, CreateOrderResponse, 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;
+    get redeemServiceEnabled(): boolean;
     /**
-     * This method takes in the `SwapParams` and returns a placed order
-     * It internally calls `getAttestedQuote`, `createOrder` and `pollOrder`
-     * @param swapParams
-     * @returns MatchedOrder
+     * Creates an order for a swap operation and initiates the HTLC on the source chain.
+     * @param params SwapParams
+     * @returns AsyncResult<Order, string>
      */
-    swap(params: SwapParams): AsyncResult<MatchedOrder, string>;
-    private withDefaultAffiliateFees;
+    createSwap(params: SwapParams): AsyncResult<CreateOrderResponse | string, string>;
+    createOrder<T extends BlockchainType>(arg: CreateOrderRequest | SwapParams): AsyncResult<CreateOrderResponse<T>, 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;
+    private _getAddresses;
+    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,29 @@
-import { AffiliateFeeOptionalChainAsset, Asset, IOrderbook, MatchedOrder } from '@gardenfi/orderbook';
-import { OrderStatus } from '../orderStatus/status';
-import { AsyncResult, Environment, EventBroker, IAuth, DigestKey } from '@gardenfi/utils';
+import { AffiliateFee, AssetLike, BitcoinOrderResponse, BlockchainType, EvmOrderResponse, IOrderbook, Order, OrderAction, OrderStatus, SolanaOrderResponse, StarknetOrderResponse, SuiOrderResponse, CreateOrderResponse } from '@gardenfi/orderbook';
+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: AssetLike;
     /**
      * Asset to be received.
      */
-    toAsset: Asset;
+    toAsset: AssetLike;
     /**
      * Amount in lowest denomination of the sendAsset.
      */
@@ -33,101 +33,56 @@ export type SwapParams = {
      */
     receiveAmount: string;
     /**
-     * Time lock for the swap.
-     */
-    timelock?: number;
-    /**
-     * This will wait for the specified number of confirmations before redeeming the funds.
+     * Solver ID for the order.
      */
-    minDestinationConfirmations?: number;
+    solverId: string;
     /**
-     * Unique nonce for generating secret and secret hashes. If not provided, it will be generated as the total order count until now + 1.
+     * Slippage for the order.
      */
-    nonce?: number;
+    slippage?: number;
     /**
-     * Additional data for the order.
+     * Addresses 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
+     * @returns {AsyncResult<string, string>} The result of the swap operation.
      */
-    get evmHTLC(): IEVMHTLC | undefined;
-    /**
-     * The Starknet relay.
-     * @readonly
-     */
-    get starknetHTLC(): IStarknetHTLC | undefined;
-    /**
-     * The Solana relay.
-     * @readonly
-     */
-    get solanaHTLC(): ISolanaHTLC | undefined;
-    /**
-     * The Sui relay.
-     * @readonly
-     */
-    get suiHTLC(): ISuiHTLC | undefined;
+    createSwap(params: SwapParams): AsyncResult<CreateOrderResponse | string, string>;
     /**
      * The current quote.
      * @readonly
      */
     get quote(): IQuote;
     /**
-     * The BTC wallet.
+     * All HTLC modules at once.
      * @readonly
      */
-    get btcWallet(): IBitcoinWallet | undefined;
-    /**
-     * The orderbook.
-     * @readonly
-     */
-    get orderbook(): IOrderbook;
-    /**
-     * The block number fetcher.
-     * @readonly
-     */
-    get blockNumberFetcher(): IBlockNumberFetcher;
+    get htlcs(): GardenHTLCModules;
     /**
      * The secret manager.
      * @readonly
@@ -142,7 +97,20 @@ export interface IGardenJS extends EventBroker<GardenEvents> {
      * The digest key.
      * @readonly
      */
-    get digestKey(): DigestKey;
+    get digestKey(): DigestKey | undefined;
+    /**
+     * The redeem service enabled.
+     * @readonly
+     */
+    get redeemServiceEnabled(): boolean;
+    /**
+     * 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 +118,50 @@ 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 ResponseTypeMap = {
+    [BlockchainType.evm]: EvmOrderResponse;
+    [BlockchainType.bitcoin]: BitcoinOrderResponse;
+    [BlockchainType.starknet]: StarknetOrderResponse;
+    [BlockchainType.solana]: SolanaOrderResponse;
+    [BlockchainType.sui]: SuiOrderResponse;
 };
-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/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 { Err, IAuth, Ok, Request as UtilsRequest } from '@gardenfi/utils';
+import { IQuote, QuoteParamsForAssets, QuoteResponse } from './quote.types';
+import { AssetLike } 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?: {
+    private auth;
+    constructor(quoteUrl: string, auth: IAuth);
+    getQuoteFromAssets({ fromAsset, toAsset, amount, isExactOut, options, }: QuoteParamsForAssets): Promise<Err<string> | Ok<QuoteResponse[]>>;
+    getQuote(from: AssetLike, to: AssetLike, amount: number, isExactOut?: boolean, options?: {
         affiliateFee?: number;
         request?: UtilsRequest;
-    }): Promise<Err<string> | Ok<QuoteResponse>>;
-    getStrategies(): Promise<Err<string> | Ok<Strategies>>;
+    }): Promise<Err<string> | Ok<QuoteResponse[]>>;
 }

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

@@ -1,4 +1,4 @@
-import { Asset, Chain } from '@gardenfi/orderbook';
+import { Asset, AssetLike, 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,12 +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>;
-    /**
-     * Get the strategies available for quoting
-     * @returns {Strategies} The strategies available
-     */
-    getStrategies(): AsyncResult<Strategies, string>;
+    getQuote(from: AssetLike, to: AssetLike, amount: number, isExactOut: boolean, options?: QuoteOptions): AsyncResult<QuoteResponse[], string>;
 }
 export type QuoteOptions = {
     affiliateFee?: number;
@@ -45,14 +40,27 @@ 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;
+    estimated_time: number;
+    slippage: number;
+    fee: number;
+    fixed_fee: string;
 };
 export type Strategies = Record<string, {
     id: string;

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

@@ -0,0 +1,9 @@
+import { AsyncResult, IAuth, Url } from '@gardenfi/utils';
+
+export declare class Relayer {
+    private auth;
+    private url;
+    constructor(auth: IAuth, url: string | Url);
+    initiate(orderId: string, signature: string | string[]): AsyncResult<string, string>;
+    redeem(orderId: string, secret: string): AsyncResult<string, string>;
+}

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>;
 }