@teleportdao/bitcoin 1.6.0 → 1.7.0

package/src/{bitcoin-base.ts → bitcoin-wallet-base.ts}

@@ -1,6 +1,5 @@
-import TransactionBuilder, {
-  BitcoinConnectionInfo,
-} from "./transaction-builder/bitcoin-transaction-builder"
+import { BitcoinTransactionBuilder } from "./transaction-builder"
+import type { BitcoinConnectionInfo } from "./type"
 
 import type { ExtendedUtxo, SignerInfo, Target } from "./transaction-builder/transaction-builder"
 import BitcoinSign from "./sign/sign-transaction"
@@ -9,7 +8,7 @@ import * as bip39 from "bip39"
 import { hdWalletPath } from "@teleportdao/configs"
 import { getPubKeyFromPrivateKeyHex } from "./bitcoin-utils"
 import networks from "./utils/networks"
-import { Network, Payment, Psbt } from "bitcoinjs-lib"
+import { Network, Payment } from "bitcoinjs-lib"
 import { BitcoinInterface } from "./bitcoin-interface"
 
 import BIP32Factory from "bip32"
@@ -17,7 +16,7 @@ import ecc from "@bitcoinerlab/secp256k1"
 
 const bip32 = BIP32Factory(ecc)
 
-class BitcoinBase {
+export class BitcoinBaseWallet {
   network: Network
   hdWalletPath: {
     p2pkh: string
@@ -28,7 +27,7 @@ class BitcoinBase {
     "p2sh-p2wsh": string
     p2tr: string
   }
-  transactionBuilder: TransactionBuilder
+  transactionBuilder: BitcoinTransactionBuilder
   btcInterface: BitcoinInterface
   signer: BitcoinSign
   currentAccount?: string
@@ -42,7 +41,6 @@ class BitcoinBase {
     networkName: string,
     connectionInfo: BitcoinConnectionInfo = {
       api: {
-        enabled: true,
         provider: "BlockStream",
       },
     },
@@ -50,7 +48,11 @@ class BitcoinBase {
     this.network = networks[networkName]
     this.hdWalletPath = hdWalletPath.bitcoin
 
-    this.transactionBuilder = new TransactionBuilder(connectionInfo, networkName, this.network)
+    this.transactionBuilder = new BitcoinTransactionBuilder(
+      connectionInfo,
+      networkName,
+      this.network,
+    )
     this.btcInterface = this.transactionBuilder.btcInterface
 
     this.signer = new BitcoinSign(this.network)
@@ -126,6 +128,8 @@ class BitcoinBase {
 
   // todo : not completed
   setMultiSigAccount(accountType = "p2sh") {
+    throw new Error("not supported yet")
+
     /* eslint-disable no-unreachable */
     // todo : not completed
     switch (accountType) {
@@ -150,10 +154,6 @@ class BitcoinBase {
     this.publicKey = publicKey
   }
 
-  setAccountPublicKey(publicKeyHex: string) {
-    this.publicKey = Buffer.from(publicKeyHex, "hex")
-  }
-
   setAccountPrivateKeyByMnemonic({
     mnemonic,
     mnemonicPassword = "",
@@ -182,6 +182,10 @@ class BitcoinBase {
     return this.setAccount(addressType)
   }
 
+  setAccountPublicKey(publicKeyHex: string) {
+    this.publicKey = Buffer.from(publicKeyHex, "hex")
+  }
+
   setAccount(accountType = "p2pkh") {
     if (!this.publicKey) {
       throw new Error("account not initialized")
@@ -197,6 +201,8 @@ class BitcoinBase {
     return addressObj.address
   }
 
+  //
+
   async getExtendedUtxo(input: SignerInfo) {
     return this.transactionBuilder.getExtendedUtxo(input)
   }
@@ -266,7 +272,7 @@ class BitcoinBase {
     changeAddress: string,
     staticFeeRate?: number,
   ) {
-    let transaction = await this.btcInterface.getTransaction(txId)
+    let transaction = await this.btcInterface.apiProvider.getTransaction(txId)
 
     let extendedUtxo = transaction.vin.map((vi) => ({
       signerInfo: signerInfos.find((s) => s.address === vi.address)!,
@@ -303,7 +309,7 @@ class BitcoinBase {
       targets,
       feeRate,
       changeAddress: changeIndex >= 0 ? transaction.vout[changeIndex].address : changeAddress,
+      selectType: "inOrder",
     })
   }
 }
-export { BitcoinBase }

package/src/helper/brc20-helper.ts

@@ -0,0 +1,181 @@
+import BigNumber from "bignumber.js"
+import { brc20 } from "@teleportdao/configs"
+
+export type WrapOpReturn = {
+  chainId: number
+  appId: number
+  brc20TokenId: number
+  recipientAddress: string
+  inputAmount: string
+  outputAmount?: string
+  outputToken?: string
+  thirdPartyId?: number
+}
+export type WrapOpReturnAndType = WrapOpReturn & {
+  requestType: "wrap" | "wrapAndExchange"
+}
+
+const brc20WrapRequests = brc20.requestAppId
+
+export function generateBrc2OpReturn({
+  chainId,
+  appId,
+  brc20TokenId,
+  inputAmount,
+  recipientAddress,
+  thirdPartyId = 0,
+  isExchange = false,
+  outputToken,
+  outputAmount,
+}: WrapOpReturn & {
+  isExchange?: boolean
+}) {
+  let data = ""
+  if (chainId.toString(16).length > 4) throw new Error("chainId should be less than 2 bytes")
+  data += chainId.toString(16).padStart(4, "0") // 2 bytes
+  data += appId.toString(16).padStart(2, "0") // 1 bytes
+  data += brc20TokenId.toString(16).padStart(4, "0") // 2 bytes
+  data += BigNumber(inputAmount).toString(16).padStart(26, "0") // 13 bytes
+  data += recipientAddress.replace("0x", "").toLowerCase().padStart(40, "0") // 20 bytes
+  data += BigNumber(thirdPartyId).toString(16).padStart(2, "0") // 1 bytes
+  if (isExchange) {
+    if (!outputAmount || !outputToken) {
+      throw new Error("outputAmount and outputToken are required for exchange")
+    }
+    data += outputToken.replace("0x", "").toLowerCase().padStart(40, "0") // 20 bytes
+    data += BigNumber(outputAmount).toString(16).padStart(26, "0") // 13 bytes
+  }
+  return data
+}
+
+export function parseBrc20OpReturn(data: string) {
+  let parsedData: any = {}
+  parsedData.chainId = Number(`0x${data.slice(0, 4)}`) // 2 bytes
+  parsedData.appId = Number(`0x${data.slice(4, 6)}`) // 1 bytes
+  parsedData.brc20TokenId = Number(`0x${data.slice(6, 10)}`) // 2 bytes
+  parsedData.inputAmount = new BigNumber(`0x${data.slice(10, 36)}`).toFixed(0) // 11 bytes
+  parsedData.recipientAddress = `0x${data.slice(36, 76)}` // 20 bytes
+  parsedData.thirdPartyId = `0x${data.slice(76, 78)}` // 20 bytes
+  if (data.length === 78) {
+    parsedData.requestType = "wrap"
+    return {
+      status: true,
+      data: parsedData as WrapOpReturnAndType,
+    }
+  }
+  parsedData.outputToken = `0x${data.slice(78, 118)}` // 20 bytes
+  parsedData.outputAmount = new BigNumber(`0x${data.slice(118, 144)}`).toFixed(0) // 20 bytes
+  if (data.length === 144) {
+    parsedData.requestType = "swapAndWrap"
+    return {
+      status: true,
+      data: parsedData as WrapOpReturnAndType,
+    }
+  }
+
+  return {
+    status: false,
+    message: `invalid OP_RETURN data for requestType: 'wrap or exchange'. invalid data length : ${data.length} - valid length : 144 , 78`,
+    code: "INVALID_OP_RETURN",
+  }
+}
+
+function parseBrc20RawRequest(opReturnData: string): {
+  status: boolean
+  data?: WrapOpReturnAndType
+  message?: string
+  code?: string
+} {
+  let data = opReturnData.slice(2, 4) === "4c" ? opReturnData.slice(6) : opReturnData.slice(4)
+  // eslint-disable-next-line no-unused-vars
+  let appIdHex = data.slice(4, 6) // 2 bytes
+  if (!appIdHex) {
+    return {
+      status: false,
+      message: `invalid OP_RETURN data : ${data}`,
+      code: "INVALID_APP_ID",
+    }
+  }
+
+  let appId = Number(`0x${appIdHex}`) // 2 bytes
+
+  //   get type base on appId
+  let requestType = Object.keys(brc20WrapRequests).find(
+    (key) =>
+      appId >= brc20WrapRequests[key as keyof typeof brc20WrapRequests].appIdRange[0] &&
+      appId <= brc20WrapRequests[key as keyof typeof brc20WrapRequests].appIdRange[1],
+  )
+
+  switch (requestType) {
+    case "wrap":
+    case "wrapAndExchange":
+      return parseBrc20OpReturn(data)
+    default:
+      return {
+        status: false,
+        message: `invalid appId : ${appId}`,
+        code: "INVALID_OP_RETURN",
+      }
+  }
+}
+
+export function checkAndParseBrc20Request(
+  vouts: {
+    address?: string
+    script: string
+    value: number
+  }[],
+  address: string,
+): {
+  status: boolean
+  data?: WrapOpReturnAndType
+  dataOutputIndex?: number
+  lockerFeeValue?: number
+  lockerFeeOutputIndex?: number
+  brc20OutputIndex?: number
+  brc20OutputValue?: number
+  message?: string
+  code?: string
+} {
+  let requestOutputIndex = vouts.findIndex((vout_) => vout_.script.startsWith("6a"))
+  if (requestOutputIndex >= 0) {
+    let opReturnData = vouts[requestOutputIndex]?.script
+    if (!opReturnData) {
+      return {
+        status: false,
+        message: "invalid OP_RETURN",
+        code: "INVALID_OP_RETURN",
+      }
+    }
+
+    let brc20Transfer = vouts[0]
+    if (brc20Transfer.address !== address || brc20Transfer.value < 546) {
+      return {
+        status: false,
+        message: "no brc20 transfer output",
+        code: "NO_BRC20_TRANSFER",
+      }
+    }
+
+    let dataResponse = parseBrc20RawRequest(opReturnData)
+    if (dataResponse.status) {
+      let lockerFeeOutputIndex = vouts.findIndex((vout_, i) => vout_.address === address && +i > 0)
+      let lockerFeeValue = lockerFeeOutputIndex >= 0 ? vouts[lockerFeeOutputIndex].value : 0
+      return {
+        status: true,
+        data: dataResponse.data!,
+        dataOutputIndex: requestOutputIndex,
+        lockerFeeValue,
+        lockerFeeOutputIndex,
+        brc20OutputIndex: 0,
+        brc20OutputValue: brc20Transfer.value,
+      }
+    }
+    return dataResponse
+  }
+  return {
+    status: false,
+    message: "transaction outputs should contain OP_RETURN",
+    code: "NO_OP_RETURN",
+  }
+}

package/src/helper/index.ts

@@ -0,0 +1,3 @@
+export * as brc20Helper from "./brc20-helper"
+export * as teleswapHelper from "./teleswap-helper"
+export * as ordinalHelper from "./ordinal-helper"

package/src/helper/ordinal-helper.ts

@@ -0,0 +1,118 @@
+import * as bitcoin from "bitcoinjs-lib"
+import * as ecc from "tiny-secp256k1"
+
+bitcoin.initEccLib(ecc)
+
+// eslint-disable-next-line consistent-return
+export function createAddressObjectByScriptNoType(
+  script: Buffer,
+  network: bitcoin.Network = bitcoin.networks.bitcoin,
+) {
+  let addressObject: bitcoin.payments.Payment
+
+  try {
+    addressObject = bitcoin.payments.p2pkh({
+      output: script,
+      network,
+    })
+    if (addressObject.address) {
+      return {
+        addressObject,
+        addressType: "p2pkh",
+      }
+    }
+  } catch (err) {
+    /* empty */
+  }
+
+  try {
+    addressObject = bitcoin.payments.p2wpkh({
+      output: script,
+      network,
+    })
+    if (addressObject.address) {
+      return {
+        addressObject,
+        addressType: "p2wpkh",
+      }
+    }
+  } catch (err) {
+    /* empty */
+  }
+
+  try {
+    addressObject = bitcoin.payments.p2sh({
+      output: script,
+      network,
+    })
+    if (addressObject.address) {
+      return {
+        addressObject,
+        addressType: "p2sh",
+      }
+    }
+  } catch (err) {
+    /* empty */
+  }
+
+  try {
+    addressObject = bitcoin.payments.p2wsh({
+      output: script,
+      network,
+    })
+    if (addressObject.address) {
+      return {
+        addressObject,
+        addressType: "p2wsh",
+      }
+    }
+  } catch (err) {
+    /* empty */
+  }
+
+  try {
+    addressObject = bitcoin.payments.p2tr({
+      output: script,
+      network,
+    })
+    if (addressObject.address) {
+      return {
+        addressObject,
+        addressType: "p2tr",
+      }
+    }
+  } catch (err) {
+    /* empty */
+  }
+}
+
+export function splitBuffer(buffer: Buffer, partLength: number) {
+  const parts: Buffer[] = []
+  for (let i = 0; i < buffer.length; i += partLength) {
+    const part = buffer.subarray(i, i + partLength)
+    parts.push(part)
+  }
+  return parts
+}
+
+export function getOrdinalScript(
+  file: { buffer: Buffer; type: string },
+  internalPublicKeyHex: string,
+) {
+  let bufferParts = splitBuffer(file.buffer, 520)
+  const splittedFileHex = bufferParts.map((part) => part.toString("hex")).join(" ")
+  const fileTypeHex = Buffer.from(file.type!, "utf8").toString("hex")
+  const ORDINAL_ORD_HEX = Buffer.from("ord", "utf8").toString("hex")
+  const script = `${internalPublicKeyHex} OP_CHECKSIG OP_FALSE OP_IF ${ORDINAL_ORD_HEX} 00000000000000000000 ${fileTypeHex} OP_0 ${splittedFileHex} OP_ENDIF`
+
+  // we add 00000000000000000000 so we can modify INCORRECT OPCODE
+  const leafScript = Buffer.from(
+    bitcoin.script.fromASM(script).toString("hex").replace("0a00000000000000000000", "0101"),
+    "hex",
+  )
+  return leafScript
+}
+
+export function toXOnly(pubKey: Buffer) {
+  return pubKey.length === 32 ? pubKey : pubKey.subarray(1, 33)
+}

package/src/helper/teleswap-helper.ts

@@ -0,0 +1,300 @@
+import { teleswap } from "@teleportdao/configs"
+import BigNumber from "bignumber.js"
+
+type Vin = {
+  address: string
+  value: number
+}
+
+type Vout = {
+  address?: string
+  value: number
+  script: string
+}
+
+export type WrapOpReturn = {
+  chainId: number
+  appId: number
+  recipientAddress: string
+  percentageFee: number
+  speed: boolean
+  //
+  outputToken?: string
+  outputAmount?: string
+  deadline?: string
+  isFixedToken?: boolean
+}
+
+export type UnwrapInfo = {
+  receivers: (Vout & {
+    index: number
+  })[]
+  changes: (Vout & {
+    index: number
+  })[]
+  totalInputValue: number
+  lockerVin: {
+    vinIndex: number
+    address: string
+    value: number
+  }
+}
+
+export type WrapOpReturnWithType = WrapOpReturn & {
+  requestType: "wrap" | "wrapAndSwap"
+}
+
+const wrapOpReturnLength = {
+  chainId: 2,
+  appId: 4,
+  percentageFee: 4,
+  outputAmount: 56,
+  deadline: 8,
+}
+
+export function generateWrapOpReturn({
+  chainId,
+  appId,
+  recipientAddress, // 20 bytes
+  percentageFee, // 2 bytes in percent %
+  speed = false, // 1 byte
+  isExchange = false,
+  outputToken, // 20 bytes
+  outputAmount, // 28 bytes
+  deadline, // 4 bytes
+  isFixedToken = false, // 1 byte
+}: WrapOpReturn & {
+  isExchange?: boolean
+}) {
+  let data = ""
+  if (BigNumber(chainId).toString(16).length > wrapOpReturnLength.chainId) {
+    throw new Error("invalid chainId")
+  }
+  if (BigNumber(appId).toString(16).length > wrapOpReturnLength.appId) {
+    throw new Error("invalid appId")
+  }
+  if (BigNumber(percentageFee).toString(16).length > wrapOpReturnLength.percentageFee) {
+    throw new Error("invalid percentageFee")
+  }
+  data += BigNumber(chainId).toString(16).padStart(2, "0")
+  data += BigNumber(appId).toString(16).padStart(4, "0")
+  data += recipientAddress.replace("0x", "").toLowerCase().padStart(40, "0")
+  data += BigNumber((percentageFee * 100).toFixed(0))
+    .toString(16)
+    .padStart(4, "0")
+  data += speed ? "01" : "00"
+  if (!isExchange) {
+    if (data.length !== 26 * 2) throw new Error("invalid data length")
+    return data
+  }
+  if (!outputToken) {
+    throw new Error("invalid outputToken")
+  }
+  if (
+    !outputAmount ||
+    BigNumber(outputAmount).toString(16).length > wrapOpReturnLength.outputAmount
+  ) {
+    throw new Error("invalid outputAmount")
+  }
+  if (!deadline || BigNumber(deadline).toString(16).length > wrapOpReturnLength.deadline) {
+    throw new Error("invalid deadline")
+  }
+
+  data += outputToken.replace("0x", "").toLowerCase().padStart(40, "0")
+  data += BigNumber(outputAmount).toString(16).padStart(56, "0")
+  data += BigNumber(deadline).toString(16).padStart(8, "0")
+  data += isFixedToken ? "01" : "00"
+  if (data.length !== 79 * 2) throw new Error("invalid data length")
+  return data
+}
+
+export function getBurnTransactionInfo(address: string, vin: Vin[] = [], vouts: Vout[] = []) {
+  let lockerVinIndex = vin.findIndex((vi) => vi.address === address)
+  if (lockerVinIndex >= 0) {
+    let lockerVin = { ...vin[lockerVinIndex], vinIndex: lockerVinIndex }
+    let totalInputValue = vin.reduce((acc, current) => acc + current.value, 0)
+    let receivers: (Vout & {
+      index: number
+    })[] = []
+    let changes: (Vout & {
+      index: number
+    })[] = []
+    vouts.forEach((vout, i) => {
+      let voutWithIndex = {
+        ...vout,
+        index: i,
+      }
+      if (voutWithIndex.address === address) {
+        changes.push(voutWithIndex)
+      } else {
+        receivers.push(voutWithIndex)
+      }
+    })
+    return { receivers, changes, totalInputValue, lockerVin }
+  }
+  return
+}
+
+//
+
+function parseWrapRequest(data: string) {
+  let parsedData: any = {}
+  parsedData.requestType = "wrap"
+  let offset = 0
+  parsedData.chainId = BigNumber(`0x${data.slice(offset, (offset += 2))}`).toNumber() // 1 bytes
+  parsedData.appId = BigNumber(`0x${data.slice(offset, (offset += 4))}`).toNumber() // 2 bytes
+  parsedData.recipientAddress = `0x${data.slice(offset, (offset += 40))}` // 20 bytes
+  parsedData.percentageFee = BigNumber(`0x${data.slice(offset, (offset += 4))}`)
+    .dividedBy(100)
+    .toNumber() // 2 bytes
+  parsedData.speed = data.slice(offset, (offset += 2)) === "01" // 1 byte
+  if (data.length === offset) {
+    return {
+      status: true,
+      data: parsedData as WrapOpReturnWithType,
+    }
+  }
+
+  parsedData.requestType = "swapAndWrap"
+  parsedData.exchangeTokenAddress = `0x${data.slice(offset, (offset += 40))}` // 20 bytes
+  parsedData.outputAmount = new BigNumber(`0x${data.slice(offset, (offset += 56))}`).toFixed(0) // 28 bytes
+  parsedData.deadline = new BigNumber(`0x${data.slice(offset, (offset += 8))}`).toFixed(0) // 4 bytes
+  parsedData.isFixedToken = data.slice(offset, (offset += 2)) === "01" // 1 byte
+  if (data.length === offset) {
+    return {
+      status: true,
+      data: parsedData as WrapOpReturnWithType,
+    }
+  }
+
+  return {
+    status: false,
+    message: `invalid OP_RETURN data for requestType: 'transfer or exchange'. invalid data length : ${data.length} - valid length : ${offset}`,
+    code: "INVALID_OP_RETURN",
+  }
+}
+
+// function parseLendAndBorrowRequest(data: string) {
+//   let parsedData: any = {}
+//   parsedData.requestType = "lend"
+
+//   let offset = 0
+//   parsedData.chainId = BigNumber(`0x${data.slice(offset, (offset += 2))}`) // 1 bytes
+//   parsedData.appId = BigNumber(`0x${data.slice(offset, (offset += 4))}`) // 2 bytes
+//   parsedData.recipientAddress = `0x${data.slice(offset, (offset += 40))}` // 20 bytes
+//   parsedData.percentageFee = BigNumber(`0x${data.slice(offset, (offset += 4))}`) / 100 // 2 bytes
+//   parsedData.mode = BigNumber(`0x${data.slice(offset, (offset += 2))}`) // 1 byte
+//   if (data.length === offset) {
+//     return {
+//       status: true,
+//       data: parsedData,
+//     }
+//   }
+//   parsedData.requestType = "borrow"
+//   parsedData.tokenAddress = `0x${data.slice(offset, (offset += 40))}` // 20 bytes
+//   parsedData.borrowAmount = BigNumber(`0x${data.slice(offset, (offset += 56))}`) // 28 bytes
+//   if (data.length === offset) {
+//     return {
+//       status: true,
+//       data: parsedData,
+//     }
+//   }
+//   return {
+//     status: false,
+//     message: `invalid OP_RETURN data for requestType: 'lend or borrow'. invalid data length : ${data.length} - valid length : ${offset}`,
+//     code: "INVALID_OP_RETURN",
+//   }
+// }
+
+export function parseWrapRawRequest(opReturnData: string) {
+  let data = opReturnData.slice(2, 4) === "4c" ? opReturnData.slice(6) : opReturnData.slice(4)
+  let appIdHex = data.slice(2, 6) // 2 bytes
+  if (!appIdHex) {
+    return {
+      status: false,
+      message: `invalid OP_RETURN data : ${data}`,
+      code: "INVALID_APP_ID",
+    }
+  }
+
+  let appId = BigNumber(`0x${appIdHex}`).toNumber() // 2 bytes
+
+  //   get type base on appId
+  let requestType = Object.keys(teleswap.requestAppId).find(
+    (key) =>
+      appId >= teleswap.requestAppId[key as keyof typeof teleswap.requestAppId].appIdRange[0] &&
+      appId <= teleswap.requestAppId[key as keyof typeof teleswap.requestAppId].appIdRange[1],
+  )
+
+  switch (requestType) {
+    case "wrap":
+    case "wrapAndSwap":
+      return parseWrapRequest(data)
+    default:
+      return {
+        status: false,
+        message: `invalid appId : ${appId}`,
+        code: "INVALID_OP_RETURN",
+      }
+  }
+}
+
+export function checkAndParseWrapRequest(
+  vouts: Vout[],
+  lockerAddress: string,
+  { minTeleporterFeeAmount = 0 } = {},
+) {
+  let requestOutputIndex = vouts.findIndex((vout_) => vout_.script.startsWith("6a"))
+  if (requestOutputIndex >= 0) {
+    let opReturnData = vouts[requestOutputIndex]?.script || null
+    if (!opReturnData) {
+      return {
+        status: false,
+        message: "no data to validate. it should not happen",
+        code: "INVALID_OP_RETURN",
+      }
+    }
+
+    let valueOutputIndex = vouts.findIndex((vout_) => vout_.address === lockerAddress)
+    let value = valueOutputIndex >= 0 ? vouts[valueOutputIndex].value || 0 : 0
+
+    let response = parseWrapRawRequest(opReturnData)
+
+    if (!response.status || !("data" in response) || !response.data) {
+      return response as {
+        status: boolean
+        message: string
+        code: string
+      }
+    }
+
+    const data = response.data
+
+    if (+data.percentageFee > 100) {
+      return {
+        status: false,
+        message: `percentageFee greater than 100 is invalid. percentageFee: ${data.percentageFee}`,
+        code: "INVALID_FEE",
+      }
+    }
+
+    if ((data.percentageFee / 100) * +value <= minTeleporterFeeAmount) {
+      return {
+        status: false,
+        message: `fee amount is less than or equal minimum teleporter fee amount.percentageFee: ${
+          data.percentageFee
+        } - value: ${value} - feeAmount  ${((data.percentageFee / 100) * +value).toFixed(
+          8,
+        )} - minimumFee: ${minTeleporterFeeAmount}`,
+        code: "NOT_ACCEPTED_BY_TELEPORTER",
+      }
+    }
+
+    return { status: response.status, data, value, valueOutputIndex }
+  }
+  return {
+    status: false,
+    message: "transaction outputs must include an OP_RETURN",
+    code: "NO_OP_RETURN",
+  }
+}