@gardenfi/core 2.5.2 → 2.5.3-beta.1

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 } 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,52 @@ 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.
+     * Slippage for the order.
      */
-    minDestinationConfirmations?: number;
+    slippage?: number;
     /**
-     * Unique nonce for generating secret and secret hashes. If not provided, it will be generated as the total order count until now + 1.
+     * Addresses for the order.
      */
-    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
-     */
-    get solanaHTLC(): ISolanaHTLC | undefined;
-    /**
-     * The Sui relay.
-     * @readonly
+     * @returns {AsyncResult<string, string>} The result of the swap operation.
      */
-    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;
-    /**
-     * The orderbook.
-     * @readonly
-     */
-    get orderbook(): IOrderbook;
-    /**
-     * The block number fetcher.
-     * @readonly
-     */
-    get blockNumberFetcher(): IBlockNumberFetcher;
+    get htlcs(): GardenHTLCModules;
     /**
      * The secret manager.
      * @readonly
@@ -142,7 +93,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 +114,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 { 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?: {
+    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>>;
+    }): 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, 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,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: AssetLike, to: AssetLike, 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>;
 }

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

@@ -1,7 +1,7 @@
 import { AnchorProvider } from '@coral-xyz/anchor';
-import { AsyncResult, Url } from '@gardenfi/utils';
+import { AsyncResult, IAuth, Url, Network } from '@gardenfi/utils';
 import { ISolanaHTLC } from '../htlc/ISolanaHTLC';
-import { MatchedOrder } from '@gardenfi/orderbook';
+import { Order, SolanaOrderResponse } from '@gardenfi/orderbook';
 
 /**
  * A Relay is an endpoint that submits the transaction on-chain on one's behalf, paying any fees.
@@ -18,18 +18,24 @@ export declare class SolanaRelay implements ISolanaHTLC {
     private splProgram?;
     private nativeProgram?;
     private relayer;
+    private auth;
     /**
      * Creates a new instance of SolanaRelay.
      * @param {AnchorProvider} provider - An abstraction of RPC connection and a Wallet
      * @param {Url} endpoint - API endpoint of the relayer node
-     * @param {string} relayer - On-chain address of the relayer in base58 format
-     * @param {string} splProgramAddress - On-chain address of the SPL token swap program
-     * @param {string} nativeProgramAddress - On-chain address of the native token swap program
+     * @param {Network} network - Chain network for selecting default relayer and program addresses
+     * @param {IAuth} auth - Auth provider for relayer endpoints
+     * @param {object} [overrides] - Optional overrides for relayer/program addresses
+     * @param {string} [overrides.relayer] - Custom relayer address (base58)
+     * @param {{native?: string; spl?: string}} [overrides.programAddress] - Custom program addresses
      * @throws {Error} If any required parameters are missing or invalid
      */
