@atomiqlabs/lp-lib 11.0.5 → 12.0.0-beta.0

package/src/swaps/frombtcln_trusted/FromBtcLnTrusted.ts

@@ -1,4 +1,3 @@
-import * as BN from "bn.js";
 import {Express, Request, Response} from "express";
 import {createHash, randomBytes} from "crypto";
 import {
@@ -18,7 +17,6 @@ import {ServerParamEncoder} from "../../utils/paramcoders/server/ServerParamEnco
 import {FieldTypeEnum, verifySchema} from "../../utils/paramcoders/SchemaVerifier";
 import {PluginManager} from "../../plugins/PluginManager";
 import {FromBtcLnBaseSwapHandler} from "../FromBtcLnBaseSwapHandler";
-import {serverParamDecoder} from "../../utils/paramcoders/server/ServerParamDecoder";
 import {
     HodlInvoiceInit,
     ILightningWallet,
@@ -27,15 +25,16 @@ import {
 } from "../../wallets/ILightningWallet";
 
 export type SwapForGasServerConfig = FromBtcBaseConfig & {
-    minCltv: BN,
+    minCltv: bigint,
 
     invoiceTimeoutSeconds?: number
 }
 
 export type FromBtcLnTrustedRequestType = {
     address: string,
-    amount: BN,
-    exactOut?: boolean
+    amount: bigint,
+    exactIn?: boolean,
+    token?: string
 };
 
 /**
@@ -43,6 +42,7 @@ export type FromBtcLnTrustedRequestType = {
  */
 export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedSwap, FromBtcLnTrustedSwapState> {
     readonly type: SwapHandlerType = SwapHandlerType.FROM_BTCLN_TRUSTED;
+    readonly swapType = null;
 
     activeSubscriptions: Map<string, AbortController> = new Map<string, AbortController>();
     processedTxIds: Map<string, string> = new Map<string, string>();
@@ -60,9 +60,6 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
         super(storageDirectory, path, chains, lightning, swapPricing);
         this.config = config;
         this.config.invoiceTimeoutSeconds = this.config.invoiceTimeoutSeconds || 90;
-        for(let chainId in chains.chains) {
-            this.allowedTokens[chainId] = new Set<string>([chains.chains[chainId].swapContract.getNativeCurrencyAddress()]);
-        }
     }
 
     /**
@@ -85,7 +82,7 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
      * @param invoiceData
      */
     private subscribeToInvoice(invoiceData: FromBtcLnTrustedSwap) {
-        const hash = invoiceData.getHash();
+        const hash = invoiceData.getIdentifierHash();
 
         //Already subscribed
         if(this.activeSubscriptions.has(hash)) return;
@@ -140,7 +137,7 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
         for(let swap of swaps) {
             //Cancel invoices
             try {
-                const paymentHash = swap.getHash();
+                const paymentHash = swap.getIdentifierHash();
                 await this.lightning.cancelHodlInvoice(paymentHash);
                 this.unsubscribeInvoice(paymentHash);
                 this.swapLogger.info(swap, "cancelInvoices(): invoice cancelled!");
@@ -171,7 +168,7 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
             }
         ]);
 
-        for(let swap of queriedData) {
+        for(let {obj: swap} of queriedData) {
             if(await this.processPastSwap(swap)) cancelInvoices.push(swap);
         }
 
@@ -181,7 +178,7 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
     private async cancelSwapAndInvoice(swap: FromBtcLnTrustedSwap): Promise<void> {
         if(swap.state!==FromBtcLnTrustedSwapState.RECEIVED) return;
         await swap.setState(FromBtcLnTrustedSwapState.CANCELED);
-        const paymentHash = swap.getHash();
+        const paymentHash = swap.getIdentifierHash();
         await this.lightning.cancelHodlInvoice(paymentHash);
         this.unsubscribeInvoice(paymentHash);
         await this.removeSwapData(swap);
@@ -206,7 +203,7 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
         }
 
         if(invoiceData.state===FromBtcLnTrustedSwapState.RECEIVED) {
-            const balance: Promise<BN> = swapContract.getBalance(signer.getAddress(), swapContract.getNativeCurrencyAddress(), false);
+            const balance: Promise<bigint> = swapContract.getBalance(signer.getAddress(), invoiceData.token, false);
             try {
                 await this.checkBalance(invoiceData.output, balance, null);
                 if(invoiceData.metadata!=null) invoiceData.metadata.times.htlcBalanceChecked = Date.now();
@@ -217,7 +214,7 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
 
             if(invoiceData.state!==FromBtcLnTrustedSwapState.RECEIVED) return;
 
-            const txns = await swapContract.txsTransfer(signer.getAddress(), swapContract.getNativeCurrencyAddress(), invoiceData.output, invoiceData.dstAddress);
+            const txns = await swapContract.txsTransfer(signer.getAddress(), invoiceData.token, invoiceData.output, invoiceData.dstAddress);
 
             let unlock = invoiceData.lock(Infinity);
             if(unlock==null) return;
@@ -289,7 +286,7 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
 
             if(invoiceData.metadata!=null) invoiceData.metadata.times.htlcSettled = Date.now();
 
-            const paymentHash = invoiceData.getHash();
+            const paymentHash = invoiceData.getIdentifierHash();
             this.processedTxIds.set(paymentHash, invoiceData.txIds.init);
             await invoiceData.setState(FromBtcLnTrustedSwapState.SETTLED);
 
@@ -382,12 +379,18 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
              * amount: string               amount (in lamports/smart chain base units) of the invoice
              */
 
-            const parsedBody: FromBtcLnTrustedRequestType = await req.paramReader.getParams({
+            req.query.token ??= swapContract.getNativeCurrencyAddress();
+
+            const parsedBody: FromBtcLnTrustedRequestType = verifySchema(req.query,{
                 address: (val: string) => val!=null &&
                     typeof(val)==="string" &&
                     swapContract.isValidAddress(val) ? val : null,
-                amount: FieldTypeEnum.BN,
-                exactOut: FieldTypeEnum.BooleanOptional
+                token: (val: string) => val!=null &&
+                    typeof(val)==="string" &&
+                    this.isTokenSupported(chainIdentifier, val) ? val : null,
+                amount: FieldTypeEnum.BigInt,
+                exactIn: (val: string) => val==="true" ? true :
+                    (val==="false" || val===undefined) ? false : null
             });
             if(parsedBody==null) throw {
                 code: 20100,
@@ -395,14 +398,14 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
             };
             metadata.request = parsedBody;
 
-            const requestedAmount = {input: !parsedBody.exactOut, amount: parsedBody.amount};
+            const requestedAmount = {input: parsedBody.exactIn, amount: parsedBody.amount};
             const request = {
                 chainIdentifier,
                 raw: req,
                 parsed: parsedBody,
                 metadata
             };
-            const useToken = swapContract.getNativeCurrencyAddress();
+            const useToken = parsedBody.token;
 
             //Check request params
             const fees = await this.preCheckAmounts(request, requestedAmount, useToken);
@@ -413,7 +416,7 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
             const abortController = this.getAbortController(responseStream);
 
             //Pre-fetch data
-            const {pricePrefetchPromise} = this.getFromBtcPricePrefetches(chainIdentifier, useToken, abortController);
+            const {pricePrefetchPromise} = this.getFromBtcPricePrefetches(chainIdentifier, useToken, useToken, abortController);
             const balancePrefetch = swapContract.getBalance(signer.getAddress(), useToken, false).catch(e => {
                 this.logger.error("getBalancePrefetch(): balancePrefetch error: ", e);
                 abortController.abort(e);
@@ -440,10 +443,10 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
 
             const hodlInvoiceObj: HodlInvoiceInit = {
                 description: chainIdentifier+"-GAS-"+parsedBody.address,
-                cltvDelta: this.config.minCltv.add(new BN(5)).toNumber(),
+                cltvDelta: Number(this.config.minCltv) + 5,
                 expiresAt: Date.now()+(this.config.invoiceTimeoutSeconds*1000),
                 id: hash.toString("hex"),
-                mtokens: amountBD.mul(new BN(1000))
+                mtokens: amountBD * 1000n
             };
             metadata.invoiceRequest = hodlInvoiceObj;
 
@@ -462,7 +465,8 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
                 swapFeeInToken,
                 totalInToken,
                 secret.toString("hex"),
-                parsedBody.address
+                parsedBody.address,
+                useToken
             );
             metadata.times.swapCreated = Date.now();
             createdSwap.metadata = metadata;
@@ -473,21 +477,21 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
 
             this.swapLogger.info(createdSwap, "REST: /createInvoice: Created swap invoice: "+hodlInvoice.request+" amount: "+amountBD.toString(10));
 
-            await responseStream.writeParamsAndEnd({
+            res.status(200).json({
                 msg: "Success",
                 code: 10000,
                 data: {
                     pr: hodlInvoice.request,
+                    amountSats: amountBD.toString(10),
+                    swapFeeSats: swapFee.toString(10),
                     swapFee: swapFeeInToken.toString(10),
                     total: totalInToken.toString(10),
                     intermediaryKey: signer.getAddress()
                 }
             });
-
         });
 
-        restServer.use(this.path+"/createInvoice", serverParamDecoder(10*1000));
-        restServer.post(this.path+"/createInvoice", createInvoice);
+        restServer.get(this.path+"/createInvoice", createInvoice);
 
         const getInvoiceStatus = expressHandlerWrapper(async (req, res) => {
             /**
@@ -557,7 +561,6 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
                 }
             };
         });
-        restServer.post(this.path+"/getInvoiceStatus", getInvoiceStatus);
         restServer.get(this.path+"/getInvoiceStatus", getInvoiceStatus);
 
         this.logger.info("started at path: ", this.path);
@@ -566,10 +569,10 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
     async init() {
         await this.storageManager.loadData(FromBtcLnTrustedSwap);
         //Check if all swaps contain a valid amount
-        for(let swap of await this.storageManager.query([])) {
+        for(let {obj: swap} of await this.storageManager.query([])) {
             if(swap.amount==null) {
                 const parsedPR = await this.lightning.parsePaymentRequest(swap.pr);
-                swap.amount = parsedPR.mtokens.add(new BN(999)).div(new BN(1000));
+                swap.amount = (parsedPR.mtokens + 999n) / 1000n;
             }
         }
         await PluginManager.serviceInitialize(this);
@@ -577,19 +580,19 @@ export class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedS
 
     getInfoData(): any {
         return {
-            minCltv: this.config.minCltv.toNumber()
-        }
+            minCltv: Number(this.config.minCltv)
+        };
     }
 
-    protected processClaimEvent(chainIdentifier: string, event: ClaimEvent<SwapData>): Promise<void> {
+    protected processClaimEvent(chainIdentifier: string, swap: FromBtcLnTrustedSwap, event: ClaimEvent<SwapData>): Promise<void> {
         return Promise.resolve();
     }
 
-    protected processInitializeEvent(chainIdentifier: string, event: InitializeEvent<SwapData>): Promise<void> {
+    protected processInitializeEvent(chainIdentifier: string, swap: FromBtcLnTrustedSwap, event: InitializeEvent<SwapData>): Promise<void> {
         return Promise.resolve();
     }
 
-    protected processRefundEvent(chainIdentifier: string, event: RefundEvent<SwapData>): Promise<void> {
+    protected processRefundEvent(chainIdentifier: string, swap: FromBtcLnTrustedSwap, event: RefundEvent<SwapData>): Promise<void> {
         return Promise.resolve();
     }
 

package/src/swaps/frombtcln_trusted/FromBtcLnTrustedSwap.ts

@@ -1,4 +1,3 @@
-import * as BN from "bn.js";
 import {SwapData} from "@atomiqlabs/base";
 import {createHash} from "crypto";
 import {FromBtcBaseSwap} from "../FromBtcBaseSwap";
@@ -17,49 +16,63 @@ export enum FromBtcLnTrustedSwapState {
 export class FromBtcLnTrustedSwap<T extends SwapData = SwapData> extends FromBtcBaseSwap<T, FromBtcLnTrustedSwapState> {
 
     readonly pr: string;
-    readonly output: BN;
+    readonly output: bigint;
     readonly dstAddress: string;
     readonly secret: string;
+    readonly token: string;
 
     scRawTx: string;
 
     constructor(
         chainIdentifier: string,
         pr: string,
-        inputMtokens: BN,
-        swapFee: BN,
-        swapFeeInToken: BN,
-        output: BN,
+        inputMtokens: bigint,
+        swapFee: bigint,
+        swapFeeInToken: bigint,
+        output: bigint,
         secret: string,
-        dstAddress: string
+        dstAddress: string,
+        token: string
     );
     constructor(obj: any);
 
-    constructor(chainIdOrObj: string | any, pr?: string, inputMtokens?: BN, swapFee?: BN, swapFeeInToken?: BN, output?: BN, secret?: string, dstAddress?: string) {
+    constructor(
+        chainIdOrObj: string | any,
+        pr?: string,
+        inputMtokens?: bigint,
+        swapFee?: bigint,
+        swapFeeInToken?: bigint,
+        output?: bigint,
+        secret?: string,
+        dstAddress?: string,
+        token?: string
+    ) {
         if(typeof(chainIdOrObj)==="string") {
-            super(chainIdOrObj, inputMtokens.add(new BN(999)).div(new BN(1000)), swapFee, swapFeeInToken);
+            super(chainIdOrObj, (inputMtokens + 999n) / 1000n, swapFee, swapFeeInToken);
             this.state = FromBtcLnTrustedSwapState.CREATED;
             this.pr = pr;
             this.output = output;
             this.secret = secret;
             this.dstAddress = dstAddress;
+            this.token = token;
         } else {
             super(chainIdOrObj);
             this.pr = chainIdOrObj.pr;
             this.output = deserializeBN(chainIdOrObj.output);
             this.secret = chainIdOrObj.secret;
             this.dstAddress = chainIdOrObj.dstAddress;
+            this.token = chainIdOrObj.token;
             this.scRawTx = chainIdOrObj.scRawTx;
         }
         this.type = null;
     }
 
-    getHash(): string {
+    getClaimHash(): string {
         return createHash("sha256").update(Buffer.from(this.secret, "hex")).digest().toString("hex");
     }
 
-    getSequence(): BN {
-        return new BN(0);
+    getSequence(): bigint {
+        return 0n;
     }
 
     serialize(): any {
@@ -68,6 +81,7 @@ export class FromBtcLnTrustedSwap<T extends SwapData = SwapData> extends FromBtc
         partialSerialized.output = serializeBN(this.output);
         partialSerialized.secret = this.secret;
         partialSerialized.dstAddress = this.dstAddress;
+        partialSerialized.token = this.token;
         partialSerialized.scRawTx = this.scRawTx;
         return partialSerialized;
     }