@atomiqlabs/sdk 8.4.4 → 8.5.0

package/src/swaps/ISwapWrapper.ts

@@ -10,6 +10,8 @@ import {UnifiedSwapStorage} from "../storage/UnifiedSwapStorage";
 import {SCToken} from "../types/Token";
 import {getLogger} from "../utils/Logger";
 import {PriceInfoType} from "../types/PriceInfoType";
+import {fromHumanReadableString} from "../utils/TokenUtils";
+import {UserError} from "../errors/UserError";
 
 /**
  * Options for swap wrapper configuration
@@ -26,15 +28,9 @@ export type ISwapWrapperOptions = {
  *
  * @category Swaps/Base
  */
-export type WrapperCtorTokens<T extends MultiChain = MultiChain> = {
-    ticker: string,
-    name: string,
-    chains: {[chainId in ChainIds<T>]?: {
-        address: string,
-        decimals: number,
-        displayDecimals?: number
-    }}
-}[];
+export type WrapperCtorTokens<T extends ChainType = ChainType> = {
+    [tokenAddress: string]: SCToken<T["ChainId"]>
+};
 
 /**
  * Type definition linking wrapper and swap types
@@ -164,22 +160,27 @@ export abstract class ISwapWrapper<
         this._prices = prices;
         this.events = events || new EventEmitter();
         this._options = options;
-        this._tokens = {};
-        for(let tokenData of tokens) {
-            const chainData = tokenData.chains[chainIdentifier];
-            if(chainData==null) continue;
-            this._tokens[chainData.address] = {
-                chain: "SC",
-                chainId: this.chainIdentifier,
-                address: chainData.address,
-                decimals: chainData.decimals,
-                ticker: tokenData.ticker,
-                name: tokenData.name,
-                displayDecimals: chainData.displayDecimals
-            };
-        }
+        this._tokens = tokens;
     }
 
+    /**
+     * Parses the provided gas amount from its `string` or `bigint` representation to `bigint` base units.
+     *
+     * Defaults to `0n` if no gasAmount is provided
+     *
+     * @param gasAmount
+     * @internal
+     */
+    protected parseGasAmount(gasAmount?: string | bigint): bigint {
+        let result: bigint | undefined | null;
+        if(typeof(gasAmount)==="string") {
+            result = fromHumanReadableString(gasAmount, this._getNativeToken());
+            if(result==null) throw new UserError("Invalid `gasAmount` option provided, not a numerical string!");
+        } else {
+            result = gasAmount;
+        }
+        return result ?? 0n;
+    }
 
     /**
      * Pre-fetches swap price for a given swap

package/src/swaps/escrow_swaps/IEscrowSelfInitSwap.ts

@@ -112,7 +112,7 @@ export abstract class IEscrowSelfInitSwap<
     /**
      * Returns the transaction fee paid on the smart chain side to initiate the escrow
      */