-    constructor(provider: AnchorProvider, url: Url, relayer: string, programAddress: {
-        native?: string;
-        spl?: string;
+    constructor(provider: AnchorProvider, url: Url, network: Network, auth: IAuth, overrides?: {
+        relayer?: string;
+        programAddress?: {
+            native?: string;
+            spl?: string;
+        };
     });
     /**
      * Gets the on-chain address of the current user's wallet.
@@ -38,12 +44,14 @@ export declare class SolanaRelay implements ISolanaHTLC {
      */
     get htlcActorAddress(): string;
     /**
-     * Determines if the given order is for a native Solana token (SOL).
-     * @param {MatchedOrder} order - The matched order to check
-     * @returns {boolean} True if it's a native token, false if it's an SPL token
-     * @private
+     * Initiates a swap by creating a new swap account and locking funds.
+     * Automatically detects whether to use SPL or native token handling.
+     * @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
      */
-    private isNativeToken;
+    initiate(order: Order | SolanaOrderResponse): AsyncResult<string, string>;
     /**
      * Sends a transaction via the relayer for SPL tokens.
      * @param {web3.Transaction} transaction - The transaction to send
@@ -57,24 +65,16 @@ export declare class SolanaRelay implements ISolanaHTLC {
     /**
      * Initiates a swap directly via HTLC (without relayer).
      * @param {web3.Transaction} transaction - The transaction to send
-     * @param {MatchedOrder} order - The matched order
+     * @param {Order} order - The matched order
      * @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
      * @private
      */
     private initiateViaHTLC;
-    /**
-     * Creates a PDA (Program Derived Address) for the swap account.
-     * @param {Buffer} secretHash - The secret hash buffer
-     * @param {web3.PublicKey} programId - The program ID to use for PDA derivation
-     * @returns {web3.PublicKey} The derived PDA
-     * @private
-     */
-    private createSwapPDA;
     /**
      * Initiates a swap for SPL tokens.
-     * @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
@@ -83,31 +83,23 @@ export declare class SolanaRelay implements ISolanaHTLC {
     private initiateSplSwap;
     /**
      * Initiates a swap for native tokens (SOL).
-     * @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
      * @private
      */
     private initiateNativeSwap;
-    /**
-     * Initiates a swap by creating a new swap account and locking funds.
-     * Automatically detects whether to use SPL or native token handling.
-     * @param {MatchedOrder} 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>;
+    private initiateWithCreateOrderResponse;
     /**
      * 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 {Promise<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>;
     /**
      * DO NOT CALL THIS FUNCTION. Refund is automatically taken care of by the relayer!
      * This method exists only to satisfy the ISolanaHTLC interface but is not intended for direct use.

package/dist/src/lib/solana/solanaTypes.d.ts

@@ -1,5 +1,5 @@
 import { web3, BN } from '@coral-xyz/anchor';
-import { MatchedOrder } from '@gardenfi/orderbook';
+import { Order } from '@gardenfi/orderbook';
 
 /**
  * A Swap configuration in Solana
@@ -20,9 +20,9 @@ export declare class SwapConfig {
     constructor(swapId: string, redeemer: string, secretHash: string, amount: bigint, expiresIn: number);
     /**
      * Constructs a SwapConfig from a matched order object with Solana as a source swap
-     * @param order - The MatchedOrder with a Solana as source swap
+     * @param order - The Order with a Solana as source swap
      */
-    static from(order: MatchedOrder): SwapConfig;
+    static from(order: Order): SwapConfig;
 }
 /**
  * Checks whether given secret is a valid 32 byte hex string.

package/dist/src/lib/starknet/htlc/starknetHTLC.d.ts

@@ -1,4 +1,4 @@
-import { MatchedOrder } from '@gardenfi/orderbook';
+import { Order } from '@gardenfi/orderbook';
 import { Account, CallData } from 'starknet';
 import { AsyncResult, Network } from '@gardenfi/utils';
 import { IStarknetHTLC } from '../starknetHTLC.types';
@@ -14,7 +14,7 @@ export declare class StarknetHTLC implements IStarknetHTLC {
      * @param order Order to initiate HTLC for
      * @returns Transaction ID
      */
-    initiate(order: MatchedOrder): AsyncResult<string, string>;
+    initiate(order: Order): AsyncResult<string, string>;
     callData: CallData;
     /**
      * Redeems the HTLC
@@ -23,12 +23,12 @@ export declare class StarknetHTLC implements IStarknetHTLC {
      * @param secret Secret to redeem HTLC with
      * @returns Transaction ID
      */
-    redeem(order: MatchedOrder, secret: string): AsyncResult<string, string>;
+    redeem(order: Order, secret: string): AsyncResult<string, string>;
     /**
      * Refunds the HTLC
      *
      * @param order Order to refund HTLC for
      * @returns Refund transaction ID
      */
-    refund(order: MatchedOrder): AsyncResult<string, string>;
+    refund(order: Order): AsyncResult<string, string>;
 }

package/dist/src/lib/starknet/relay/starknetRelay.d.ts

@@ -1,6 +1,6 @@
 import { AccountInterface } from 'starknet';
-import { MatchedOrder } from '@gardenfi/orderbook';
-import { AsyncResult, Network, Url } from '@gardenfi/utils';
+import { Order, StarknetOrderResponse } from '@gardenfi/orderbook';
+import { AsyncResult, IAuth, Network, Url } from '@gardenfi/utils';
 import { IStarknetHTLC } from '../starknetHTLC.types';
 
 export declare class StarknetRelay implements IStarknetHTLC {
@@ -8,11 +8,14 @@ export declare class StarknetRelay implements IStarknetHTLC {
     private account;
     private starknetProvider;
     private chainId;
-    constructor(relayerUrl: string | Url, account: AccountInterface, network: Network, nodeUrl?: string);
+    private auth;
+    constructor(relayerUrl: string | Url, account: AccountInterface, network: Network, auth: IAuth, nodeUrl?: string);
     get htlcActorAddress(): string;
-    initiate(order: MatchedOrder): AsyncResult<string, string>;
+    initiate(order: Order | StarknetOrderResponse): AsyncResult<string, string>;
     private approveAndInitiate;
     private initiateRelay;
-    redeem(order: MatchedOrder, secret: string): AsyncResult<string, string>;
+    redeem(order: Order, secret: string): AsyncResult<string, string>;
+    executeApprovalTransaction(order: StarknetOrderResponse): AsyncResult<string, string>;
+    initiateWithCreateOrderResponse(order: StarknetOrderResponse): AsyncResult<string, string>;
     refund(): AsyncResult<string, string>;
 }