@teleportdao/bitcoin 1.7.21 → 1.8.0

package/src/sign/index.ts

@@ -1 +1 @@
-export { default as BaseBitcoinSigner } from "./sign-transaction"
+export { default as BaseBitcoinSigner } from "./sign-transaction"

package/src/sign/sign-transaction.ts

@@ -1,108 +1,108 @@
-import { Psbt, crypto, Network } from "bitcoinjs-lib"
-// import BIP32Factory from "bip32"
-import ecc from "@bitcoinerlab/secp256k1"
-import ECPairFactory from "ecpair"
-
-const ECPair = ECPairFactory(ecc)
-
-function tapTweakHash(pubKey: Buffer, h?: Buffer) {
-  return crypto.taggedHash("TapTweak", Buffer.concat(h ? [pubKey, h] : [pubKey]))
-}
-
-function tweakSigner(
-  privateKey: Buffer,
-  network: Network,
-  opts = {} as {
-    [key: string]: Buffer
-  },
-) {
-  let newPrv = privateKey
-  let keyPair = ECPair.fromPrivateKey(privateKey, {
-    network,
-    compressed: true,
-  })
-
-  if (!keyPair.privateKey) throw new Error("private key not exist")
-
-  if (keyPair.publicKey.toString("hex").startsWith("03")) {
-    newPrv = ecc.privateNegate(keyPair.privateKey) as Buffer
-  }
-
-  const tweakedPrivateKey = ecc.privateAdd(
-    newPrv,
-    tapTweakHash(Buffer.from(keyPair.publicKey.toString("hex").slice(2), "hex"), opts?.tweakHash),
-  )
-  if (!tweakedPrivateKey) {
-    throw new Error("Invalid tweaked private key!")
-  }
-
-  return ECPair.fromPrivateKey(Buffer.from(tweakedPrivateKey), {
-    network,
-  })
-}
-
-class BitcoinLikeSignTransaction {
-  network: Network
-
-  constructor(network: Network) {
-    this.network = network
-  }
-
-  async signPsbt(
-    unsignedPsbt: {
-      unsignedTransaction: string
-      inputsToSign?: number[]
-    },
-    privateKey: Buffer,
-    sighashTypes?: any[],
-    usingTweakSignerIfNeeded = true,
-  ) {
-    const { network } = this
-    const keyPair = ECPair.fromPrivateKey(privateKey, {
-      network,
-      compressed: true,
-    })
-    const psbt = Psbt.fromBase64(unsignedPsbt.unsignedTransaction, {
-      network,
-    })
-
-    let numberOfInputs = psbt.inputCount
-
-    for (let i = 0; i < numberOfInputs; i += 1) {
-      if (unsignedPsbt.inputsToSign && !unsignedPsbt.inputsToSign.includes(i)) {
-        // eslint-disable-next-line no-continue
-        continue
-      }
-      let type = psbt.getInputType(i)
-
-      if (usingTweakSignerIfNeeded && type === "nonstandard") {
-        console.log("using tweak signer")
-        let a = tweakSigner(privateKey, this.network)
-        await psbt.signInputAsync(i, a, sighashTypes)
-      } else {
-        await psbt.signInputAsync(i, keyPair, sighashTypes)
-      }
-    }
-
-    // psbt.signAllInputs(keyPair)
-    const partialSigendPsbt = psbt.toBase64()
-    return partialSigendPsbt
-  }
-
-  finalizePsbts(psbtsBase64: string[] = []) {
-    const finals = psbtsBase64.map((psbtBase64) =>
-      Psbt.fromBase64(psbtBase64, { network: this.network }),
-    )
-    const psbt =
-      finals.length === 1 ? finals[0] : new Psbt({ network: this.network }).combine(...finals)
-
-    psbt.finalizeAllInputs()
-
-    let finalizeTx = psbt.extractTransaction()
-    // const rawTx = finalizeTx.toBuffer()
-    // const hex = rawTx.toString("hex")
-    return finalizeTx.toHex()
-  }
-}
-
-export default BitcoinLikeSignTransaction
+import { Psbt, crypto, Network } from "bitcoinjs-lib"
+// import BIP32Factory from "bip32"
+import ecc from "@bitcoinerlab/secp256k1"
+import ECPairFactory from "ecpair"
+
+const ECPair = ECPairFactory(ecc)
+
+function tapTweakHash(pubKey: Buffer, h?: Buffer) {
+  return crypto.taggedHash("TapTweak", Buffer.concat(h ? [pubKey, h] : [pubKey]))
+}
+
+function tweakSigner(
+  privateKey: Buffer,
+  network: Network,
+  opts = {} as {
+    [key: string]: Buffer
+  },
+) {
+  let newPrv = privateKey
+  let keyPair = ECPair.fromPrivateKey(privateKey, {
+    network,
+    compressed: true,
+  })
+
+  if (!keyPair.privateKey) throw new Error("private key not exist")
+
+  if (keyPair.publicKey.toString("hex").startsWith("03")) {
+    newPrv = ecc.privateNegate(keyPair.privateKey) as Buffer
+  }
+
+  const tweakedPrivateKey = ecc.privateAdd(
+    newPrv,
+    tapTweakHash(Buffer.from(keyPair.publicKey.toString("hex").slice(2), "hex"), opts?.tweakHash),
+  )
+  if (!tweakedPrivateKey) {
+    throw new Error("Invalid tweaked private key!")
+  }
+
+  return ECPair.fromPrivateKey(Buffer.from(tweakedPrivateKey), {
+    network,
+  })
+}
+
+class BitcoinLikeSignTransaction {
+  network: Network
+
+  constructor(network: Network) {
+    this.network = network
+  }
+
+  async signPsbt(
+    unsignedPsbt: {
+      unsignedTransaction: string
+      inputsToSign?: number[]
+    },
+    privateKey: Buffer,
+    sighashTypes?: any[],
+    usingTweakSignerIfNeeded = true,
+  ) {
+    const { network } = this
+    const keyPair = ECPair.fromPrivateKey(privateKey, {
+      network,
+      compressed: true,
+    })
+    const psbt = Psbt.fromBase64(unsignedPsbt.unsignedTransaction, {
+      network,
+    })
+
+    let numberOfInputs = psbt.inputCount
+
+    for (let i = 0; i < numberOfInputs; i += 1) {
+      if (unsignedPsbt.inputsToSign && !unsignedPsbt.inputsToSign.includes(i)) {
+        // eslint-disable-next-line no-continue
+        continue
+      }
+      let type = psbt.getInputType(i)
+
+      if (usingTweakSignerIfNeeded && type === "nonstandard") {
+        console.log("using tweak signer")
+        let a = tweakSigner(privateKey, this.network)
+        await psbt.signInputAsync(i, a, sighashTypes)
+      } else {
+        await psbt.signInputAsync(i, keyPair, sighashTypes)
+      }
+    }
+
+    // psbt.signAllInputs(keyPair)
+    const partialSigendPsbt = psbt.toBase64()
+    return partialSigendPsbt
+  }
+
+  finalizePsbts(psbtsBase64: string[] = []) {
+    const finals = psbtsBase64.map((psbtBase64) =>
+      Psbt.fromBase64(psbtBase64, { network: this.network }),
+    )
+    const psbt =
+      finals.length === 1 ? finals[0] : new Psbt({ network: this.network }).combine(...finals)
+
+    psbt.finalizeAllInputs()
+
+    let finalizeTx = psbt.extractTransaction()
+    // const rawTx = finalizeTx.toBuffer()
+    // const hex = rawTx.toString("hex")
+    return finalizeTx.toHex()
+  }
+}
+
+export default BitcoinLikeSignTransaction