-    async getSmartChainNetworkFee(): Promise<TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true>> {
+    async getSmartChainNetworkFee(): Promise<TokenAmount<SCToken<T["ChainId"]>, true>> {
         const swapContract: T["Contract"] = this.wrapper._contract;
         return toTokenAmount(
             await (
@@ -131,8 +131,8 @@ export abstract class IEscrowSelfInitSwap<
      */
     abstract hasEnoughForTxFees(): Promise<{
         enoughBalance: boolean,
-        balance: TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true>,
-        required: TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true>
+        balance: TokenAmount<SCToken<T["ChainId"]>, true>,
+        required: TokenAmount<SCToken<T["ChainId"]>, true>
     }>;
 
 

package/src/swaps/escrow_swaps/frombtc/IFromBTCSelfInitSwap.ts

@@ -169,19 +169,19 @@ export abstract class IFromBTCSelfInitSwap<
     /**
      * @inheritDoc
      */
-    getOutput(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true> {
+    getOutput(): TokenAmount<SCToken<T["ChainId"]>, true> {
         return toTokenAmount(this.getSwapData().getAmount(), this.wrapper._tokens[this.getSwapData().getToken()], this.wrapper._prices, this.pricingInfo);
     }
 
     /**
      * @inheritDoc
      */
-    abstract getInput(): TokenAmount<T["ChainId"], BtcToken>;
+    abstract getInput(): TokenAmount<BtcToken>;
 
     /**
      * @inheritDoc
      */
-    getInputWithoutFee(): TokenAmount<T["ChainId"], BtcToken> {
+    getInputWithoutFee(): TokenAmount<BtcToken> {
         const input = this.getInput();
         if(input.rawAmount==null) return toTokenAmount(null, this.inputToken, this.wrapper._prices, this.pricingInfo);
         return toTokenAmount(input.rawAmount - this.swapFeeBtc, this.inputToken, this.wrapper._prices, this.pricingInfo);
@@ -192,8 +192,8 @@ export abstract class IFromBTCSelfInitSwap<
      */
     async hasEnoughForTxFees(): Promise<{
         enoughBalance: boolean,
-        balance: TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true>,
-        required: TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true>
+        balance: TokenAmount<SCToken<T["ChainId"]>, true>,
+        required: TokenAmount<SCToken<T["ChainId"]>, true>
     }> {
         const [balance, commitFee] = await Promise.all([
             this.wrapper._contract.getBalance(this._getInitiator(), this.wrapper._chain.getNativeCurrencyAddress(), false),
@@ -212,7 +212,7 @@ export abstract class IFromBTCSelfInitSwap<
      *  to act as a security deposit that can be taken by the intermediary (LP) if the user doesn't go through
      *  with the swap
      */
-    getSecurityDeposit(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true> {
+    getSecurityDeposit(): TokenAmount<SCToken<T["ChainId"]>, true> {
         return toTokenAmount(this.getSwapData().getSecurityDeposit(), this.wrapper._getNativeToken(), this.wrapper._prices, this.pricingInfo);
     }
 
@@ -221,7 +221,7 @@ export abstract class IFromBTCSelfInitSwap<
      *  This covers the security deposit and the watchtower fee (if applicable), it is calculated a maximum of those
      *  two values.
      */
-    getTotalDeposit(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true> {
+    getTotalDeposit(): TokenAmount<SCToken<T["ChainId"]>, true> {
         return toTokenAmount(this.getSwapData().getTotalDeposit(), this.wrapper._getNativeToken(), this.wrapper._prices, this.pricingInfo);
     }
 
@@ -273,7 +273,7 @@ export abstract class IFromBTCSelfInitSwap<
      * Returns the transaction fee required for the claim transaction to settle the escrow on the destination
      *  smart chain
      */
-    async getClaimNetworkFee(): Promise<TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true>> {
+    async getClaimNetworkFee(): Promise<TokenAmount<SCToken<T["ChainId"]>, true>> {
         const swapContract: T["Contract"] = this.wrapper._contract;
         return toTokenAmount(
             await swapContract.getClaimFee(this._getInitiator(), this.getSwapData()),

package/src/swaps/escrow_swaps/frombtc/ln/FromBTCLNSwap.ts

@@ -448,7 +448,7 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
     /**
      * @inheritDoc
      */
-    getInput(): TokenAmount<T["ChainId"], BtcToken<true>> {
+    getInput(): TokenAmount<BtcToken<true>> {
         if(this.pr==null || !this.pr.toLowerCase().startsWith("ln"))
             return toTokenAmount(null, this.inputToken, this.wrapper._prices, this.pricingInfo);
 
@@ -461,7 +461,7 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
     /**
      * @inheritDoc
      */
-    getSmartChainNetworkFee(): Promise<TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true>> {
+    getSmartChainNetworkFee(): Promise<TokenAmount<SCToken<T["ChainId"]>, true>> {
         return this.getCommitAndClaimNetworkFee();
     }
 
@@ -470,8 +470,8 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
      */
     async hasEnoughForTxFees(): Promise<{
         enoughBalance: boolean,
-        balance: TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true>,
-        required: TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true>
+        balance: TokenAmount<SCToken<T["ChainId"]>, true>,
+        required: TokenAmount<SCToken<T["ChainId"]>, true>
     }> {
         const [balance, feeRate] = await Promise.all([
             this.wrapper._contract.getBalance(this._getInitiator(), this.wrapper._chain.getNativeCurrencyAddress(), false),
@@ -1082,7 +1082,7 @@ export class FromBTCLNSwap<T extends ChainType = ChainType>
      * Estimated transaction fee for commit & claim transactions combined, required
      *  to settle the swap on the smart chain destination side.
      */
-    async getCommitAndClaimNetworkFee(): Promise<TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true>> {
+    async getCommitAndClaimNetworkFee(): Promise<TokenAmount<SCToken<T["ChainId"]>, true>> {
         const swapContract: T["Contract"] = this.wrapper._contract;
         const feeRate = this.feeRate ?? await swapContract.getInitFeeRate(
             this.getSwapData().getOfferer(),

package/src/swaps/escrow_swaps/frombtc/ln/FromBTCLNWrapper.ts

@@ -13,7 +13,7 @@ import {UserError} from "../../../../errors/UserError";
 import {IntermediaryError} from "../../../../errors/IntermediaryError";
 import {SwapType} from "../../../../enums/SwapType";
 import {
-    extendAbortController,
+    extendAbortController, parseHashValueExact32Bytes,
     throwIfUndefined
 } from "../../../../utils/Utils";
 import {FromBTCLNResponseType, IntermediaryAPI} from "../../../../intermediaries/apis/IntermediaryAPI";
@@ -33,9 +33,30 @@ import {AllOptional} from "../../../../utils/TypeUtils";
 import {sha256} from "@noble/hashes/sha2";
 
 export type FromBTCLNOptions = {
-    paymentHash?: Buffer,
+    /**
+     * Instead of letting the SDK generate the preimage/paymentHash pair internally you can pass your computed
+     *  paymentHash here, this will create the swap with the provided payment hash. Note that you would then
+     *  have to reveal the preimage by passing it to the {@link FromBTCLNSwap.claim} or {@link FromBTCLNSwap.txsClaim}
+     *  functions
+     *
+     * Accepts both, a {@link Buffer} and a hexadecimal `string`
+     */
+    paymentHash?: Buffer | string,
+    /**
+     * Optional description to use for the swap lightning network invoice, keep the invoice length below 500 characters
+     */
     description?: string,
-    descriptionHash?: Buffer,
+    /**
+     * Optional description hash to use for the lightning network invoice, useful when returning the invoice as part of
+     *  an LNURL-pay service endpoint.
+     *
+     * Accepts both, a {@link Buffer} and a hexadecimal `string`
+     */
+    descriptionHash?: Buffer | string,
+    /**
+     * A flag to skip checking whether the lightning network node of the LP has enough channel liquidity to facilitate
+     *  the swap.
+     */
     unsafeSkipLnNodeCheck?: boolean
 };
 
@@ -179,7 +200,10 @@ export class FromBTCLNWrapper<
         resp: FromBTCLNResponseType,
         amountData: AmountData,
         lp: Intermediary,
-        options: FromBTCLNOptions,
+        options: {
+            descriptionHash?: Buffer,
+            description?: string
+        },
         decodedPr: PaymentRequestObject & {tagsObject: TagsObject},
         paymentHash: Buffer
     ): void {
@@ -238,22 +262,20 @@ export class FromBTCLNWrapper<
     }[] {
         if(!this.isInitialized) throw new Error("Not initialized, call init() first!");
 
-        if(options==null) options = {};
-        options.unsafeSkipLnNodeCheck ??= this._options.unsafeSkipLnNodeCheck;
-
-        if(options.paymentHash!=null && options.paymentHash.length!==32)
-            throw new UserError("Invalid payment hash length, must be exactly 32 bytes!");
-
-        if(options.descriptionHash!=null && options.descriptionHash.length!==32)
-            throw new UserError("Invalid description hash length");
+        const _options = {
+            paymentHash: parseHashValueExact32Bytes(options?.paymentHash, "payment hash"),
+            description: options?.description,
+            descriptionHash: parseHashValueExact32Bytes(options?.descriptionHash, "description hash"),
+            unsafeSkipLnNodeCheck: options?.unsafeSkipLnNodeCheck ?? this._options.unsafeSkipLnNodeCheck
+        };
 
-        if(options.description!=null && Buffer.byteLength(options.description, "utf8") > 500)
+        if(_options.description!=null && Buffer.byteLength(_options.description, "utf8") > 500)
             throw new UserError("Invalid description length");
 
         let secret: Buffer | undefined;
         let paymentHash: Buffer;
-        if(options?.paymentHash!=null) {
-            paymentHash = options.paymentHash;
+        if(_options.paymentHash!=null) {
+            paymentHash = _options.paymentHash;
         } else {
             ({secret, paymentHash} = this.getSecretAndHash());
         }
@@ -286,8 +308,8 @@ export class FromBTCLNWrapper<
                                 amount: amountData.amount,
                                 claimer: recipient,
                                 token: amountData.token.toString(),
-                                description: options?.description,
-                                descriptionHash: options?.descriptionHash,
+                                description: _options.description,
+                                descriptionHash: _options.descriptionHash,
                                 exactOut: !amountData.exactIn,
                                 feeRate: throwIfUndefined(_preFetches.feeRatePromise),
                                 additionalParams
@@ -296,7 +318,7 @@ export class FromBTCLNWrapper<
                         );
 
                         return {
-                            lnCapacityPromise: options?.unsafeSkipLnNodeCheck ? null : this.preFetchLnCapacity(lnPublicKey),
+                            lnCapacityPromise: _options.unsafeSkipLnNodeCheck ? null : this.preFetchLnCapacity(lnPublicKey),
                             resp: await response
                         };
                     }, undefined, RequestError, abortController.signal);
@@ -307,7 +329,7 @@ export class FromBTCLNWrapper<
                     const amountIn = (BigInt(decodedPr.millisatoshis) + 999n) / 1000n;
 
                     try {
-                        this.verifyReturnedData(resp, amountData, lp, options ?? {}, decodedPr, paymentHash);
+                        this.verifyReturnedData(resp, amountData, lp, _options, decodedPr, paymentHash);
                         const [pricingInfo] = await Promise.all([
                             this.verifyReturnedPrice(
                                 lp.services[SwapType.FROM_BTCLN], false, amountIn, resp.total,
@@ -374,8 +396,12 @@ export class FromBTCLNWrapper<
     }[]> {
         if(!this.isInitialized) throw new Error("Not initialized, call init() first!");
 
-        if(options?.paymentHash!=null && options.paymentHash.length!==32)
-            throw new UserError("Invalid payment hash length, must be exactly 32 bytes!");
+        const _options = {
+            paymentHash: parseHashValueExact32Bytes(options?.paymentHash, "payment hash"),
+            description: options?.description,
+            descriptionHash: parseHashValueExact32Bytes(options?.descriptionHash, "description hash"),
+            unsafeSkipLnNodeCheck: options?.unsafeSkipLnNodeCheck ?? this._options.unsafeSkipLnNodeCheck
+        };
 
         const abortController = extendAbortController(abortSignal);
         const preFetches = {
@@ -408,7 +434,7 @@ export class FromBTCLNWrapper<
                 if((amount * 105n / 100n) > max) throw new UserError("Amount more than LNURL-withdraw maximum");
             }
 
-            return this.create(recipient, amountData, lps, options, additionalParams, abortSignal, preFetches).map(data => {
+            return this.create(recipient, amountData, lps, _options, additionalParams, abortSignal, preFetches).map(data => {
                 return {
                     quote: data.quote.then(quote => {
                         quote._setLNURLData(

package/src/swaps/escrow_swaps/frombtc/ln_auto/FromBTCLNAutoSwap.ts

@@ -589,14 +589,14 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
     /**
      * @inheritDoc
      */
-    getInput(): TokenAmount<T["ChainId"], BtcToken<true>> {
+    getInput(): TokenAmount<BtcToken<true>> {
         return toTokenAmount(this.getLightningInvoiceSats(), this.inputToken, this.wrapper._prices, this.pricingInfo);
     }
 
     /**
      * @inheritDoc
      */
-    getInputWithoutFee(): TokenAmount<T["ChainId"], BtcToken<true>> {
+    getInputWithoutFee(): TokenAmount<BtcToken<true>> {
         return toTokenAmount(this.getInputAmountWithoutFee(), this.inputToken, this.wrapper._prices, this.pricingInfo);
     }
 
@@ -610,14 +610,14 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
     /**
      * @inheritDoc
      */
-    getOutput(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true> {
+    getOutput(): TokenAmount<SCToken<T["ChainId"]>, true> {
         return toTokenAmount(this.getSwapData().getAmount(), this.wrapper._tokens[this.getSwapData().getToken()], this.wrapper._prices, this.pricingInfo);
     }
 
     /**
      * @inheritDoc
      */
-    getGasDropOutput(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true> {
+    getGasDropOutput(): TokenAmount<SCToken<T["ChainId"]>, true> {
         return toTokenAmount(
             this.getSwapData().getSecurityDeposit() - this.getSwapData().getClaimerBounty(),
             this.wrapper._tokens[this.getSwapData().getDepositToken()], this.wrapper._prices, this.gasPricingInfo

package/src/swaps/escrow_swaps/frombtc/ln_auto/FromBTCLNAutoWrapper.ts

@@ -12,7 +12,7 @@ import {UserError} from "../../../../errors/UserError";
 import {IntermediaryError} from "../../../../errors/IntermediaryError";
 import {SwapType} from "../../../../enums/SwapType";
 import {
-    extendAbortController,
+    extendAbortController, parseHashValueExact32Bytes,
     randomBytes,
     throwIfUndefined
 } from "../../../../utils/Utils";
@@ -35,14 +35,56 @@ import {LNURLWithdrawParamsWithUrl} from "../../../../types/lnurl/LNURLWithdraw"
 import {tryWithRetries} from "../../../../utils/RetryUtils";
 import {AllOptional} from "../../../../utils/TypeUtils";
 import {sha256} from "@noble/hashes/sha2";
+import {fromHumanReadableString} from "../../../../utils/TokenUtils";
 
 export type FromBTCLNAutoOptions = {
-    paymentHash?: Buffer,
+    /**
+     * Instead of letting the SDK generate the preimage/paymentHash pair internally you can pass your computed
+     *  paymentHash here, this will create the swap with the provided payment hash. Note that swaps created this way
+     *  won't settle automatically (as the SDK is missing the preimage). Once the HTLC towards the user is created in
+     *  the {@link FromBTCLNAutoSwapState.CLAIM_COMMITED} state, you should pass the secret preimage manually in the
+     *  {@link FromBTCLNAutoSwap.waitTillClaimed}, {@link FromBTCLNAutoSwap.claim} or {@link FromBTCLNAutoSwap.txsClaim}
+     *  functions.
+     *
+     * Accepts both, a {@link Buffer} and a hexadecimal `string`
+     */
+    paymentHash?: Buffer | string,
+    /**
+     * Optional description to use for the swap lightning network invoice, keep the invoice length below 500 characters
+     */
     description?: string,
-    descriptionHash?: Buffer,
+    /**
+     * Optional description hash to use for the lightning network invoice, useful when returning the invoice as part of
+     *  an LNURL-pay service endpoint.
+     *
+     * Accepts both, a {@link Buffer} and a hexadecimal `string`
+     */
+    descriptionHash?: Buffer | string,
+    /**
+     * Optional additional native token to receive as an output of the swap (e.g. STRK on Starknet or cBTC on Citrea).
+     *  When passed as a `bigint` it is specified in base units of the token and in `string` it is the human readable
+     *  decimal format.
+     */
+    gasAmount?: bigint | string,
+    /**
+     * A flag to skip checking whether the lightning network node of the LP has enough channel liquidity to facilitate
+     *  the swap.
+     */
     unsafeSkipLnNodeCheck?: boolean,
-    gasAmount?: bigint,
+    /**
+     * A flag to attach 0 watchtower fee to the swap, this would make the settlement unattractive for the watchtowers
+     *  and therefore automatic settlement for such swaps will not be possible, you will have to settle manually
+     *  with {@link FromBTCLNSwap.claim} or {@link FromBTCLNSwap.txsClaim} functions.
+     */
     unsafeZeroWatchtowerFee?: boolean,
+    /**
+     * A safety factor to use when estimating the watchtower fee to attach to the swap (this has to cover the gas fee
+     *  of watchtowers settling the swap). A higher multiple here would mean that a swap is more attractive for
+     *  watchtowers to settle automatically.
+     *
+     * Uses a `1.25` multiple by default (i.e. the current network fee is multiplied by 1.25 and then used to estimate
+     *  the settlement gas fee cost)
+     */
     feeSafetyFactor?: number
 };
 
@@ -326,26 +368,21 @@ export class FromBTCLNAutoWrapper<
         if(!this.isInitialized) throw new Error("Not initialized, call init() first!");
 
         const _options = {
-            paymentHash: options?.paymentHash,
+            paymentHash: parseHashValueExact32Bytes(options?.paymentHash, "payment hash"),
             unsafeSkipLnNodeCheck: options?.unsafeSkipLnNodeCheck ?? this._options.unsafeSkipLnNodeCheck,
-            gasAmount: options?.gasAmount ?? 0n,
+            gasAmount: this.parseGasAmount(options?.gasAmount),
             feeSafetyFactor: options?.feeSafetyFactor ?? 1.25, //No need to add much of a margin, since the claim should happen rather soon
             unsafeZeroWatchtowerFee: options?.unsafeZeroWatchtowerFee ?? false,
             description: options?.description,
-            descriptionHash: options?.descriptionHash
+            descriptionHash: parseHashValueExact32Bytes(options?.descriptionHash, "description hash")
         };
 
-        if(_options.paymentHash!=null && _options.paymentHash.length!==32)
-            throw new UserError("Invalid payment hash length, must be exactly 32 bytes!");
-
-        if(_options.descriptionHash!=null && _options.descriptionHash.length!==32)
-            throw new UserError("Invalid description hash length");
+        if(amountData.token===this._chain.getNativeCurrencyAddress() && _options.gasAmount!==0n)
+            throw new UserError("Cannot specify `gasAmount` for swaps to a native token!");
 
         if(_options.description!=null && Buffer.byteLength(_options.description, "utf8") > 500)
             throw new UserError("Invalid description length");
 
-        if(preFetches==null) preFetches = {};
-
         let secret: Buffer | undefined;
         let paymentHash: Buffer;
         if(_options?.paymentHash!=null) {
@@ -358,6 +395,8 @@ export class FromBTCLNAutoWrapper<
         const nativeTokenAddress = this._chain.getNativeCurrencyAddress();
 
         const _abortController = extendAbortController(abortSignal);
+
+        preFetches ??= {};
         const _preFetches = {
             pricePrefetchPromise: preFetches?.pricePrefetchPromise ?? this.preFetchPrice(amountData, _abortController.signal),
             usdPricePrefetchPromise: preFetches?.usdPricePrefetchPromise ?? this.preFetchUsdPrice(_abortController.signal),
@@ -497,18 +536,15 @@ export class FromBTCLNAutoWrapper<
         if(!this.isInitialized) throw new Error("Not initialized, call init() first!");
 
         const _options = {
-            paymentHash: options?.paymentHash,
+            paymentHash: parseHashValueExact32Bytes(options?.paymentHash, "payment hash"),
             unsafeSkipLnNodeCheck: options?.unsafeSkipLnNodeCheck ?? this._options.unsafeSkipLnNodeCheck,
-            gasAmount: options?.gasAmount ?? 0n,
+            gasAmount: this.parseGasAmount(options?.gasAmount),
             feeSafetyFactor: options?.feeSafetyFactor ?? 1.25, //No need to add much of a margin, since the claim should happen rather soon
             unsafeZeroWatchtowerFee: options?.unsafeZeroWatchtowerFee ?? false,
             description: options?.description,
-            descriptionHash: options?.descriptionHash
+            descriptionHash: parseHashValueExact32Bytes(options?.descriptionHash, "description hash")
         };
 
-        if(_options.paymentHash!=null && _options.paymentHash.length!==32)
-            throw new UserError("Invalid payment hash length, must be exactly 32 bytes!");
-
         const abortController = extendAbortController(abortSignal);
         const preFetches = {
             pricePrefetchPromise: this.preFetchPrice(amountData, abortController.signal),

package/src/swaps/escrow_swaps/frombtc/onchain/FromBTCSwap.ts

@@ -356,7 +356,7 @@ export class FromBTCSwap<T extends ChainType = ChainType>
     /**
      * @inheritDoc
      */
-    getInput(): TokenAmount<T["ChainId"], BtcToken<false>> {
+    getInput(): TokenAmount<BtcToken<false>> {
         return toTokenAmount(this.amount ?? null, this.inputToken, this.wrapper._prices);
     }
 
@@ -365,7 +365,7 @@ export class FromBTCSwap<T extends ChainType = ChainType>
      *  this amount is pre-funded by the user on the destination chain when the swap escrow
      *  is initiated. For total pre-funded deposit amount see {@link getTotalDeposit}.
      */
-    getClaimerBounty(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>, true> {
+    getClaimerBounty(): TokenAmount<SCToken<T["ChainId"]>, true> {
         return toTokenAmount(this._data.getClaimerBounty(), this.wrapper._tokens[this._data.getDepositToken()], this.wrapper._prices);
     }
 
@@ -661,7 +661,7 @@ export class FromBTCSwap<T extends ChainType = ChainType>
     /**
      * @inheritDoc
      */
-    async estimateBitcoinFee(_bitcoinWallet: IBitcoinWallet | MinimalBitcoinWalletInterface, feeRate?: number): Promise<TokenAmount<any, BtcToken<false>, true> | null> {
+    async estimateBitcoinFee(_bitcoinWallet: IBitcoinWallet | MinimalBitcoinWalletInterface, feeRate?: number): Promise<TokenAmount<BtcToken<false>, true> | null> {
         if(this.address==null || this.amount==null) return null;
         const bitcoinWallet: IBitcoinWallet = toBitcoinWallet(_bitcoinWallet, this.wrapper._btcRpc, this.wrapper._options.bitcoinNetwork);
         const txFee = await bitcoinWallet.getTransactionFee(this.address, this.amount, feeRate);