@teleportdao/bitcoin 1.6.0 → 1.7.0

package/src/sign/index.ts

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

package/src/sign/sign-transaction.ts

@@ -1,8 +1,9 @@
 import { Psbt, crypto, Network } from "bitcoinjs-lib"
 // import BIP32Factory from "bip32"
 import ecc from "@bitcoinerlab/secp256k1"
-import * as bitcoinEcPair from "bitcoinjs-ecpair"
-const ECPair = bitcoinEcPair.ECPair
+import ECPairFactory from "ecpair"
+
+const ECPair = ECPairFactory(ecc)
 
 function tapTweakHash(pubKey: Buffer, h?: Buffer) {
   return crypto.taggedHash("TapTweak", Buffer.concat(h ? [pubKey, h] : [pubKey]))
@@ -10,14 +11,14 @@ function tapTweakHash(pubKey: Buffer, h?: Buffer) {
 
 function tweakSigner(
   privateKey: Buffer,
+  network: Network,
   opts = {} as {
     [key: string]: Buffer
   },
-  network: Network,
 ) {
   let newPrv = privateKey
   let keyPair = ECPair.fromPrivateKey(privateKey, {
-    network: network,
+    network,
     compressed: true,
   })
 
@@ -36,12 +37,13 @@ function tweakSigner(
   }
 
   return ECPair.fromPrivateKey(Buffer.from(tweakedPrivateKey), {
-    network: network,
+    network,
   })
 }
 
 class BitcoinLikeSignTransaction {
   network: Network
+
   constructor(network: Network) {
     this.network = network
   }
@@ -49,8 +51,11 @@ class BitcoinLikeSignTransaction {
   async signPsbt(
     unsignedPsbt: {
       unsignedTransaction: string
+      inputsToSign?: number[]
     },
     privateKey: Buffer,
+    sighashTypes?: any[],
+    usingTweakSignerIfNeeded = true,
   ) {
     const { network } = this
     const keyPair = ECPair.fromPrivateKey(privateKey, {
@@ -64,12 +69,18 @@ class BitcoinLikeSignTransaction {
     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 (type === "nonstandard") {
-        let a = tweakSigner(privateKey, undefined, this.network)
-        await psbt.signInputAsync(i, a)
+
+      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)
+        await psbt.signInputAsync(i, keyPair, sighashTypes)
       }
     }
 

package/src/teleswap-wallet.ts

@@ -0,0 +1,155 @@
+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: number,
+    percentageFee: number,
+    signer: SignerInfo,
+    lockerAddress: string,
+    exchange?: {
+      outputToken: string
+      outputAmount: string
+      deadline: string
+      isFixedToken?: boolean
+    },
+    {
+      chainId = 137, // 80001
+      appId = exchange ? 1 : 0,
+    } = {},
+    fullAmount = false,
+    staticExtendedUtxo?: ExtendedUtxo[],
+    staticFeeRate?: number,
+    changeAddress?: string,
+  ) {
+    const dataHex = generateWrapOpReturn({
+      chainId,
+      appId,
+      recipientAddress,
+      percentageFee,
+      speed: false,
+      isExchange: !!exchange,
+      outputAmount: exchange?.outputAmount,
+      outputToken: exchange?.outputToken,
+      deadline: exchange?.deadline,
+      isFixedToken: exchange?.isFixedToken || false,
+    })
+    let extendedUtxo = staticExtendedUtxo || (await this.getExtendedUtxo(signer))
+    let feeRate = staticFeeRate || (await this.transactionBuilder._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: number,
+    percentageFee: number,
+    lockerAddress: string,
+    exchange?: {
+      outputToken: string
+      outputAmount: string
+      deadline: string
+      isFixedToken?: boolean
+    },
+    {
+      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,
+      percentageFee,
+      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,26 +1,9 @@
-import BaseTransactionBuilder from "./transaction-builder"
+import { BaseTransactionBuilder } from "./transaction-builder"
 import { BitcoinInterface } from "../bitcoin-interface"
 import * as bitcoin from "bitcoinjs-lib"
+import { BitcoinConnectionInfo } from "../type"
 
-export type BitcoinConnectionInfo = {
-  rpc?: {
-    enabled?: boolean
-    url: string
-    headers?: {
-      [key: string]: string
-    }
-    auth?: {
-      username: string
-      password: string
-    }
-  }
-  api: {
-    enabled?: boolean
-    token?: string
-    provider: string
-  }
-}
-class BitcoinTransactionBuilder extends BaseTransactionBuilder {
+export class BitcoinTransactionBuilder extends BaseTransactionBuilder {
   btcInterface: BitcoinInterface
   constructor(
     connectionInfo: BitcoinConnectionInfo,
@@ -36,7 +19,7 @@ class BitcoinTransactionBuilder extends BaseTransactionBuilder {
   }
 
   async _getUtxo(userAddress: string) {
-    let utxos = await this.btcInterface.getAddressesUtxo([userAddress])
+    let utxos = await this.btcInterface.getUtxo(userAddress)
     return utxos.map((tx) => ({
       hash: tx.txId as string,
       value: +tx.value,
@@ -49,13 +32,13 @@ class BitcoinTransactionBuilder extends BaseTransactionBuilder {
   }
 
   async _getTransactionHex(transactionId: string): Promise<string> {
-    return this.btcInterface.provider.getRawTransaction(transactionId)
+    return this.btcInterface.getRawTransaction(transactionId)
   }
 
   async sendTx(txHex: string): Promise<string> {
-    let txId = await this.btcInterface.provider.sendRawTransaction(txHex)
+    let txId = await (
+      this.btcInterface.rpcProvider || this.btcInterface.apiProvider
+    ).sendRawTransaction(txHex)
     return txId
   }
 }
-
-export default BitcoinTransactionBuilder

package/src/transaction-builder/index.ts

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

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

@@ -0,0 +1,147 @@
+import { ExtendedUtxo, Target, componentBytes } from "../"
+import * as bitcoin from "bitcoinjs-lib"
+import { LEAF_VERSION_TAPSCRIPT } from "bitcoinjs-lib/src/payments/bip341"
+import { BitcoinTransactionBuilder } from "./bitcoin-transaction-builder"
+import { getOrdinalScript, toXOnly } from "../helper/ordinal-helper"
+
+export class OrdinalTransactionBuilder extends BitcoinTransactionBuilder {
+  async createNftPsbt({
+    extendedUtxo,
+    nftExtendedUtxo,
+    receiverAddress,
+    feeRate,
+    changeAddress,
+    otherTargets,
+  }: {
+    nftExtendedUtxo: ExtendedUtxo
+    extendedUtxo: ExtendedUtxo[]
+    feeRate: number
+    changeAddress: string
+    receiverAddress: string
+    otherTargets?: Target[]
+  }) {
+    let targets: Target[] = [
+      {
+        address: receiverAddress,
+        value: nftExtendedUtxo.value,
+      },
+    ]
+
+    if (otherTargets) targets.push(...otherTargets)
+
+    if (!changeAddress && targets.length === 0) throw new Error("no target")
+    let changeObject = {
+      address: changeAddress,
+    }
+    let { inputs, outputs, change, fee } = await this.filterAndConvertTxDataToStandardFormat({
+      extendedUtxo: [nftExtendedUtxo, ...extendedUtxo],
+      targets,
+      changeObject,
+      feeRate,
+      selectType: "inOrder",
+    })
+
+    let unsignedTx = this.createUnsignedTransaction({
+      inputs,
+      outputs,
+      change,
+      fee,
+      feeRate,
+    })
+
+    return unsignedTx
+  }
+
+  createOrdinalAddress(
+    file: {
+      buffer: Buffer
+      type: string
+    },
+    publicKey: Buffer,
+  ) {
+    const internalPublicKey = toXOnly(publicKey).toString("hex")
+    let leafScript = getOrdinalScript(file, internalPublicKey)
+
+    const scriptTree = {
+      output: leafScript,
+    }
+    const redeem = {
+      output: leafScript,
+      redeemVersion: LEAF_VERSION_TAPSCRIPT,
+    }
+
+    const p2trTapOrdinalScript = bitcoin.payments.p2tr({
+      internalPubkey: Buffer.from(internalPublicKey, "hex"),
+      scriptTree,
+      network: this.network,
+      redeem,
+    })
+    let ordinalAddress = p2trTapOrdinalScript.address!
+    const controlBlock = p2trTapOrdinalScript.witness![p2trTapOrdinalScript.witness!.length - 1]
+    return {
+      ordinalAddress,
+      ordinalScript: p2trTapOrdinalScript.output!,
+      redeem,
+      controlBlock,
+    }
+  }
+
+  createInscribeUnsignedTx(
+    ordinalSpendDetails: {
+      ordinalAddress: string
+      ordinalScript: Buffer
+      redeem: {
+        output: Buffer
+        redeemVersion: number
+      }
+      controlBlock: Buffer
+    },
+    inscribeDeposit: {
+      hash: string
+      index: number
+      value: number
+    },
+    receiverAddress: string,
+    ordinalAmount = 600,
+  ) {
+    const psbt = new bitcoin.Psbt({ network: this.network })
+      .addInput({
+        ...inscribeDeposit,
+        witnessUtxo: { value: inscribeDeposit.value, script: ordinalSpendDetails.ordinalScript },
+        // tapInternalKey: toXOnly(node.publicKey),
+        // tapMerkleRoot: p2trTapOrdinalScript.hash!,
+        tapLeafScript: [
+          {
+            leafVersion: ordinalSpendDetails.redeem.redeemVersion,
+            script: ordinalSpendDetails.redeem.output,
+            controlBlock: ordinalSpendDetails.controlBlock,
+          },
+        ],
+      })
+      .addOutput({
+        value: ordinalAmount,
+        address: receiverAddress,
+      })
+
+    return {
+      unsignedTransaction: psbt.toBase64(),
+      inputs: [inscribeDeposit],
+      outputs: [
+        {
+          value: ordinalAmount,
+          address: receiverAddress,
+        },
+      ],
+      fee: inscribeDeposit.value - ordinalAmount,
+    }
+  }
+
+  //  use with caution. just segwit address
+  getUnsignedPsbtTxId(unsignedPsbt: string): string {
+    //  use with caution
+    let psbt = bitcoin.Psbt.fromBase64(unsignedPsbt, {
+      network: this.network,
+    })
+    return (psbt as any).__CACHE.__TX.getId()
+  }
+}

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

@@ -8,28 +8,48 @@ const coinselectSplit = require("coinselect/split")
 const coinselectAccumulative = require("coinselect/accumulative")
 
 // https://bitcoin.stackexchange.com/questions/84004/how-do-virtual-size-stripped-size-and-raw-size-compare-between-legacy-address-f
-const componentBytes = {
+// export const componentBytes = {
+//   bytePerInput: {
+//     p2pkh: 148,
+//     p2wpkh: 70, // 68
+//     "p2sh-p2wpkh": 91,
+//     p2tr: 60, // actual 58
+//   },
+//   baseTxBytes: 10 + 5, // +5 extra bytes to be sure
+//   bytePerOutput: {
+//     p2pkh: 35, // 34
+//     p2wpkh: 35, // 31
+//     p2sh: 35, // 32
+//     p2tr: 45, // 43
+//     default: 35,
+//   },
+//
+// }
+export const componentBytes = {
   bytePerInput: {
     p2pkh: 148,
-    p2wpkh: 70, // 68
+    p2wpkh: 68, // 68
     "p2sh-p2wpkh": 91,
-    p2tr: 65, // actual 58
+    p2tr: 58, // actual 58
+    default: 100,
   },
-  baseTxBytes: 10 + 5, // +2 extra bytes to be sure
+  baseTxBytes: 10 + 5, // +5 extra bytes to be sure
   bytePerOutput: {
-    p2pkh: 35, // 34
-    p2wpkh: 35, // 31
-    p2sh: 35, // 32
-    p2tr: 45, // 43
+    p2pkh: 34, // 34
+    p2wpkh: 31, // 31
+    p2sh: 32, // 32
+    p2tr: 43, // 43
     default: 35,
+    max: 45,
   },
-  opReturn: {
-    dataLessThan75: 31,
-    dataMoreThan75: 91,
+
+  scriptExtraBytes: {
+    lessThan255: 12,
+    moreThan255: 15,
   },
 }
 
-const DUST = 1000
+export const DUST = 1000
 
 export type Utxo = {
   hash: string
@@ -97,7 +117,23 @@ export type ExtendedUnsignedTransaction = {
   change: TargetAddress | undefined
 }
 
-class BaseBitcoinLikeTransaction {
+function coinSelectInOrder(
+  utxos: { hash: string; index: number; value: number }[],
+  outputs: {
+    address?: string
+    script?: Buffer
+    value: number
+  }[],
+  feeRate: number,
+) {
+  let response = coinselectAccumulative(utxos, outputs, 1)
+  return {
+    ...response,
+    fee: +(+response.fee * feeRate).toFixed(),
+  }
+}
+
+export class BaseTransactionBuilder {
   testnet: boolean
   network: bitcoin.Network
   maximumNumberOfOutputsInTransaction: number
@@ -177,6 +213,52 @@ class BaseBitcoinLikeTransaction {
     return extendedUtxo
   }
 
+  calculateTxSize(
+    inputTypes: string[],
+    outputs: {
+      script?: Buffer
+      address?: string
+      value: number
+    }[],
+    changeAddressType = "default",
+  ) {
+    const inputsSizes = inputTypes.map(
+      (addressType) =>
+        componentBytes.bytePerInput[addressType as keyof typeof componentBytes.bytePerInput],
+    )
+    const outputSizes = outputs.map((outP: any) => {
+      if (outP.address) {
+        let addressType = "default"
+        try {
+          addressType = getAddressType(outP.address, this.network)
+        } catch {
+          addressType = "default"
+        }
+        return componentBytes.bytePerOutput[
+          addressType as keyof typeof componentBytes.bytePerOutput
+        ]
+      }
+
+      if (outP.script) {
+        if (outP.script.byteLength < 255) {
+          return outP.script.byteLength + componentBytes.scriptExtraBytes.lessThan255
+        }
+        return outP.script.byteLength + componentBytes.scriptExtraBytes.moreThan255
+      }
+
+      return componentBytes.bytePerOutput[
+        changeAddressType as keyof typeof componentBytes.bytePerOutput
+      ]
+    })
+
+    const txSize =
+      componentBytes.baseTxBytes +
+      inputsSizes.reduce((a, c) => a + c, 0) +
+      outputSizes.reduce((a, c) => a + c, 0)
+
+    return txSize
+  }
+
   helperHandleInputsAndOutputs({
     targets,
     extendedUtxo,
@@ -194,7 +276,7 @@ class BaseBitcoinLikeTransaction {
       derivationPath?: string
       masterFingerprint?: string
     }
-    selectType?: "normal" | "accumulative" | "full"
+    selectType?: "normal" | "accumulative" | "full" | "inOrder"
   }) {
     const filteredUtxo = extendedUtxo.filter(
       (u) =>
@@ -212,6 +294,9 @@ class BaseBitcoinLikeTransaction {
       case "accumulative":
         selectResponse = coinselectAccumulative(filteredUtxo, targets, Math.round(feeRate))
         break
+      case "inOrder":
+        selectResponse = coinSelectInOrder(filteredUtxo, targets, Math.round(feeRate))
+        break
       case "full":
         if (!(targets[0] as TargetAddress).address) {
           throw new Error()
@@ -222,7 +307,6 @@ class BaseBitcoinLikeTransaction {
           Math.round(feeRate),
         )
         break
-
       default:
         break
     }
@@ -247,49 +331,24 @@ class BaseBitcoinLikeTransaction {
       fee = inputs.reduce((a, b) => a + b.value, 0) - outputs.reduce((a, b) => a + b.value, 0)
     }
 
-    const inputsSizes = inputs.map(
-      (i) =>
-        componentBytes.bytePerInput[
-          i.signerInfo.addressType as keyof typeof componentBytes.bytePerInput
-        ],
-    )
-    const outputSizes = outputs.map((outP) => {
-      if (outP.address) {
-        let addressType = "default"
-        try {
-          addressType = getAddressType(outP.address, this.network)
-        } catch {
-          addressType = "default"
-        }
-        return componentBytes.bytePerOutput[
-          addressType as keyof typeof componentBytes.bytePerOutput
-        ]
-      }
-
-      if (outP.script) {
-        if (outP.script.byteLength < 75) {
-          return componentBytes.opReturn.dataLessThan75
-        }
-        return componentBytes.opReturn.dataMoreThan75
-      }
-
-      let addressType = "default"
-      try {
-        addressType = getAddressType(changeObject?.address || "", this.network)
-      } catch {
-        addressType = "default"
-      }
-
-      return componentBytes.bytePerOutput[addressType as keyof typeof componentBytes.bytePerOutput]
-    })
+    let changeAddressType = "default"
+    try {
+      changeAddressType = getAddressType(changeObject?.address || "", this.network)
+    } catch {
+      changeAddressType = "default"
+    }
 
     const txSize =
-      componentBytes.baseTxBytes +
-      inputsSizes.reduce((a, c) => a + c, 0) +
-      outputSizes.reduce((a, c) => a + c, 0) +
-      componentBytes.bytePerOutput.default
-
-    const txFee = txSize * Math.round(feeRate)
+      this.calculateTxSize(
+        inputs.map((i) => i.signerInfo.addressType),
+        outputs,
+        changeAddressType,
+      ) + componentBytes.bytePerOutput.default
+
+    let txFee = Math.round(txSize * feeRate)
+    if (Math.round(feeRate) === 1) {
+      txFee = Math.round(txFee + txFee * 0.1)
+    }
     if (
       inputs.reduce((a, b) => a + b.value, 0) -
         outputs.filter((o) => o.address || o.script).reduce((a, b) => a + b.value, 0) -
@@ -363,7 +422,7 @@ class BaseBitcoinLikeTransaction {
       derivationPath?: string
       masterFingerprint?: string
     }
-    selectType?: "normal" | "accumulative" | "full"
+    selectType?: "normal" | "accumulative" | "full" | "inOrder"
   }) {
     let {
       inputs: filteredInputs,
@@ -617,7 +676,7 @@ class BaseBitcoinLikeTransaction {
 
     changeAddress?: string | SignerInfo
     fullAmount?: boolean
-    selectType?: "normal" | "accumulative" | "full"
+    selectType?: "normal" | "accumulative" | "full" | "inOrder"
   }) {
     if (!changeAddress && targets.length === 0) throw new Error("no target")
     let changeObject =
@@ -644,5 +703,3 @@ class BaseBitcoinLikeTransaction {
     return unsignedTransaction
   }
 }
-
-export default BaseBitcoinLikeTransaction