package/src/teleswap-wallet.ts

@@ -1,155 +1,155 @@
-import { teleswap } from "@teleportdao/configs"
-import type {
-  ExtendedUtxo,
-  SignerInfo,
-  TargetAddress,
-} from "./transaction-builder/transaction-builder"
-import { BitcoinBaseWallet } from "./bitcoin-wallet-base"
-import { generateWrapOpReturn } from "./helper/teleswap-helper"
-
-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"
-  staticFeeRate?: number
-}
-
-export class TeleswapWallet extends BitcoinBaseWallet {
-  // payment
-  async sendToMultipleAddress(
-    receivers: TargetAddress[],
-    feeSpeed: "normal" | "fast" | "slow" = "normal",
-  ) {
-    if (!this.signerInfo || !this.privateKey) {
-      throw new Error("account not initialized")
-    }
-    let extendedUtxo = await this.getExtendedUtxo(this.signerInfo)
-    let feeRate = await this.transactionBuilder._getFeeRate(feeSpeed)
-    let unsignedTx = await this.transactionBuilder.processUnsignedTransaction({
-      extendedUtxo,
-      targets: receivers,
-      changeAddress: this.currentAccount,
-      feeRate,
-      fullAmount: false,
-    })
-    let signedPsbt = await this.signer.signPsbt(unsignedTx, this.privateKey)
-    let signedTx = this.signer.finalizePsbts([signedPsbt])
-    let txId = await this.transactionBuilder.sendTx(signedTx)
-    return txId
-  }
-
-  // send
-
-  async wrapUnsigned(
-    recipientAddress: string,
-    amount: string,
-    networkFee: string,
-    signer: SignerInfo,
-    lockerAddress: string,
-    exchange?: {
-      outputToken: string
-      outputAmount: string
-      bridgePercentageFee?: number
-    },
-    {
-      chainId = 137, // 80001
-      appId = exchange
-        ? teleswap.requestAppId.WrapAndSwap.default
-        : teleswap.requestAppId.Wrap.default,
-    } = {},
-    fullAmount = false,
-    staticExtendedUtxo?: ExtendedUtxo[],
-    staticFeeRate?: number,
-    changeAddress?: string,
-  ) {
-    const dataHex = generateWrapOpReturn({
-      chainId,
-      appId,
-      recipientAddress,
-      networkFee,
-      speed: false,
-      isExchange: !!exchange,
-      outputAmount: exchange?.outputAmount,
-      outputToken: exchange?.outputToken,
-      bridgePercentageFee: exchange?.bridgePercentageFee,
-    })
-    let extendedUtxo = staticExtendedUtxo || (await this.getExtendedUtxo(signer))
-    let feeRate = staticFeeRate || (await this.btcInterface.getFeeRate("normal"))
-
-    const targets = fullAmount
-      ? [this.transactionBuilder.getOpReturnTarget(dataHex)]
-      : [
-          {
-            address: lockerAddress,
-            value: +amount,
-          },
-          this.transactionBuilder.getOpReturnTarget(dataHex),
-        ]
-
-    const unsignedTx = this.transactionBuilder.processUnsignedTransaction({
-      extendedUtxo,
-      feeRate,
-      targets,
-      changeAddress: changeAddress || signer.address,
-      fullAmount,
-    })
-
-    return unsignedTx
-  }
-
-  async wrap(
-    recipientAddress: string,
-    amount: string,
-    networkFee: string,
-    lockerAddress: string,
-    exchange?: {
-      outputToken: string
-      outputAmount: string
-      bridgePercentageFee?: number
-    },
-    {
-      chainId = 137, // 80001
-      appId = exchange ? 1 : 0,
-    } = {},
-    fullAmount = false,
-    staticExtendedUtxo?: ExtendedUtxo[],
-    staticFeeRate?: number,
-    changeAddress?: string,
-  ) {
-    if (!this.signerInfo || !this.privateKey) {
-      throw new Error("account not initialized")
-    }
-    let unsignedTransaction = await this.wrapUnsigned(
-      recipientAddress,
-      amount,
-      networkFee,
-      this.signerInfo,
-      lockerAddress,
-      exchange,
-      {
-        chainId,
-        appId,
-      },
-      fullAmount,
-      staticExtendedUtxo,
-      staticFeeRate,
-      changeAddress,
-    )
-    let signedPsbt = await this.signer.signPsbt(unsignedTransaction, this.privateKey)
-    return this.sendSignedPsbt(signedPsbt)
-  }
-}
-export default TeleswapWallet
+import { teleswap } from "@teleportdao/configs"
+import type {
+  ExtendedUtxo,
+  SignerInfo,
+  TargetAddress,
+} from "./transaction-builder/transaction-builder"
+import { BitcoinBaseWallet } from "./bitcoin-wallet-base"
+import { generateWrapOpReturn } from "./helper/teleswap-helper"
+
+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"
+  staticFeeRate?: number
+}
+
+export class TeleswapWallet extends BitcoinBaseWallet {
+  // payment
+  async sendToMultipleAddress(
+    receivers: TargetAddress[],
+    feeSpeed: "normal" | "fast" | "slow" = "normal",
+  ) {
+    if (!this.signerInfo || !this.privateKey) {
+      throw new Error("account not initialized")
+    }
+    let extendedUtxo = await this.getExtendedUtxo(this.signerInfo)
+    let feeRate = await this.transactionBuilder._getFeeRate(feeSpeed)
+    let unsignedTx = await this.transactionBuilder.processUnsignedTransaction({
+      extendedUtxo,
+      targets: receivers,
+      changeAddress: this.currentAccount,
+      feeRate,
+      fullAmount: false,
+    })
+    let signedPsbt = await this.signer.signPsbt(unsignedTx, this.privateKey)
+    let signedTx = this.signer.finalizePsbts([signedPsbt])
+    let txId = await this.transactionBuilder.sendTx(signedTx)
+    return txId
+  }
+
+  // send
+
+  async wrapUnsigned(
+    recipientAddress: string,
+    amount: string,
+    networkFee: string,
+    signer: SignerInfo,
+    lockerAddress: string,
+    exchange?: {
+      outputToken: string
+      outputAmount: string
+      bridgePercentageFee?: number
+    },
+    {
+      chainId = 137, // 80001
+      appId = exchange
+        ? teleswap.requestAppId.WrapAndSwap.default
+        : teleswap.requestAppId.Wrap.default,
+    } = {},
+    fullAmount = false,
+    staticExtendedUtxo?: ExtendedUtxo[],
+    staticFeeRate?: number,
+    changeAddress?: string,
+  ) {
+    const dataHex = generateWrapOpReturn({
+      chainId,
+      appId,
+      recipientAddress,
+      networkFee,
+      speed: false,
+      isExchange: !!exchange,
+      outputAmount: exchange?.outputAmount,
+      outputToken: exchange?.outputToken,
+      bridgePercentageFee: exchange?.bridgePercentageFee,
+    })
+    let extendedUtxo = staticExtendedUtxo || (await this.getExtendedUtxo(signer))
+    let feeRate = staticFeeRate || (await this.btcInterface.getFeeRate("normal"))
+
+    const targets = fullAmount
+      ? [this.transactionBuilder.getOpReturnTarget(dataHex)]
+      : [
+          {
+            address: lockerAddress,
+            value: +amount,
+          },
+          this.transactionBuilder.getOpReturnTarget(dataHex),
+        ]
+
+    const unsignedTx = this.transactionBuilder.processUnsignedTransaction({
+      extendedUtxo,
+      feeRate,
+      targets,
+      changeAddress: changeAddress || signer.address,
+      fullAmount,
+    })
+
+    return unsignedTx
+  }
+
+  async wrap(
+    recipientAddress: string,
+    amount: string,
+    networkFee: string,
+    lockerAddress: string,
+    exchange?: {
+      outputToken: string
+      outputAmount: string
+      bridgePercentageFee?: number
+    },
+    {
+      chainId = 137, // 80001
+      appId = exchange ? 1 : 0,
+    } = {},
+    fullAmount = false,
+    staticExtendedUtxo?: ExtendedUtxo[],
+    staticFeeRate?: number,
+    changeAddress?: string,
+  ) {
+    if (!this.signerInfo || !this.privateKey) {
+      throw new Error("account not initialized")
+    }
+    let unsignedTransaction = await this.wrapUnsigned(
+      recipientAddress,
+      amount,
+      networkFee,
+      this.signerInfo,
+      lockerAddress,
+      exchange,
+      {
+        chainId,
+        appId,
+      },
+      fullAmount,
+      staticExtendedUtxo,
+      staticFeeRate,
+      changeAddress,
+    )
+    let signedPsbt = await this.signer.signPsbt(unsignedTransaction, this.privateKey)
+    return this.sendSignedPsbt(signedPsbt)
+  }
+}
+export default TeleswapWallet

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

