@teleportdao/bitcoin 1.4.4 → 1.4.7

package/src/{teleport-dao-payments.js → teleport-dao-payments.ts}

@@ -1,9 +1,31 @@
+import type { ExtendedUtxo, Target } from "./transaction-builder/transaction-builder"
 import { BitcoinBase } from "./bitcoin-base"
 
-class TeleportDaoPayment extends BitcoinBase {
+export type TransferRequest = {
+  changeAddress?: string
+  lockerAddress: string
+  amount: number
+  fullAmount?: boolean
+  //-----------
+  chainId: number
+  appId: number
+  recipientAddress: string // 20 bytes
+  percentageFee: number // 2 bytes in satoshi
+  speed?: number | boolean // 1 byte
+  isExchange?: boolean
+  exchangeTokenAddress?: string // 20 bytes
+  outputAmount?: number // 28 bytes
+  deadline?: number // 4 bytes
+  isFixedToken?: boolean // 1 byte
+  feeSpeed?: "normal" | "fast" | "slow"
+}
+export class TeleportDaoPayment extends BitcoinBase {
   // payment
-  async payBurnRequest(receivers, feeSpeed = "normal") {
-    let extendedUtxo = await this.transactionBuilder.getExtendedUtxo({
+  async payBurnRequest(receivers: Target[], feeSpeed: "normal" | "fast" | "slow" = "normal") {
+    if (!this.currentAccount || !this.currentAccountType || !this.publicKey || !this.privateKey) {
+      throw new Error("account not initialized")
+    }
+    let extendedUtxo = await this.getExtendedUtxo({
       address: this.currentAccount,
       addressType: this.currentAccountType,
       publicKey: this.publicKey.toString("hex"),
@@ -40,7 +62,10 @@ class TeleportDaoPayment extends BitcoinBase {
     deadline, // 4 bytes
     isFixedToken = false, // 1 byte
     feeSpeed = "normal",
-  }) {
+  }: TransferRequest) {
+    if (!this.currentAccount || !this.currentAccountType || !this.publicKey || !this.privateKey) {
+      throw new Error("account not initialized")
+    }
     let extendedUtxo = await this.getExtendedUtxo({
       address: this.currentAccount,
       addressType: this.currentAccountType,
@@ -86,7 +111,7 @@ class TeleportDaoPayment extends BitcoinBase {
     outputAmount = 0, // 28 bytes
     deadline = 0, // 4 bytes
     isFixedToken = false, // 1 byte
-  }) {
+  }: TransferRequest): Promise<Target[]> {
     let dataHex = TeleportDaoPayment.getTransferOpReturnData({
       chainId,
       appId,
@@ -129,6 +154,8 @@ class TeleportDaoPayment extends BitcoinBase {
     deadline = 0, // 4 bytes
     isFixedToken = false, // 1 byte
     feeSpeed = "normal",
+  }: TransferRequest & {
+    extendedUtxo: ExtendedUtxo[]
   }) {
     let feeRate = await this.transactionBuilder._getFeeRate(feeSpeed)
     let targets = await this.getBitcoinToEthTargetOutputs({
@@ -169,7 +196,22 @@ class TeleportDaoPayment extends BitcoinBase {
     isBorrow = false,
     tokenAddress = "0x0000000000000000000000000000000000000000", // 20 bytes
     borrowAmount = 0, // 28 bytes
+  }: {
+    lockerAddress: string
+    amount: number
+    chainId: number
+    appId: number
+    recipientAddress: string // 20 bytes
+    percentageFee: number // 2 bytes in satoshi
+    mode?: 0 | 1 | boolean // 1 byte
+    isBorrow?: boolean
+    tokenAddress?: string // 20 bytes
+    borrowAmount?: number // 28 bytes
   }) {
+    if (!this.currentAccount || !this.currentAccountType || !this.publicKey || !this.privateKey) {
+      throw new Error("account not initialized")
+    }
+
     let dataHex = TeleportDaoPayment.getLendingOpReturnData({
       chainId,
       appId,
@@ -217,6 +259,17 @@ class TeleportDaoPayment extends BitcoinBase {
     outputAmount = 0, // 28 bytes
     deadline, // 4 bytes
     isFixedToken = false, // 1 byte
+  }: {
+    chainId: number
+    appId: number
+    recipientAddress: string // 20 bytes
+    percentageFee: number // 2 bytes in satoshi
+    deadline: number // 4 bytes
+    speed?: number | boolean // 1 byte
+    isExchange?: boolean
+    exchangeTokenAddress?: string // 20 bytes
+    outputAmount?: number // 28 bytes
+    isFixedToken?: boolean // 1 byte
   }) {
     let chainIdHex = Number(chainId).toString(16).padStart(2, "0")
     let appIdHex = Number(appId).toString(16).padStart(4, "0")
@@ -255,6 +308,15 @@ class TeleportDaoPayment extends BitcoinBase {
     isBorrow = false,
     tokenAddress = "0x0000000000000000000000000000000000000000", // 20 bytes
     borrowAmount = 0, // 28 bytes
+  }: {
+    chainId: number
+    appId: number
+    recipientAddress: string // 20 bytes
+    percentageFee: number // 2 bytes in satoshi
+    mode?: 0 | 1 | boolean // 1 byte
+    isBorrow?: boolean
+    tokenAddress?: string // 20 bytes
+    borrowAmount?: number // 28 bytes
   }) {
     let chainIdHex = Number(chainId).toString(16).padStart(2, "0")
     let appIdHex = Number(appId).toString(16).padStart(4, "0")
@@ -276,5 +338,4 @@ class TeleportDaoPayment extends BitcoinBase {
     return dataHex
   }
 }
-
 export default TeleportDaoPayment

package/src/transaction-builder/bitcoin-transaction-builder.ts

@@ -1,5 +1,5 @@
 import BaseTransactionBuilder from "./transaction-builder"
-import BitcoinInterface from "../bitcoin-interface"
+import { BitcoinInterface } from "../bitcoin-interface"
 import * as bitcoin from "bitcoinjs-lib"
 
 export type BitcoinConnectionInfo = {
@@ -9,10 +9,14 @@ export type BitcoinConnectionInfo = {
     headers?: {
       [key: string]: string
     }
-    auth: any
+    auth?: {
+      username: string
+      password: string
+    }
   }
-  api?: {
+  api: {
     enabled?: boolean
+    token?: string
     provider: string
   }
 }
@@ -40,7 +44,7 @@ class BitcoinTransactionBuilder extends BaseTransactionBuilder {
     }))
   }
 
-  async _getFeeRate(speed: string) {
+  async _getFeeRate(speed: "normal" | "slow" | "fast" = "normal") {
     return this.btcInterface.getFeeRate(speed)
   }
 

package/src/transaction-builder/transaction-builder.ts

@@ -36,6 +36,7 @@ export type SignerInfo = {
   addressType: string
   derivationPath?: string
   masterFingerprint?: string
+  includeHex?: boolean
 }
 export type ExtendedUtxo = {
   signerInfo: SignerInfo
@@ -54,6 +55,13 @@ export type TargetScript = {
   value: number
 }
 export type Target = TargetAddress | TargetScript
+export type ChangeTarget = TargetAddress & {
+  bip32Derivation?: {
+    path: string
+    pubkey: Buffer
+    masterFingerprint: Buffer
+  }[]
+}
 
 export type BitcoinJSInputInfo = ExtendedUtxo & {
   bip32Derivation?: {
@@ -146,7 +154,7 @@ class BaseBitcoinLikeTransaction {
       network: this.network,
     })
     return {
-      script: embed.output,
+      script: embed.output!,
       value: 0,
     }
   }
@@ -167,13 +175,19 @@ class BaseBitcoinLikeTransaction {
     targets,
     extendedUtxo,
     feeRate,
-    changeAddress,
+    changeObject,
     selectType = "normal", // "accumulative" | "normal" | "full"
   }: {
     extendedUtxo: ExtendedUtxo[]
     targets: Target[]
     feeRate: number
-    changeAddress?: string
+    changeObject?: {
+      address: string
+      publicKey?: string
+      addressType?: string
+      derivationPath?: string
+      masterFingerprint?: string
+    }
     selectType?: "normal" | "accumulative" | "full"
   }) {
     let selectResponse
@@ -217,12 +231,26 @@ class BaseBitcoinLikeTransaction {
       throw new Error("not enough balance")
     }
     let changeIndex = outputs.findIndex((x) => !x?.address && !x.script && (x.value || 0) > 0)
-    let change: Target | undefined
+    let change: ChangeTarget | undefined
     if (changeIndex >= 0) {
-      if (!changeAddress) throw new Error("change address not exist")
-      change = {
-        address: changeAddress,
-        value: outputs[changeIndex].value,
+      if (!changeObject) throw new Error("change not exist")
+      if (changeObject.derivationPath && changeObject.masterFingerprint && changeObject.publicKey) {
+        change = {
+          address: changeObject.address,
+          value: outputs[changeIndex].value,
+          bip32Derivation: [
+            {
+              path: changeObject.derivationPath,
+              pubkey: Buffer.from(changeObject.publicKey, "hex"),
+              masterFingerprint: Buffer.from(changeObject.masterFingerprint, "hex"),
+            },
+          ],
+        }
+      } else {
+        change = {
+          address: changeObject.address,
+          value: outputs[changeIndex].value,
+        }
       }
       outputs.splice(changeIndex, 1)
     }
@@ -231,21 +259,27 @@ class BaseBitcoinLikeTransaction {
       inputs,
       fee,
       outputs: outputs as Target[],
-      change: change as TargetAddress,
+      change,
     }
   }
 
   async filterAndConvertTxDataToStandardFormat({
     extendedUtxo,
     targets,
-    changeAddress,
+    changeObject,
     feeRate,
     selectType,
   }: {
     extendedUtxo: ExtendedUtxo[]
     targets: Target[]
     feeRate: number
-    changeAddress?: string
+    changeObject?: {
+      address: string
+      publicKey?: string
+      addressType?: string
+      derivationPath?: string
+      masterFingerprint?: string
+    }
     selectType?: "normal" | "accumulative" | "full"
   }) {
     let {
@@ -257,7 +291,7 @@ class BaseBitcoinLikeTransaction {
       targets,
       extendedUtxo,
       feeRate,
-      changeAddress,
+      changeObject,
       selectType,
     })
 
@@ -274,7 +308,9 @@ class BaseBitcoinLikeTransaction {
 
   // ?note : we can extend this class and change this method for network other than bitcoin
   async convertExtendedUtxoToInputs(baseInputs: ExtendedUtxo[] = []) {
-    let inputs: BitcoinJSInputInfo[] = baseInputs
+    let inputs: (BitcoinJSInputInfo & {
+      signerInfo: SignerInfo
+    })[] = baseInputs
     let transactionId: string | null = null
     let transactionHex: string | null = null
     for (let i in inputs) {
@@ -310,6 +346,16 @@ class BaseBitcoinLikeTransaction {
           script: addressObject.output,
           value: inputs[i].value,
         }
+
+        if (inputs[i].signerInfo.includeHex) {
+          if (transactionHex && transactionId === inputs[i].hash) {
+            inputs[i].nonWitnessUtxo = Buffer.from(transactionHex, "hex")
+          } else {
+            transactionHex = await this._getTransactionHex(inputs[i].hash)
+            transactionId = inputs[i].hash
+            inputs[i].nonWitnessUtxo = Buffer.from(transactionHex, "hex")
+          }
+        }
       } else if (addressType === "p2sh-p2wpkh") {
         // add p2sh-p2wpkh data
         if (!addressObject.output) throw new Error("invalid signer info")
@@ -319,6 +365,16 @@ class BaseBitcoinLikeTransaction {
         }
         if (!addressObject?.redeem?.output) throw new Error("invalid signer info for p2sh address")
         inputs[i].redeemScript = addressObject.redeem.output
+
+        if (inputs[i].signerInfo.includeHex) {
+          if (transactionHex && transactionId === inputs[i].hash) {
+            inputs[i].nonWitnessUtxo = Buffer.from(transactionHex, "hex")
+          } else {
+            transactionHex = await this._getTransactionHex(inputs[i].hash)
+            transactionId = inputs[i].hash
+            inputs[i].nonWitnessUtxo = Buffer.from(transactionHex, "hex")
+          }
+        }
       } else if (addressType === "p2tr") {
         if (!addressObject.output) throw new Error("invalid signer info")
         inputs[i].witnessUtxo = {
@@ -328,6 +384,16 @@ class BaseBitcoinLikeTransaction {
         if (!addressObject.pubkey) throw new Error("invalid signer info for p2tr address (pubkey)")
         // todo: fix after update to p2tr
         inputs[i].tapInternalKey = Buffer.from(publicKey, "hex")
+
+        if (inputs[i].signerInfo.includeHex) {
+          if (transactionHex && transactionId === inputs[i].hash) {
+            inputs[i].nonWitnessUtxo = Buffer.from(transactionHex, "hex")
+          } else {
+            transactionHex = await this._getTransactionHex(inputs[i].hash)
+            transactionId = inputs[i].hash
+            inputs[i].nonWitnessUtxo = Buffer.from(transactionHex, "hex")
+          }
+        }
       }
     }
 
@@ -344,7 +410,7 @@ class BaseBitcoinLikeTransaction {
   }: {
     inputs: BitcoinJSInputInfo[]
     outputs: Target[]
-    change?: TargetAddress
+    change?: ChangeTarget
     fee: number
     feeRate: number
   }) {
@@ -372,10 +438,13 @@ class BaseBitcoinLikeTransaction {
             hash: input.hash,
             index: Number(input.index),
             witnessUtxo: input.witnessUtxo,
+            // we dont need nonWitnessUtxo. bud some application force nonWitnessUtxo
+            nonWitnessUtxo: input.nonWitnessUtxo,
             sequence: 0xffffffff - 1,
             bip32Derivation: input.bip32Derivation,
           }
           if (!i.bip32Derivation) delete i.bip32Derivation
+          if (!i.nonWitnessUtxo) delete i.nonWitnessUtxo
           newPsbt.addInput(i)
           break
         }
@@ -384,11 +453,14 @@ class BaseBitcoinLikeTransaction {
             hash: input.hash,
             index: Number(input.index),
             witnessUtxo: input.witnessUtxo,
+            // we dont need nonWitnessUtxo. bud some application force nonWitnessUtxo
+            nonWitnessUtxo: input.nonWitnessUtxo,
             redeemScript: input.redeemScript,
             sequence: 0xffffffff - 1,
             bip32Derivation: input.bip32Derivation,
           }
           if (!i.bip32Derivation) delete i.bip32Derivation
+          if (!i.nonWitnessUtxo) delete i.nonWitnessUtxo
           newPsbt.addInput(i)
           break
         }
@@ -397,11 +469,14 @@ class BaseBitcoinLikeTransaction {
             hash: input.hash,
             index: Number(input.index),
             witnessUtxo: input.witnessUtxo,
+            // we dont need nonWitnessUtxo. bud some application force nonWitnessUtxo
+            nonWitnessUtxo: input.nonWitnessUtxo,
             tapInternalKey: input.tapInternalKey,
             sequence: 0xffffffff - 1,
             bip32Derivation: input.bip32Derivation,
           }
           if (!i.bip32Derivation) delete i.bip32Derivation
+          if (!i.nonWitnessUtxo) delete i.nonWitnessUtxo
           newPsbt.addInput(i)
           break
         }
@@ -412,15 +487,12 @@ class BaseBitcoinLikeTransaction {
 
     // add outputs
     for (const target of outputs) {
-      newPsbt.addOutput(target)
+      newPsbt.addOutput({ ...target })
     }
 
     // add changeAddress
     if (change && Object.keys(change).length !== 0) {
-      newPsbt.addOutput({
-        address: change.address,
-        value: Number(change.value),
-      })
+      newPsbt.addOutput(change)
     }
 
     // check created outputs with targets
@@ -428,9 +500,9 @@ class BaseBitcoinLikeTransaction {
       if (newPsbt.txOutputs[outputs.length].address !== change.address) {
         throw new Error("error change address")
       }
-      if (newPsbt.txOutputs[outputs.length].value !== change.value) {
-        throw new Error("error change value")
-      }
+      // if (newPsbt.txOutputs[outputs.length].value !== change.value) {
+      //   throw new Error("error change value")
+      // }
     }
 
     const unsignedPsbtBaseText = newPsbt.toBase64()
@@ -461,17 +533,22 @@ class BaseBitcoinLikeTransaction {
     targets: Target[]
     feeRate: number
 
-    changeAddress?: string
+    changeAddress?: string | SignerInfo
     fullAmount?: boolean
     selfTransaction?: boolean
     selectType?: "normal" | "accumulative" | "full"
   }) {
     if (!selfTransaction && targets.length === 0) throw new Error("no target")
-
+    let changeObject =
+      typeof changeAddress === "string"
+        ? {
+            address: changeAddress,
+          }
+        : changeAddress
     const { inputs, outputs, change, fee } = await this.filterAndConvertTxDataToStandardFormat({
       extendedUtxo,
       targets,
-      changeAddress,
+      changeObject,
       feeRate,
       selectType: fullAmount ? "full" : selectType,
     })

package/src/utils/{networks.js → networks.ts}

@@ -1,31 +1,33 @@
-const bitcoinLib = require("bitcoinjs-lib")
-
-const networks = {
-  bitcoin: bitcoinLib.networks.bitcoin,
-  bitcoin_testnet: bitcoinLib.networks.testnet,
-
-  litecoin: {
-    messagePrefix: "\x19Litecoin Signed Message:\n",
-    bech32: "ltc",
-    bip32: {
-      public: 0x0488b21e,
-      private: 0x0488ade4,
-    },
-    pubKeyHash: 0x30,
-    scriptHash: 0x32,
-    wif: 0xb0,
-  },
-  litecoin_testnet: {
-    messagePrefix: "\x18Litecoin Signed Message:\n",
-    bech32: "tltc",
-    bip32: {
-      public: 0x043587cf,
-      private: 0x04358394,
-    },
-    pubKeyHash: 0x6f,
-    scriptHash: 0x3a, // old 0xc4 -> 2  deprecated
-    wif: 0xef,
-  },
-}
-
-module.exports = networks
+import * as bitcoinLib from "bitcoinjs-lib"
+
+const networks: {
+  [key: string]: bitcoinLib.Network
+} = {
+  bitcoin: bitcoinLib.networks.bitcoin,
+  bitcoin_testnet: bitcoinLib.networks.testnet,
+
+  litecoin: {
+    messagePrefix: "\x19Litecoin Signed Message:\n",
+    bech32: "ltc",
+    bip32: {
+      public: 0x0488b21e,
+      private: 0x0488ade4,
+    },
+    pubKeyHash: 0x30,
+    scriptHash: 0x32,
+    wif: 0xb0,
+  },
+  litecoin_testnet: {
+    messagePrefix: "\x18Litecoin Signed Message:\n",
+    bech32: "tltc",
+    bip32: {
+      public: 0x043587cf,
+      private: 0x04358394,
+    },
+    pubKeyHash: 0x6f,
+    scriptHash: 0x3a, // old 0xc4 -> 2  deprecated
+    wif: 0xef,
+  },
+}
+
+export default networks

package/src/utils/{tools.js → tools.ts}

@@ -1,72 +1,80 @@
-const util = require("util")
-const axios = require("axios")
-
-const sleep = util.promisify(setTimeout)
-
-async function runWithRetries(
-  action,
-  config = {
-    maxTries: 2,
-    retrySleep: 1000,
-  },
-) {
-  const maxTries = config.maxTries || 2
-  const retrySleep = config.retrySleep || 1000 // milliseconds
-  let lastError
-  for (let count = 0; count < maxTries; count += 1) {
-    try {
-      return await action()
-    } catch (error) {
-      lastError = error
-    }
-    await sleep(retrySleep)
-  }
-  throw lastError || new Error("function failed after retries")
-}
-
-function getRandomInteger(min, max) {
-  return Math.floor(Math.random() * (max - min)) + min
-}
-
-function getAxiosInstance({ baseUrl, timeout = 10000, headers = {}, auth }) {
-  let host = baseUrl
-  let instance
-
-  instance = axios.create({
-    baseURL: host,
-    timeout,
-    auth,
-    headers: {
-      ...headers,
-    },
-  })
-
-  // Add a response interceptor
-  instance.interceptors.response.use(
-    (response) => response,
-    (error) => {
-      // todo : fix this part
-      if (error.response) {
-        const serviceError = new Error(
-          JSON.stringify({ data: error.response.data, message: error.message }),
-        )
-        return Promise.reject(serviceError)
-      }
-
-      if (error.request) {
-        const serviceError = new Error(error.message)
-        return Promise.reject(serviceError)
-      }
-      return Promise.reject(error)
-    },
-  )
-
-  return instance
-}
-
-module.exports = {
-  sleep,
-  runWithRetries,
-  getRandomInteger,
-  getAxiosInstance,
-}
+import { promisify } from "util"
+import axios from "axios"
+
+const sleep = promisify(setTimeout)
+
+async function runWithRetries(
+  action: () => any,
+  config = {
+    maxTries: 2,
+    retrySleep: 1000,
+  },
+) {
+  const maxTries = config.maxTries || 2
+  const retrySleep = config.retrySleep || 1000 // milliseconds
+  let lastError
+  for (let count = 0; count < maxTries; count += 1) {
+    try {
+      return await action()
+    } catch (error: any) {
+      lastError = error
+    }
+    await sleep(retrySleep)
+  }
+  throw lastError || new Error("function failed after retries")
+}
+
+function getRandomInteger(min: number, max: number) {
+  return Math.floor(Math.random() * (max - min)) + min
+}
+
+function getAxiosInstance({
+  baseUrl,
+  timeout = 10000,
+  headers = {},
+  auth,
+}: {
+  baseUrl: string
+  timeout?: number
+  headers?: { [key: string]: string }
+  auth?: {
+    username: string
+    password: string
+  }
+}) {
+  let host = baseUrl
+  let instance
+
+  instance = axios.create({
+    baseURL: host,
+    timeout,
+    auth,
+    headers: {
+      ...headers,
+    },
+  })
+
+  // Add a response interceptor
+  instance.interceptors.response.use(
+    (response) => response,
+    (error) => {
+      // todo : fix this part
+      if (error.response) {
+        const serviceError = new Error(
+          JSON.stringify({ data: error.response.data, message: error.message }),
+        )
+        return Promise.reject(serviceError)
+      }
+
+      if (error.request) {
+        const serviceError = new Error(error.message)
+        return Promise.reject(serviceError)
+      }
+      return Promise.reject(error)
+    },
+  )
+
+  return instance
+}
+
+export { sleep, runWithRetries, getRandomInteger, getAxiosInstance }

package/tsconfig.json

@@ -1,9 +1,10 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "src" /* Specify the root folder within your source files. */,
-    "outDir": "dist" /* Specify an output folder for all emitted files. */,
-    "baseUrl": "./src" /* Specify the base directory to resolve non-relative module names. */
-  },
-  "exclude": ["node_modules", "dist"]
-}
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src" /* Specify the root folder within your source files. */,
+    "outDir": "dist" /* Specify an output folder for all emitted files. */,
+    "baseUrl": "./src" /* Specify the base directory to resolve non-relative module names. */
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}