@gardenfi/core 2.5.3 → 3.0.0

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,25 @@ export declare class SolanaRelay implements ISolanaHTLC {
     private splProgram?;
     private nativeProgram?;
     private relayer;
+    private auth;
+    private relayerClient;
     /**
      * 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 +45,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 +66,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 +84,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 { web3 } from '@coral-xyz/anchor';
+import { Order } from '@gardenfi/orderbook';
 
 /**
  * A Swap configuration in Solana
@@ -8,8 +8,8 @@ export declare class SwapConfig {
     swapId: number[];
     redeemer: web3.PublicKey;
     secretHash: number[];
-    amount: BN;
-    expiresIn: BN;
+    amount: BigNumber;
+    expiresIn: BigNumber;
     /**
      * @param swapId - A Unique 32-bit ID to represent this configuration in hex
      * @param redeemer - The Solana address of redeemer in base58
@@ -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,15 @@ export declare class StarknetRelay implements IStarknetHTLC {
     private account;
     private starknetProvider;
     private chainId;
-    constructor(relayerUrl: string | Url, account: AccountInterface, network: Network, nodeUrl?: string);
+    private auth;
+    private relayer;
+    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>;
 }

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

@@ -1,4 +1,4 @@
-import { MatchedOrder } from '@gardenfi/orderbook';
+import { Order, StarknetOrderResponse } from '@gardenfi/orderbook';
 import { AsyncResult } from '@gardenfi/utils';
 
 export interface IStarknetHTLC {
@@ -11,18 +11,18 @@ export interface IStarknetHTLC {
      * @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 | StarknetOrderResponse): 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/sui/htlc/suiHTLC.d.ts

@@ -1,5 +1,5 @@
-import { MatchedOrder } from '@gardenfi/orderbook';
-import { AsyncResult, Network } from '@gardenfi/utils';
+import { Order } from '@gardenfi/orderbook';
+import { AsyncResult, Url, Network } from '@gardenfi/utils';
 import { ISuiHTLC } from '../suiHTLC.types';
 import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
 import { WalletWithRequiredFeatures } from '@mysten/wallet-standard';
@@ -8,14 +8,15 @@ export declare class SuiHTLC implements ISuiHTLC {
     private client;
     private account;
     private network;
-    constructor(account: WalletWithRequiredFeatures | Ed25519Keypair, network: Network);
+    private url;
+    constructor(account: WalletWithRequiredFeatures | Ed25519Keypair, network: Network, url: Url);
     get htlcActorAddress(): string;
     /**
      * Initiates the HTLC
      * @param order Order to initiate HTLC for
      * @returns Transaction ID
      */
-    initiate(order: MatchedOrder): AsyncResult<string, string>;
+    initiate(order: Order): AsyncResult<string, string>;
     /**
      * Redeems the HTLC
      *
@@ -23,12 +24,12 @@ export declare class SuiHTLC implements ISuiHTLC {
      * @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/sui/relay/suiRelay.d.ts

@@ -1,5 +1,5 @@
-import { MatchedOrder } from '@gardenfi/orderbook';
-import { AsyncResult, Network, Url } from '@gardenfi/utils';
+import { Order, SuiOrderResponse } from '@gardenfi/orderbook';
+import { AsyncResult, IAuth, Network, Url } from '@gardenfi/utils';
 import { ISuiHTLC } from '../suiHTLC.types';
 import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
 import { WalletWithRequiredFeatures } from '@mysten/wallet-standard';
@@ -9,9 +9,12 @@ export declare class SuiRelay implements ISuiHTLC {
     private url;
     private account;
     private network;
-    constructor(relayerUrl: string | Url, account: WalletWithRequiredFeatures | Ed25519Keypair, network: Network);
+    private auth;
+    private relayer;
+    constructor(relayerUrl: string | Url, account: WalletWithRequiredFeatures | Ed25519Keypair, network: Network, auth: IAuth);
     get htlcActorAddress(): string;
-    initiate(order: MatchedOrder): AsyncResult<string, string>;
-    redeem(order: MatchedOrder, secret: string): AsyncResult<string, string>;
+    initiate(order: Order | SuiOrderResponse): AsyncResult<string, string>;
+    private initiateWithCreateOrderResponse;
+    redeem(order: Order, secret: string): AsyncResult<string, string>;
     refund(): AsyncResult<string, string>;
 }

package/dist/src/lib/sui/suiHTLC.types.d.ts

@@ -1,4 +1,4 @@
-import { MatchedOrder } from '@gardenfi/orderbook';
+import { Order, SuiOrderResponse } from '@gardenfi/orderbook';
 import { AsyncResult } from '@gardenfi/utils';
 
 export interface ISuiHTLC {
@@ -11,18 +11,18 @@ export interface ISuiHTLC {
      * @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 | SuiOrderResponse): 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/switchOrAddNetwork.d.ts

@@ -1,19 +1,21 @@
 import { Chain as viemChain } from 'viem/chains';
-import { EvmChain } from '@gardenfi/orderbook';
+import { EVMChains } from '@gardenfi/orderbook';
 import { WalletClient } from 'viem';
 import { AsyncResult } from '@gardenfi/utils';
 
 export declare const botanixMainnet: viemChain;
 export declare const hyperliquidTestnet: viemChain;
 export declare const hyperliquid: viemChain;
-export declare const evmToViemChainMap: Record<EvmChain, viemChain>;
+export declare const alpenTestnet: viemChain;
+export declare const evmToViemChainMap: Record<EVMChains, viemChain>;
+export declare const getChainNameFromChainId: (chainId: number) => EVMChains | null;
 /**
  * Switches or adds a network to the wallet
  * @param chain Garden supported chain
  * @param walletClient
  * @returns new walletClient with updated chain
  */
-export declare const switchOrAddNetwork: (chain: EvmChain, walletClient: WalletClient) => AsyncResult<{
+export declare const switchOrAddNetwork: (chain: EVMChains, walletClient: WalletClient) => AsyncResult<{
     message: string;
     walletClient: WalletClient;
 }, string>;

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

@@ -1,18 +1,26 @@
-import { Environment, Err, Ok } from '@gardenfi/utils';
-import { Chain } from '@gardenfi/orderbook';
+import { AsyncResult, Environment, Err, Ok, Url, Network } from '@gardenfi/utils';
+import { AffiliateFee, BlockchainType, Chain } from '@gardenfi/orderbook';
+import { WalletClient } from 'viem';
 import { Signature } from 'starknet';
 import { Api } from './constants';
-import { ApiConfig } from './garden/garden.types';
+import { ApiConfig, GardenHTLCModules } from './garden/garden.types';
 import { BitcoinNetwork } from './bitcoin/provider/provider.interface';
 import { IBaseWallet } from './bitcoin/wallet/baseWallet';
 import { web3 } from '@coral-xyz/anchor';
 
+import * as bitcoin from 'bitcoinjs-lib';
+type ExecuteWithRelayerRetriesArgs = {
+    attempt: () => AsyncResult<string, string>;
+    wallet: WalletClient;
+    maxAttempts?: number;
+    baseDelayMs?: number;
+};
 export declare function resolveApiConfig(env: ApiConfig): {
     api: Api;
-    environment: Environment;
+    network: Network;
 };
 export declare const computeSecret: (fromChain: Chain, toChain: Chain, wallets: Partial<Record<Chain, IBaseWallet>>, nonce: number) => Promise<string>;
-export declare const isFromChainBitcoin: (chain: Chain) => chain is "bitcoin" | "bitcoin_testnet" | "bitcoin_regtest";
+export declare const isFromChainBitcoin: (chain: Chain) => chain is "bitcoin_regtest" | "bitcoin_testnet" | "bitcoin";
 /**
  * Given a hex string or a buffer, return the x-only pubkey. (removes y coordinate the prefix)
  */
@@ -31,7 +39,9 @@ export declare const toXOnly: (pubKey: string) => string;
 export declare const isValidBitcoinPubKey: (pubKey: string) => boolean;
 export declare const constructOrderPair: (sourceChain: Chain, sourceAsset: string, destChain: Chain, destAsset: string) => string;
 export declare function validateBTCAddress(address: string, networkType: Environment): boolean;
-export declare const getBitcoinNetwork: (network: Environment) => BitcoinNetwork;
+export declare function generateOutputs(output: Buffer, count: number): Buffer[];
+export declare const getBitcoinNetworkFromEnvironment: (network: Network) => BitcoinNetwork;
+export declare const getBitcoinNetworkFromNetwork: (network: Network) => bitcoin.networks.Network;
 export declare const isHexString: (value: string) => boolean;
 export declare const formatStarknetSignature: (sig: Signature) => Err<string> | Ok<string[]>;
 export declare function reversify(val: string): Buffer;
@@ -39,3 +49,25 @@ export declare function isErrorWithMessage(err: unknown): err is {
     message: string;
 };
 export declare const waitForSolanaTxConfirmation: (connection: web3.Connection, txHash: string) => Promise<boolean>;
+export declare const getAssetInfoFromOrder: (order: string, url: Url) => Promise<AsyncResult<{
+    htlcAddress: string;
+    tokenAddress: string;
+}, string>>;
+export declare const validateAmount: (amount: string) => Err<string> | Ok<BigNumber>;
+export declare const withDefaultAffiliateFees: (list: AffiliateFee[] | undefined) => AffiliateFee[];
+/**
+ *
+ * @param blockchainType
+ * @param htlcs
+ * @returns
+ */
+export declare const getAddresses: (blockchainType: BlockchainType, htlcs: GardenHTLCModules) => Promise<Err<string> | Ok<string>>;
+/**
+ * Validates that HTLCs are available for the required blockchain types for swap initiation
+ * @param blockchainType The blockchain type to check
+ * @returns AsyncResult<void, string>
+ */
+export declare const validateHTLCForSwap: (blockchainType: BlockchainType, htlcs: GardenHTLCModules) => Promise<AsyncResult<void, string>>;
+export declare const isAlreadyInitiatedError: (error: unknown) => boolean;
+export declare const executeWithRelayerRetries: ({ attempt, wallet, maxAttempts, baseDelayMs, }: ExecuteWithRelayerRetriesArgs) => Promise<string | null>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gardenfi/core",
-  "version": "2.5.3",
+  "version": "3.0.0",
   "type": "module",
   "scripts": {
     "build": "vite build",
@@ -28,8 +28,8 @@
   },
   "dependencies": {
     "@coral-xyz/anchor": "^0.31.1",
-    "@gardenfi/orderbook": "2.5.3",
-    "@gardenfi/utils": "2.5.3",
+    "@gardenfi/orderbook": "3.0.0",
+    "@gardenfi/utils": "3.0.0",
     "@mysten/signers": "^0.3.4",
     "@mysten/sui": "^1.37.1",
     "@mysten/wallet-standard": "^0.16.9",
@@ -39,6 +39,7 @@
     "bip39": "^3.1.0",
     "bitcoinjs-lib": "^6.1.5",
     "ecpair": "^2.1.0",
+    "node-cache": "^5.1.2",
     "starknet": "7.6.4",
     "tiny-secp256k1": "^2.2.3",
     "varuint-bitcoin": "^1.1.2",