@teleportdao/bitcoin 1.6.1 → 1.7.0

package/src/ordinal-wallet.ts

@@ -0,0 +1,738 @@
+import { BitcoinBaseWallet } from "./bitcoin-wallet-base"
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { BitcoinConnectionInfo } from "./type"
+import type { SignerInfo, ChangeTarget, Target, ExtendedUtxo } from "./transaction-builder"
+
+import BigNumber from "bignumber.js"
+import { OrdinalTransactionBuilder } from "./transaction-builder"
+import BitcoinSign from "./sign/sign-transaction"
+//
+import { BitcoinInterfaceOrdinal } from "./bitcoin-interface-ordinal"
+import { bitcoin as bitcoinProviders } from "@teleportdao/providers"
+
+import { generateBrc2OpReturn } from "./helper/brc20-helper"
+import { sleep } from "./utils/tools"
+
+class OrdinalWallet extends BitcoinBaseWallet {
+  unisat: bitcoinProviders.UniSat
+  transactionBuilder: OrdinalTransactionBuilder
+  btcInterface: BitcoinInterfaceOrdinal
+  signer: BitcoinSign
+  constructor(
+    networkName: string,
+    uniSatToken: string,
+    connectionInfo: BitcoinConnectionInfo = {
+      api: {
+        provider: "MempoolSpace",
+      },
+    },
+  ) {
+    super(networkName, connectionInfo)
+    if (!connectionInfo.rpc?.enabled) {
+      throw new Error("rpc is required")
+    }
+    this.transactionBuilder = new OrdinalTransactionBuilder(connectionInfo, networkName)
+    this.signer = new BitcoinSign(this.network)
+    this.btcInterface = new BitcoinInterfaceOrdinal(connectionInfo, networkName, uniSatToken)
+    this.unisat = this.btcInterface.unisat
+  }
+
+  async sendSignedPsbtWithRetry(signedPsbt: string, { numberOfRetry = 5, sleepTime = 5000 } = {}) {
+    let count = 0
+    while (count <= numberOfRetry) {
+      try {
+        let txId = await this.sendSignedPsbt(signedPsbt)
+        return txId
+      } catch (e: any) {
+        console.log(e.message)
+        await sleep(sleepTime + count * 5000)
+        count += 1
+      }
+    }
+    throw new Error("failed to send transaction")
+  }
+
+  static deployBRC20Data(tickName: string, max: number | string, limit: number | string) {
+    let data = {
+      p: "brc-20",
+      op: "deploy",
+      tick: tickName,
+      max: `${max}`,
+      lim: `${limit}`,
+    }
+    return {
+      buffer: Buffer.from(JSON.stringify(data), "utf8"),
+      type: "text/plain",
+      // type: "application/json",
+    }
+  }
+
+  static mintBRC20Data(tickName: string, amount: string | number) {
+    let data = {
+      p: "brc-20",
+      op: "mint",
+      tick: tickName,
+      amt: `${amount}`,
+    }
+    return {
+      buffer: Buffer.from(JSON.stringify(data), "utf8"),
+      type: "text/plain",
+      // type: "application/json",
+    }
+  }
+
+  static transferBRC20Data(tickName: string, amount: string | number) {
+    let data = {
+      p: "brc-20",
+      op: "transfer",
+      tick: tickName,
+      amt: `${amount}`,
+    }
+    return {
+      buffer: Buffer.from(JSON.stringify(data), "utf8"),
+      type: "text/plain",
+      // type: "application/json",
+    }
+  }
+
+  async sendUsingUtxosUnsigned({
+    receivers,
+    speed = "normal",
+    utxo,
+    changeAddress,
+    staticFeeRate,
+  }: {
+    receivers: {
+      address: string
+      value: number
+    }[]
+    changeAddress: string
+    speed?: "normal" | "fast" | "slow"
+    staticFeeRate?: number
+    utxo: ExtendedUtxo[]
+  }) {
+    let extendedUtxo: ExtendedUtxo[] = utxo
+
+    receivers.forEach(({ value }) => {
+      if (value - +value.toFixed(0) !== 0)
+        throw new Error("incorrect amount. amount should be in satoshi")
+    })
+
+    // eslint-disable-next-line no-underscore-dangle
+    let feeRate = staticFeeRate || (await this.transactionBuilder._getFeeRate(speed))
+    let unsignedTx = await this.transactionBuilder.processUnsignedTransaction({
+      extendedUtxo,
+      targets: receivers,
+      changeAddress,
+      feeRate,
+      fullAmount: false,
+    })
+
+    return {
+      ...unsignedTx,
+      possibleTxId: this.transactionBuilder.getUnsignedPsbtTxId(unsignedTx.unsignedTransaction),
+    }
+  }
+
+  async sendUsingUtxos({
+    receivers,
+    speed = "normal",
+    utxo,
+  }: {
+    receivers: {
+      address: string
+      value: number
+    }[]
+    speed?: "normal" | "fast" | "slow"
+    utxo?: ExtendedUtxo[]
+  }) {
+    if (!this.currentAccount || !this.currentAccountType || !this.publicKey || !this.privateKey) {
+      throw new Error("account not initialized")
+    }
+
+    let extendedUtxo: ExtendedUtxo[] = utxo
+      ? utxo.filter((u) => u.signerInfo.address === this.currentAccount!)
+      : await this.getExtendedUtxo({
+          address: this.currentAccount,
+          addressType: this.currentAccountType,
+          publicKey: this.publicKey.toString("hex"),
+        })
+
+    let unsignedTx = await this.sendUsingUtxosUnsigned({
+      receivers,
+      speed,
+      utxo: extendedUtxo,
+      changeAddress: this.bitcoinAddress!,
+    })
+    let signedPsbt = await this.signer.signPsbt(unsignedTx, this.privateKey)
+    let signedTx = this.signer.finalizePsbts([signedPsbt])
+    let txId = await this.transactionBuilder.sendTx(signedTx)
+    const { inputs, outputs, change, fee } = unsignedTx
+    return { txId, inputs, outputs, change, fee }
+  }
+
+  async inscribeOrdinalDepositUnsigned(
+    file: {
+      buffer: Buffer
+      type: string
+    },
+    signer: SignerInfo,
+    extendedUtxo?: ExtendedUtxo[],
+    staticFeeRate?: number,
+  ) {
+    const publicKey = Buffer.from(signer.publicKey, "hex")
+    let transferOrdinal = this.transactionBuilder.createOrdinalAddress(file, publicKey)
+    const leafScript = transferOrdinal.redeem.output
+    const { ordinalAddress } = transferOrdinal
+
+    let feeRate = staticFeeRate || (await this.btcInterface.getFeeRate("normal"))
+    let fee = +(((400 + leafScript.length) / 4) * feeRate * 1.5).toFixed(0)
+    let ordinalAmount = 600
+
+    let utxo1: ExtendedUtxo[] =
+      extendedUtxo || (await this.btcInterface.getBTCUtxo(signer.address, signer))
+
+    let inscribeDepositUnsignedInfo = await this.sendUsingUtxosUnsigned({
+      receivers: [
+        {
+          address: ordinalAddress,
+          value: ordinalAmount + fee,
+        },
+      ],
+      utxo: utxo1,
+      changeAddress: signer.address,
+    })
+
+    return {
+      inscribeDepositUnsignedInfo,
+      transferOrdinal,
+    }
+  }
+
+  async inscribeOrdinalUnsigned(
+    file: {
+      buffer: Buffer
+      type: string
+    },
+    signer: SignerInfo,
+    extendedUtxo?: ExtendedUtxo[],
+    staticFeeRate?: number,
+  ) {
+    const { inscribeDepositUnsignedInfo, transferOrdinal } =
+      await this.inscribeOrdinalDepositUnsigned(file, signer, extendedUtxo, staticFeeRate)
+    const { ordinalAddress } = transferOrdinal
+    let ordinalAmount = 600
+    let inscribeDeposit: {
+      hash: string
+      value: number
+      index: number
+    } = {
+      hash: inscribeDepositUnsignedInfo.possibleTxId,
+      value: inscribeDepositUnsignedInfo.outputs[0].value,
+      index: 0,
+    }
+    let inscribeUnsignedInfo = this.transactionBuilder.createInscribeUnsignedTx(
+      transferOrdinal,
+      inscribeDeposit,
+      this.bitcoinAddress!,
+      ordinalAmount,
+    )
+    return {
+      inscribeDepositUnsignedInfo: {
+        ...inscribeDepositUnsignedInfo,
+        possibleTxId: this.transactionBuilder.getUnsignedPsbtTxId(
+          inscribeDepositUnsignedInfo.unsignedTransaction,
+        ),
+      },
+      inscribeUnsignedInfo: {
+        ...inscribeUnsignedInfo,
+        possibleTxId: this.transactionBuilder.getUnsignedPsbtTxId(
+          inscribeUnsignedInfo.unsignedTransaction,
+        ),
+      },
+      inscribeAddress: ordinalAddress,
+    }
+  }
+
+  async inscribeOrdinal(
+    file: {
+      buffer: Buffer
+      type: string
+    },
+    extendedUtxo?: ExtendedUtxo[],
+    staticFeeRate?: number,
+  ) {
+    if (!this.currentAccount || !this.currentAccountType || !this.publicKey || !this.privateKey) {
+      throw new Error("account not initialized")
+    }
+
+    const { inscribeDepositUnsignedInfo, transferOrdinal } =
+      await this.inscribeOrdinalDepositUnsigned(file, this.signerInfo!, extendedUtxo, staticFeeRate)
+
+    let ordinalUtxo = await this.btcInterface.getBTCUtxo(
+      transferOrdinal.ordinalAddress,
+      this.signerInfo!,
+    )
+
+    let inscribeDeposit: {
+      inputs: {
+        hash: string
+        value: number
+        index: number
+        signerInfo: SignerInfo
+      }[]
+      hash: string
+      value: number
+      index: number
+      change?: ChangeTarget
+      changeIndex?: number
+    }
+
+    if (ordinalUtxo.length > 1) {
+      throw new Error("multiple deposit found for this ordinal address")
+    }
+
+    if (
+      ordinalUtxo.length === 0 ||
+      ordinalUtxo[0].value <
+        inscribeDepositUnsignedInfo.outputs[0].value -
+          inscribeDepositUnsignedInfo.outputs[0].value * 0.15
+    ) {
+      const signedPsbt1 = await this.signer.signPsbt(inscribeDepositUnsignedInfo, this.privateKey!)
+      console.log("inscribe deposit tx ...")
+      const inscribeDepositTxId = await this.sendSignedPsbt(signedPsbt1)
+      console.log(`inscribe deposit txId : ${inscribeDepositTxId}`)
+
+      inscribeDeposit = {
+        hash: inscribeDepositTxId,
+        value: inscribeDepositUnsignedInfo.outputs[0].value,
+        index: 0,
+        inputs: inscribeDepositUnsignedInfo.inputs,
+        change: inscribeDepositUnsignedInfo.change,
+        changeIndex: inscribeDepositUnsignedInfo.change
+          ? inscribeDepositUnsignedInfo.outputs.length
+          : undefined,
+      }
+    } else {
+      inscribeDeposit = {
+        hash: ordinalUtxo[0].hash,
+        value: ordinalUtxo[0].value,
+        index: ordinalUtxo[0].index,
+        inputs: [],
+      }
+      console.log("no need to deposit", inscribeDeposit)
+    }
+
+    const ordinalAmount = 600
+    let inscribeUnsignedInfo = this.transactionBuilder.createInscribeUnsignedTx(
+      transferOrdinal,
+      inscribeDeposit,
+      this.bitcoinAddress!,
+      ordinalAmount,
+    )
+
+    const signedPsbt2 = await this.signer.signPsbt(
+      inscribeUnsignedInfo,
+      this.privateKey!,
+      undefined,
+      false,
+    )
+
+    console.log("inscribeTxId ...")
+    await sleep(10 * 1000)
+    let inscribeTxId = await this.sendSignedPsbtWithRetry(signedPsbt2)
+    console.log("inscribeTxId", inscribeTxId)
+    return {
+      inscribeTx: { hash: inscribeTxId, index: 0, value: ordinalAmount },
+      inscribeDepositTx: inscribeDeposit,
+      inscribeAddress: transferOrdinal.ordinalAddress,
+    }
+  }
+
+  async deployBrc20(
+    brc: { tick: string; max: number; limit: number },
+    extendedUtxo?: ExtendedUtxo[],
+    staticFeeRate?: number,
+  ) {
+    let file = OrdinalWallet.deployBRC20Data(brc.tick, brc.max, brc.limit)
+    return this.inscribeOrdinal(file, extendedUtxo, staticFeeRate)
+  }
+
+  async mintBrc20(
+    brc: { tick: string; amount: number | string },
+    extendedUtxo?: ExtendedUtxo[],
+    staticFeeRate?: number,
+  ) {
+    let file = OrdinalWallet.mintBRC20Data(brc.tick, brc.amount)
+    return this.inscribeOrdinal(file, extendedUtxo, staticFeeRate)
+  }
+
+  async inscribeBrc20Unsigned(
+    brc: { tick: string; amount: number | string },
+    signer: SignerInfo,
+    extendedUtxo?: ExtendedUtxo[],
+    staticFeeRate?: number,
+  ) {
+    let file = OrdinalWallet.transferBRC20Data(brc.tick, brc.amount)
+    return this.inscribeOrdinalUnsigned(file, signer, extendedUtxo, staticFeeRate)
+  }
+
+  async inscribeBrc20(
+    brc: { tick: string; amount: number | string },
+    extendedUtxo?: ExtendedUtxo[],
+    staticFeeRate?: number,
+  ) {
+    let file = OrdinalWallet.transferBRC20Data(brc.tick, brc.amount)
+    return this.inscribeOrdinal(file, extendedUtxo, staticFeeRate)
+  }
+
+  async transferBrc20Unsigned(
+    receiver: string,
+    brcInscribeUtxo: {
+      hash: string
+      value: number
+      index: number
+    },
+    signer: SignerInfo,
+    extendedUtxo?: ExtendedUtxo[],
+    staticFeeRate?: number,
+    otherTargets?: Target[],
+  ) {
+    let utxo = extendedUtxo || (await this.btcInterface.getBTCUtxo(signer.address, signer))
+    let feeRate = staticFeeRate || (await this.btcInterface.getFeeRate("normal"))
+    let unsignedTx = await this.transactionBuilder.createNftPsbt({
+      extendedUtxo: utxo,
+      nftExtendedUtxo: {
+        hash: brcInscribeUtxo.hash,
+        index: 0,
+        value: brcInscribeUtxo.value,
+        signerInfo: signer,
+      },
+      feeRate,
+      receiverAddress: receiver,
+      changeAddress: signer.address,
+      otherTargets,
+    })
+    return {
+      ...unsignedTx,
+      possibleTxId: this.transactionBuilder.getUnsignedPsbtTxId(unsignedTx.unsignedTransaction),
+    }
+  }
+
+  async transferBrc20(
+    receiver: string,
+    brcInscribeUtxo: {
+      hash: string
+      value: number
+      index: number
+    },
+    extendedUtxo: ExtendedUtxo[],
+    staticFeeRate?: number,
+    otherTargets?: Target[],
+  ) {
+    if (!this.currentAccount || !this.currentAccountType || !this.publicKey || !this.privateKey) {
+      throw new Error("account not initialized")
+    }
+    let feeRate = staticFeeRate || (await this.btcInterface.getFeeRate("normal"))
+    let unsignedTx = await this.transactionBuilder.createNftPsbt({
+      extendedUtxo,
+      nftExtendedUtxo: {
+        hash: brcInscribeUtxo.hash,
+        index: 0,
+        value: brcInscribeUtxo.value,
+        signerInfo: this.signerInfo!,
+      },
+      feeRate,
+      receiverAddress: receiver,
+      changeAddress: this.bitcoinAddress!,
+      otherTargets,
+    })
+
+    let signedTx = await this.signer.signPsbt(unsignedTx, this.privateKey!)
+    let finalTransferTxId = await this.sendSignedPsbtWithRetry(signedTx)
+    return {
+      hash: finalTransferTxId,
+      index: 0,
+      value: brcInscribeUtxo.value,
+      inputs: unsignedTx.inputs,
+      change: unsignedTx.change,
+      changeIndex: unsignedTx.change ? unsignedTx.outputs.length : undefined,
+    }
+  }
+
+  async inscribeAndTransferBrc20Unsigned(
+    receiver: string,
+    brc: { tick: string; amount: number | string },
+    signer: SignerInfo,
+    otherTargets?: Target[],
+    extendedUtxo?: ExtendedUtxo[],
+    staticFeeRate?: number,
+  ) {
+    // check all fee before process transaction
+    let brc20Balance = await this.unisat.getBrc20AddressBalanceForTicker(signer.address, brc.tick)
+
+    if (BigNumber(brc20Balance.transferableBalance).gte(brc.amount)) {
+      let transferrableInscription = brc20Balance.transferableInscriptions.find(
+        (insc) => insc.data.tick === brc.tick && BigNumber(insc.data.amt).isEqualTo(brc.amount),
+      )
+
+      console.log("transferrableInscription", transferrableInscription)
+    }
+
+    if (BigNumber(brc20Balance.availableBalanceSafe).isLessThan(brc.amount)) {
+      throw new Error("insufficient balance")
+    }
+
+    let feeRate = staticFeeRate || (await this.btcInterface.getFeeRate("normal"))
+
+    let utxo1: ExtendedUtxo[] =
+      extendedUtxo || (await this.btcInterface.getBTCUtxo(signer.address, signer))
+    let utxo2: ExtendedUtxo[] = []
+    const { inscribeAddress, inscribeDepositUnsignedInfo, inscribeUnsignedInfo } =
+      await this.inscribeBrc20Unsigned(brc, signer, utxo1, feeRate)
+
+    utxo2 = utxo1.filter(
+      (u) =>
+        inscribeDepositUnsignedInfo.inputs.findIndex(
+          (i) => i.hash === u.hash && i.index === u.index,
+        ) === -1,
+    )
+
+    if (inscribeDepositUnsignedInfo.change) {
+      utxo2.push({
+        hash: inscribeDepositUnsignedInfo.possibleTxId,
+        index: inscribeDepositUnsignedInfo.outputs.length,
+        value: inscribeDepositUnsignedInfo.change.value,
+        signerInfo: signer,
+      })
+    }
+    let transferTxUnsignedInfo = await this.transferBrc20Unsigned(
+      receiver,
+      {
+        hash: inscribeUnsignedInfo.possibleTxId,
+        value: inscribeUnsignedInfo.outputs[0].value,
+        index: 0,
+      },
+      signer,
+      utxo2,
+      feeRate,
+      otherTargets,
+    )
+    return {
+      inscribeDepositUnsignedInfo,
+      inscribeUnsignedInfo,
+      transferTxUnsignedInfo,
+      inscribeAddress,
+    }
+  }
+
+  async inscribeAndTransferBrc20(
+    receiver: string,
+    brc: { tick: string; amount: number | string },
+    otherTargets?: Target[],
+    extendedUtxo?: ExtendedUtxo[],
+    staticFeeRate?: number,
+  ) {
+    // check all fee before process transaction
+    let brc20Balance = await this.unisat.getBrc20AddressBalanceForTicker(
+      this.bitcoinAddress!,
+      brc.tick,
+    )
+
+    if (BigNumber(brc20Balance.transferableBalance).gte(brc.amount)) {
+      let transferrableInscription = brc20Balance.transferableInscriptions.find(
+        (insc) => insc.data.tick === brc.tick && BigNumber(insc.data.amt).isEqualTo(brc.amount),
+      )
+      console.log("transferrableInscription", transferrableInscription)
+
+      if (transferrableInscription) {
+        let ins = await this.btcInterface.unisat.getInscriptionInfo(
+          transferrableInscription.inscriptionId,
+        )
+
+        if (ins) {
+          let transferTx = await this.transferBrc20(
+            receiver,
+            {
+              hash: ins.utxo.txid!,
+              index: ins.utxo.vout!,
+              value: ins.utxo.satoshi!,
+            },
+            extendedUtxo ||
+              (await this.btcInterface.getBTCUtxo(this.bitcoinAddress!, this.signerInfo!)),
+            staticFeeRate || (await this.btcInterface.getFeeRate("normal")),
+            otherTargets,
+          )
+          return {
+            transferTx,
+          }
+        }
+      }
+    }
+
+    if (BigNumber(brc20Balance.availableBalanceSafe).isLessThan(brc.amount)) {
+      throw new Error(`insufficient balance ${brc20Balance.availableBalanceSafe} ${brc.amount}`)
+    }
+
+    let feeRate = staticFeeRate || (await this.btcInterface.getFeeRate("normal"))
+
+    let utxo1: ExtendedUtxo[] =
+      extendedUtxo || (await this.btcInterface.getBTCUtxo(this.bitcoinAddress!, this.signerInfo!))
+    let utxo2: ExtendedUtxo[] = []
+    const { inscribeAddress, inscribeDepositTx, inscribeTx } = await this.inscribeBrc20(
+      brc,
+      utxo1,
+      feeRate,
+    )
+
+    utxo2 = utxo1.filter(
+      (u) =>
+        inscribeDepositTx.inputs.findIndex((i) => i.hash === u.hash && i.index === u.index) === -1,
+    )
+
+    if (inscribeDepositTx.change) {
+      utxo2.push({
+        hash: inscribeDepositTx.hash,
+        index: inscribeDepositTx.changeIndex!,
+        value: inscribeDepositTx.change.value,
+        signerInfo: this.signerInfo!,
+      })
+    }
+    await sleep(10 * 1000)
+    let transferTx = await this.transferBrc20(receiver, inscribeTx, utxo2, feeRate, otherTargets)
+    return {
+      inscribeTx,
+      inscribeAddress,
+      inscribeDepositTx,
+      transferTx,
+    }
+  }
+
+  async wrapBrc20Unsigned(
+    recipientAddress: string,
+    brc: { tick: string; amount: number | string },
+    brc20TokenId: number,
+    signer: SignerInfo,
+    lockerAddress: string,
+    exchange?: {
+      outputToken: string
+      outputAmount: string
+    },
+    extendedUtxo?: ExtendedUtxo[],
+    staticFeeRate?: number,
+    {
+      chainId = 137, // 80001
+      appId = exchange ? 1 : 0,
+    } = {},
+  ) {
+    const isExchange = !!exchange
+    let dataHex = generateBrc2OpReturn({
+      chainId,
+      appId,
+      brc20TokenId,
+      inputAmount: BigNumber(brc.amount).multipliedBy(1e18).toFixed(0),
+      recipientAddress,
+      isExchange,
+      outputToken: exchange?.outputToken,
+      outputAmount: exchange?.outputAmount,
+    })
+    let opTarget = this.transactionBuilder.getOpReturnTarget(dataHex)
+    return this.inscribeAndTransferBrc20Unsigned(
+      lockerAddress,
+      brc,
+      signer,
+      [opTarget],
+      extendedUtxo,
+      staticFeeRate,
+    )
+  }
+
+  async wrapBrc20OnlyTransferUnsigned(
+    recipientAddress: string,
+    brcInscribeTx: {
+      hash: string
+      value: number
+      index: number
+    },
+    brc: { tick: string; amount: number | string },
+    brc20TokenId: number,
+    signer: SignerInfo,
+    lockerAddress: string,
+    exchange?: {
+      outputToken: string
+      outputAmount: string
+    },
+    extendedUtxo?: ExtendedUtxo[],
+    staticFeeRate?: number,
+    {
+      chainId = 137, // 80001
+      appId = exchange ? 1 : 0,
+    } = {},
+  ) {
+    let utxo: ExtendedUtxo[] =
+      extendedUtxo || (await this.btcInterface.getBTCUtxo(signer.address, signer))
+
+    const isExchange = !!exchange
+    let dataHex = generateBrc2OpReturn({
+      chainId,
+      appId,
+      brc20TokenId,
+      inputAmount: BigNumber(brc.amount).multipliedBy(1e18).toFixed(0),
+      recipientAddress,
+      isExchange,
+      outputToken: exchange?.outputToken,
+      outputAmount: exchange?.outputAmount,
+    })
+    let opTarget = this.transactionBuilder.getOpReturnTarget(dataHex)
+    let feeRate = staticFeeRate || (await this.btcInterface.getFeeRate("normal"))
+    let transferTxUnsignedInfo = await this.transferBrc20Unsigned(
+      lockerAddress,
+      brcInscribeTx,
+      signer,
+      utxo,
+      feeRate,
+      [opTarget],
+    )
+    return transferTxUnsignedInfo
+  }
+
+  async wrapBrc20(
+    recipientAddress: string,
+    brc: { tick: string; amount: number | string },
+    brc20TokenId: number,
+    lockerAddress: string,
+    exchange?: {
+      outputToken: string
+      outputAmount: string
+    },
+    extendedUtxo?: ExtendedUtxo[],
+    staticFeeRate?: number,
+    {
+      chainId = 137, // 80001
+      appId = exchange ? 1 : 0,
+    } = {},
+  ) {
+    const isExchange = !!exchange
+
+    let dataHex = generateBrc2OpReturn({
+      chainId,
+      appId,
+      brc20TokenId,
+      inputAmount: BigNumber(brc.amount).multipliedBy(1e18).toFixed(0),
+      recipientAddress,
+      isExchange,
+      outputToken: exchange?.outputToken,
+      outputAmount: exchange?.outputAmount,
+    })
+    let opTarget = this.transactionBuilder.getOpReturnTarget(dataHex)
+    return this.inscribeAndTransferBrc20(
+      lockerAddress,
+      brc,
+      [opTarget],
+      extendedUtxo,
+      staticFeeRate,
+    )
+  }
+}
+
+export default OrdinalWallet