@@ -1,44 +1,44 @@
-import * as bitcoin from "bitcoinjs-lib"
-import { BaseTransactionBuilder } from "./transaction-builder"
-import { BitcoinInterface } from "../bitcoin-interface"
-import { BitcoinConnectionInfo } from "../type"
-
-export class BitcoinTransactionBuilder extends BaseTransactionBuilder {
-  btcInterface: BitcoinInterface
-  constructor(
-    connectionInfo: BitcoinConnectionInfo,
-    networkName: string,
-    network = bitcoin.networks.bitcoin,
-  ) {
-    super({
-      network,
-      testnet: networkName?.includes("_testnet"),
-      dustLimit: 1000,
-    })
-    this.btcInterface = new BitcoinInterface(connectionInfo, networkName)
-  }
-
-  async _getUtxo(userAddress: string) {
-    let utxos = await this.btcInterface.getUtxo(userAddress)
-    return utxos.map((tx) => ({
-      hash: tx.txId as string,
-      value: +tx.value,
-      index: +tx.index,
-    }))
-  }
-
-  async _getFeeRate(speed: "normal" | "slow" | "fast" = "normal") {
-    return this.btcInterface.getFeeRate(speed)
-  }
-
-  async _getTransactionHex(transactionId: string): Promise<string> {
-    return this.btcInterface.getRawTransaction(transactionId)
-  }
-
-  async sendTx(txHex: string): Promise<string> {
-    let txId = await (
-      this.btcInterface.rpcProvider || this.btcInterface.apiProvider
-    ).sendRawTransaction(txHex)
-    return txId
-  }
-}
+import * as bitcoin from "bitcoinjs-lib"
+import { BaseTransactionBuilder } from "./transaction-builder"
+import { BitcoinInterface } from "../bitcoin-interface"
+import { BitcoinConnectionInfo } from "../type"
+
+export class BitcoinTransactionBuilder extends BaseTransactionBuilder {
+  btcInterface: BitcoinInterface
+  constructor(
+    connectionInfo: BitcoinConnectionInfo,
+    networkName: string,
+    network = bitcoin.networks.bitcoin,
+  ) {
+    super({
+      network,
+      testnet: networkName?.includes("_testnet"),
+      dustLimit: 1000,
+    })
+    this.btcInterface = new BitcoinInterface(connectionInfo, networkName)
+  }
+
+  async _getUtxo(userAddress: string) {
+    let utxos = await this.btcInterface.getUtxo(userAddress)
+    return utxos.map((tx) => ({
+      hash: tx.txId as string,
+      value: +tx.value,
+      index: +tx.index,
+    }))
+  }
+
+  async _getFeeRate(speed: "normal" | "slow" | "fast" = "normal") {
+    return this.btcInterface.getFeeRate(speed)
+  }
+
+  async _getTransactionHex(transactionId: string): Promise<string> {
+    return this.btcInterface.getRawTransaction(transactionId)
+  }
+
+  async sendTx(txHex: string): Promise<string> {
+    let txId = await (
+      this.btcInterface.rpcProvider || this.btcInterface.apiProvider
+    ).sendRawTransaction(txHex)
+    return txId
+  }
+}

package/src/transaction-builder/index.ts

@@ -1,3 +1,3 @@
-export * from "./bitcoin-transaction-builder"
-export * from "./ordinal-transaction-builder"
-export * from "./transaction-builder"
+export * from "./bitcoin-transaction-builder"
+export * from "./ordinal-transaction-builder"
+export * from "./transaction-builder"