@exodus/bitcoin-api 2.12.0 → 2.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/bitcoin-api",
-  "version": "2.12.0",
+  "version": "2.13.0",
   "description": "Exodus bitcoin-api",
   "main": "src/index.js",
   "files": [
@@ -23,14 +23,13 @@
     "@exodus/bip322-js": "^1.1.0-exodus.4",
     "@exodus/bip44-constants": "^195.0.0",
     "@exodus/bitcoin-lib": "2.3.0",
+    "@exodus/bitcoinerlab-secp256k1": "^1.0.5-exodus.1",
     "@exodus/bitcoinjs-lib": "^6.1.5-exodus.1",
     "@exodus/currency": "^2.3.2",
     "@exodus/fetch": "^1.3.0",
     "@exodus/models": "^11.0.0",
-    "@exodus/secp256k1": "4.0.2-exodus.0",
     "@exodus/simple-retry": "0.0.6",
     "@exodus/timer": "^1.0.0",
-    "@noble/secp256k1": "~1.7.1",
     "bech32": "^1.1.3",
     "bip32-path": "^0.4.2",
     "bn.js": "4.12.0",
@@ -58,5 +57,5 @@
     "jest-when": "^3.5.1",
     "safe-buffer": "^5.2.1"
   },
-  "gitHead": "49a0b40b825c556ea08538c5cedf64754dd35369"
+  "gitHead": "9d296fc0875749545bc95b2a976e93739d63553b"
 }

package/src/bitcoinjs-lib/ecc/index.js

@@ -1,3 +1,9 @@
-import { desktopEcc } from './desktop'
+import { initEccLib } from '@exodus/bitcoinjs-lib'
 
-export const eccFactory = () => desktopEcc
+import bitcoinerlab from '@exodus/bitcoinerlab-secp256k1'
+
+export const ecc = bitcoinerlab
+
+initEccLib(ecc)
+
+export const eccFactory = () => ecc

package/src/fee/get-fee-resolver.js

@@ -1,7 +1,13 @@
 import assert from 'minimalistic-assert'
 import { getUtxosData } from './utxo-selector'
 import { findUnconfirmedSentRbfTxs } from '../tx-utils'
-import { getUsableUtxos, getUtxos } from '../utxos-utils'
+import {
+  getInscriptionIds,
+  getOrdinalsUtxos,
+  getTransferOrdinalsUtxos,
+  getUsableUtxos,
+  getUtxos,
+} from '../utxos-utils'
 import { canBumpTx } from './can-bump-tx'
 import { getUnconfirmedTxAncestorMap } from '../unconfirmed-ancestor-data'
 
@@ -42,7 +48,7 @@ export class GetFeeResolver {
       assert(!nft, 'nft must not be provided when brc20 is provided!!!')
     }
 
-    const inscriptionIds = nft?.tokenId ? [nft?.tokenId] : brc20?.inscriptionIds
+    const inscriptionIds = getInscriptionIds({ nft, brc20 })
 
     const { resolvedFee, extraFee } = this.#getUtxosData({
       asset,
@@ -100,6 +106,12 @@ export class GetFeeResolver {
     const utxos = getUtxos({ accountState, asset })
     const unconfirmedTxAncestor = getUnconfirmedTxAncestorMap({ accountState })
 
+    const ordinalsUtxos = getOrdinalsUtxos({ accountState, asset })
+
+    const transferOrdinalsUtxos = inscriptionIds
+      ? getTransferOrdinalsUtxos({ inscriptionIds, ordinalsUtxos })
+      : undefined
+
     const usableUtxos = getUsableUtxos({
       asset,
       utxos,
@@ -117,6 +129,7 @@ export class GetFeeResolver {
       amount,
       feeRate: feePerKB,
       receiveAddress,
+      transferOrdinalsUtxos,
       inscriptionIds,
       isSendAll,
       getFeeEstimator: this.#getFeeEstimator,

package/src/fee/utxo-selector.js

@@ -34,6 +34,7 @@ export const selectUtxos = ({
   allowUnconfirmedRbfEnabledUtxos,
   unconfirmedTxAncestor,
   inscriptionIds, // for each inscription transfer, we need to calculate one more input and one more output
+  transferOrdinalsUtxos, // to calculate the size of the input
 }) => {
   const resolvedReceiveAddresses = getBestReceiveAddresses({
     asset,
@@ -197,7 +198,9 @@ export const selectUtxos = ({
     selectedUtxosValue = selectedUtxosValue.add(newUtxo.value)
   }
 
-  let selectedUtxos = UtxoCollection.fromArray(selectedUtxosArray, { currency })
+  let selectedUtxos = (transferOrdinalsUtxos || UtxoCollection.createEmpty({ currency })).union(
+    UtxoCollection.fromArray(selectedUtxosArray, { currency })
+  ) // extremelly important, orden must be kept!!! ordinals utxos go first!!!
 
   // start figuring out fees
   const outputs =
@@ -240,6 +243,7 @@ export const getUtxosData = ({
   mustSpendUtxos,
   allowUnconfirmedRbfEnabledUtxos,
   inscriptionIds,
+  transferOrdinalsUtxos,
   unconfirmedTxAncestor,
   utxosDescendingOrder,
 }) => {
@@ -257,6 +261,7 @@ export const getUtxosData = ({
     allowUnconfirmedRbfEnabledUtxos,
     unconfirmedTxAncestor,
     inscriptionIds,
+    transferOrdinalsUtxos,
     utxosDescendingOrder,
   })
 

package/src/index.js

@@ -16,6 +16,7 @@ export * from './unconfirmed-ancestor-data'
 export * from './parse-unsigned-tx'
 export * from './insight-api-client/util'
 export * from './move-funds'
+export { createEncodeMultisigContract } from './multisig-address'
 export { toAsyncSigner } from './tx-sign/taproot'
 export { toXOnly } from './bitcoinjs-lib/ecc-utils'
 export * from './ordinals-utils'

package/src/multisig-address.js

@@ -0,0 +1,81 @@
+import * as defaultBitcoinjsLib from '@exodus/bitcoinjs-lib'
+import { toXOnly } from './bitcoinjs-lib/ecc-utils'
+import { eccFactory } from './bitcoinjs-lib/ecc'
+
+// Key to use when key path spending is disabled https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki#constructing-and-spending-taproot-outputs
+const DUMMY_TAPROOT_PUBKEY = Buffer.from(
+  '50929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0',
+  'hex'
+)
+
+// Leaf version for BIP342 is 0xc0 or 192 https://github.com/bitcoin/bips/blob/master/bip-0342.mediawiki#specification
+const LEAF_VERSION_TAPSCRIPT = 192
+
+// Limit multisig keys to 20 for now
+const MAX_PUBKEYS = 20
+
+export const createEncodeMultisigContract =
+  ({
+    bitcoinjsLib = defaultBitcoinjsLib,
+    network = bitcoinjsLib.Network.bitcoin,
+    ecc = eccFactory(),
+  }) =>
+  (publicKeys, { threshold = publicKeys.length, version = 0 } = Object.create(null)) => {
+    if (
+      !Array.isArray(publicKeys) ||
+      publicKeys.some((k) => !Buffer.isBuffer(k) || !ecc.isPointCompressed(k))
+    ) {
+      throw new Error('publicKeys must be an Array of Buffers representing compressed public keys')
+    }
+
+    if (publicKeys.length <= 0 || publicKeys.length > MAX_PUBKEYS) {
+      throw new Error(`asset.encodeMultisigContract supports from 1 to ${MAX_PUBKEYS} pubKeys`)
+    }
+
+    if (new Set(publicKeys.map((k) => k.toString('hex'))).size !== publicKeys.length) {
+      throw new Error('publicKeys must not contain any duplicates')
+    }
+
+    if (!Number.isSafeInteger(version)) {
+      throw new TypeError('asset.encodeMultisigContract requires meta.version to be an integer')
+    }
+
+    // Only support version 0 for now
+    if (version !== 0) {
+      throw new Error(`asset.encodeMultisigContract does not support version ${version}`)
+    }
+
+    if (!Number.isSafeInteger(threshold) || threshold <= 0 || threshold > MAX_PUBKEYS) {
+      throw new Error(
+        `asset.encodeMultisigContract requires meta.threshold to be an integer between 1 and ${MAX_PUBKEYS}`
+      )
+    }
+
+    if (threshold > publicKeys.length) {
+      throw new Error('threshold must be <= publicKeys.length')
+    }
+
+    // Sort according to BIP67 https://github.com/bitcoin/bips/blob/master/bip-0067.mediawiki
+    publicKeys.sort((a, b) => Buffer.compare(a, b))
+
+    // Create multisig redeem script https://github.com/bitcoin/bips/blob/master/bip-0342.mediawiki#cite_note-5
+    const OPS = bitcoinjsLib.script.OPS
+    const chunks = []
+    const keysIter = publicKeys[Symbol.iterator]()
+
+    chunks.push(toXOnly(keysIter.next().value), OPS.OP_CHECKSIG)
+    for (const key of keysIter) {
+      chunks.push(toXOnly(key), OPS.OP_CHECKSIGADD)
+    }
+
+    chunks.push(Buffer.from([threshold]), OPS.OP_NUMEQUAL)
+
+    const output = bitcoinjsLib.script.compile(chunks)
+
+    return bitcoinjsLib.payments.p2tr({
+      internalPubkey: DUMMY_TAPROOT_PUBKEY,
+      scriptTree: { output },
+      redeem: { output, redeemVersion: LEAF_VERSION_TAPSCRIPT },
+      network,
+    })
+  }

package/src/tx-send/index.js

@@ -15,6 +15,7 @@ import {
 } from './dogecoin'
 import { findUnconfirmedSentRbfTxs } from '../tx-utils'
 import {
+  getInscriptionIds,
   getOrdinalsUtxos,
   getTransferOrdinalsUtxos,
   getUsableUtxos,
@@ -221,11 +222,9 @@ export const getPrepareSendTransaction =
     allowUnconfirmedRbfEnabledUtxos,
     utxosDescendingOrder,
     rbfEnabled: providedRbfEnabled,
+    assetClientInterface,
   }) =>
-  async (
-    { asset: maybeToken, walletAccount, address, amount: tokenAmount, options },
-    { assetClientInterface }
-  ) => {
+  async ({ asset: maybeToken, walletAccount, address, amount: tokenAmount, options }) => {
     const {
       multipleAddressesEnabled,
       feePerKB,
@@ -258,7 +257,7 @@ export const getPrepareSendTransaction =
     }
 
     const amount = isToken ? asset.currency.ZERO : tokenAmount
-    const inscriptionIds = nft?.tokenId ? [nft?.tokenId] : brc20 ? brc20.inscriptionIds : undefined
+    const inscriptionIds = getInscriptionIds({ nft, brc20 })
 
     assert(
       ordinalsEnabled || !inscriptionIds,
@@ -351,6 +350,7 @@ export const getPrepareSendTransaction =
       allowUnconfirmedRbfEnabledUtxos,
       unconfirmedTxAncestor,
       inscriptionIds,
+      transferOrdinalsUtxos,
       utxosDescendingOrder,
     })
 
@@ -365,10 +365,6 @@ export const getPrepareSendTransaction =
       throw new Error(`Unable to bump ${bumpTxId}`)
     }
 
-    if (transferOrdinalsUtxos) {
-      selectedUtxos = transferOrdinalsUtxos.union(selectedUtxos)
-    }
-
     if (replaceTx) {
       replaceTx = replaceTx.clone()
       replaceTx = replaceTx.update({ data: { ...replaceTx.data } })
@@ -474,11 +470,9 @@ export const createAndBroadcastTXFactory =
     allowUnconfirmedRbfEnabledUtxos,
     ordinalsEnabled = false,
     utxosDescendingOrder,
+    assetClientInterface,
   }) =>
-  async (
-    { asset: maybeToken, walletAccount, address, amount: tokenAmount, options },
-    { assetClientInterface }
-  ) => {
+  async ({ asset: maybeToken, walletAccount, address, amount: tokenAmount, options }) => {
     // Prepare transaction
     const { bumpTxId, nft, isExchange, isBip70, isRbfAllowed = true, feeOpts } = options
 
@@ -503,10 +497,8 @@ export const createAndBroadcastTXFactory =
       allowUnconfirmedRbfEnabledUtxos,
       utxosDescendingOrder,
       rbfEnabled,
-    })(
-      { asset: maybeToken, walletAccount, address, amount: tokenAmount, options },
-      { assetClientInterface }
-    )
+      assetClientInterface,
+    })({ asset: maybeToken, walletAccount, address, amount: tokenAmount, options })
     const {
       amount,
       change,

package/src/tx-sign/create-sign-with-wallet.js

@@ -37,7 +37,9 @@ export function createSignWithWallet({
       const { key, purpose, publicKey } = getKeyAndPurpose(address)
 
       const isP2SH = purpose === 49
-      const isTaprootAddress = purpose === 86
+      const hasTapLeafScript =
+        psbt.data.inputs[index].tapLeafScript && psbt.data.inputs[index].tapLeafScript.length > 0
+      const isTaprootKeySpend = purpose === 86 && !hasTapLeafScript
 
       if (isP2SH) {
         // If spending from a P2SH address, we assume the address is P2SH wrapping
@@ -56,7 +58,7 @@ export function createSignWithWallet({
         } else {
           throw new Error('Expected P2SH script to be a nested segwit input')
         }
-      } else if (isTaprootAddress && !Buffer.isBuffer(psbt.data.inputs[index].tapInternalKey)) {
+      } else if (isTaprootKeySpend && !Buffer.isBuffer(psbt.data.inputs[index].tapInternalKey)) {
         // tapInternalKey is metadata for signing and not part of the hash to sign.
         // so modifying it here is fine.
         psbt.updateInput(index, {
@@ -67,7 +69,7 @@ export function createSignWithWallet({
       // desktop / BE / mobile with bip-schnorr signing
       await psbt.signInputAsync(
         index,
-        toAsyncSigner({ keyPair: key, isTaprootAddress, network }),
+        toAsyncSigner({ keyPair: key, isTaprootKeySpend, network }),
         allowedSigHashTypes
       )
     }

package/src/tx-sign/default-create-tx.js

@@ -35,7 +35,7 @@ export const signTxFactory = ({ assetName, resolvePurpose, coinInfo, network })
 
     await signWithWallet(psbt, inputsToSign)
 
-    const skipFinalize = !!unsignedTx.txData.psbtBuffer
+    const skipFinalize = !!unsignedTx.txData.psbtBuffer || unsignedTx.txMeta.returnPsbt
     return extractTransaction({ psbt, skipFinalize })
   }
 }

package/src/tx-sign/default-prepare-for-signing.js

@@ -17,17 +17,21 @@ export function createPrepareForSigning({ assetName, resolvePurpose, coinInfo })
   assert(coinInfo, 'coinInfo is required')
 
   return ({ unsignedTx }) => {
+    const networkInfo = coinInfo.toBitcoinJS()
+
     const isPsbtBufferPassed =
       unsignedTx.txData.psbtBuffer &&
       unsignedTx.txMeta.addressPathsMap &&
       unsignedTx.txMeta.inputsToSign
     if (isPsbtBufferPassed) {
       // PSBT created externally (Web3, etc..)
-      return createPsbtFromBuffer({ psbtBuffer: unsignedTx.txData.psbtBuffer })
+      return createPsbtFromBuffer({
+        psbtBuffer: unsignedTx.txData.psbtBuffer,
+        networkInfo,
+      })
     }
 
     // Create PSBT based on internal Exodus data structure
-    const networkInfo = coinInfo.toBitcoinJS()
     const psbt = createPsbtFromTxData({
       ...unsignedTx.txData,
       ...unsignedTx.txMeta,
@@ -41,8 +45,8 @@ export function createPrepareForSigning({ assetName, resolvePurpose, coinInfo })
 }
 
 // Creates a PSBT instance from the passed transaction buffer provided by 3rd parties (e.g. dApps).
-function createPsbtFromBuffer({ psbtBuffer, ecc }) {
-  return Psbt.fromBuffer(psbtBuffer, { eccLib: ecc })
+function createPsbtFromBuffer({ psbtBuffer, ecc, networkInfo }) {
+  return Psbt.fromBuffer(psbtBuffer, { eccLib: ecc, network: networkInfo })
 }
 
 // Creates a PSBT instance from the passed inputs, outputs etc. The wallet itself provides this data.
@@ -54,7 +58,7 @@ function createPsbtFromTxData({ inputs, outputs, rawTxs, networkInfo, resolvePur
   const psbt = new Psbt({ maximumFeeRate, network: networkInfo })
 
   // Fill tx
-  for (const { txId, vout, address, value, script, sequence } of inputs) {
+  for (const { txId, vout, address, value, script, sequence, tapLeafScript } of inputs) {
     // TODO: don't use the purpose as intermediate variable
     // see internals of `resolvePurposes`, just use `isP2TR, isP2SH etc directly
     const purpose = resolvePurpose(address)
@@ -64,6 +68,10 @@ function createPsbtFromTxData({ inputs, outputs, rawTxs, networkInfo, resolvePur
 
     const txIn = { hash: txId, index: vout, sequence }
     if (isSegwitAddress || isTaprootAddress) {
+      if (isTaprootAddress && tapLeafScript) {
+        txIn.tapLeafScript = tapLeafScript
+      }
+
       // witness outputs only require the value and the script, not the full transaction
       txIn.witnessUtxo = { value, script: Buffer.from(script, 'hex') }
     } else {

package/src/tx-sign/taproot.js

@@ -40,22 +40,22 @@ function tapTweakHash(pubKey, h) {
 /**
  * Take a sync signer and make it async.
  */
-export function toAsyncSigner({ keyPair, isTaprootAddress, network }) {
+export function toAsyncSigner({ keyPair, isTaprootKeySpend, network }) {
   assert(keyPair, 'keyPair is required')
 
-  if (isTaprootAddress) {
+  if (isTaprootKeySpend) {
     keyPair = tweakSigner({ signer: keyPair, ECPair, network })
   }
 
   // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
   keyPair.sign = async (h) => {
-    const sig = await ecc.signAsync(h, keyPair.privateKey)
+    const sig = ecc.sign(h, keyPair.privateKey)
     return Buffer.from(sig)
   }
 
   // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
   keyPair.signSchnorr = async (h) => {
-    const sig = await ecc.signSchnorrAsync(h, keyPair.privateKey, getSchnorrEntropy())
+    const sig = ecc.signSchnorr(h, keyPair.privateKey, getSchnorrEntropy())
     return Buffer.from(sig)
   }
 

package/src/utxos-utils.js

@@ -9,6 +9,10 @@ export const getInscriptionTxId = (inscriptionId) => {
   return inscriptionId.split('i')[0]
 }
 
+export function getInscriptionIds({ nft, brc20 }) {
+  return nft?.tokenId ? [nft?.tokenId] : brc20 ? brc20.inscriptionIds : undefined
+}
+
 export function getTransferOrdinalsUtxos({ inscriptionIds, ordinalsUtxos }) {
   const transferOrdinalsUtxos = ordinalsUtxos.filter((utxo) =>
     utxo.inscriptions?.some((i) => inscriptionIds.includes(i.inscriptionId))

package/src/bitcoinjs-lib/ecc/common.js

@@ -1,81 +0,0 @@
-import secp256k1 from '@exodus/secp256k1'
-import { toXOnly } from '../ecc-utils'
-
-/**
- * Common ecc functions between mobile and desktop. Once mobile accepts @noble/secp256k1, we can unify both
- */
-export const common = {
-  /**
-   *
-   * @param msg32 {Uint8Array} the message
-   * @param seckey {Uint8Array} the private key
-   * @param data {Uint8Array} the data to sign
-   */
-  sign: (msg32, seckey, data) => secp256k1.ecdsaSign(msg32, seckey, { data }).signature,
-
-  /**
-   *
-   * @param msg32 {Uint8Array} the message to verify
-   * @param publicKey {Uint8Array} the public key
-   * @param signature {Uint8Array} the signature
-   * @returns {boolean}
-   */
-  verify: (msg32, publicKey, signature) => secp256k1.ecdsaVerify(signature, msg32, publicKey),
-
-  /**
-   *
-   * @param seckey {Uint8Array}
-   * @param tweak {Uint8Array}
-   */
-  privateAdd: (seckey, tweak) =>
-    // cloning input. secp256k1 modifies it and it cannot be reused/cached
-    secp256k1.privateKeyTweakAdd(Buffer.from(seckey), tweak),
-
-  /**
-   * @param seckey {Uint8Array} the public key
-   */
-  privateNegate: (seckey) =>
-    // cloning input. secp256k1 modifies it and it cannot be reused/cached
-    secp256k1.privateKeyNegate(Buffer.from(seckey)),
-
-  /**
-   *
-   * @param publicKey {Uint8Array}
-   * @param tweak {Uint8Array}
-   * @returns {{parity: (number), xOnlyPubkey}|null}
-   */
-  xOnlyPointAddTweak: (publicKey, tweak) => {
-    try {
-      const t = secp256k1.publicKeyTweakAdd(toPubKey(publicKey), tweak)
-      return {
-        parity: t[0] === 0x02 ? 0 : 1,
-        xOnlyPubkey: toXOnly(t),
-      }
-    } catch {
-      return null
-    }
-  },
-
-  /**
-   * @param seckey {Uint8Array}
-   * @returns {boolean}
-   */
-  isPrivate: (seckey) => secp256k1.privateKeyVerify(seckey),
-  /**
-   * @param seckey {Uint8Array}
-   * @param compressed {boolean}
-   */
-  pointFromScalar: (seckey, compressed) => secp256k1.publicKeyCreate(seckey, compressed),
-}
-
-/**
- *
- * @param xOnly {Uint8Array}
- * @returns {Uint8Array}
- */
-export const toPubKey = (xOnly) => {
-  const p = new Uint8Array(33)
-  p.set([0x02])
-  p.set(xOnly, 1)
-  return p
-}

package/src/bitcoinjs-lib/ecc/desktop.js

@@ -1,83 +0,0 @@
-import { initEccLib } from '@exodus/bitcoinjs-lib'
-import { Point, schnorr, sign } from '@noble/secp256k1'
-import { common, toPubKey } from './common'
-
-/**
- * Wrapper around `secp256k1` in order to follow the bitcoinjs-lib `TinySecp256k1Interface`
- * Schnorr signatures are offered by @noble/secp256k1
- */
-export const desktopEcc = {
-  ...common,
-
-  /**
-   * @param message {Uint8Array}
-   * @param privateKey {Uint8Array}
-   * @param extraEntropy {Uint8Array}
-   * @returns {Promise<Uint8Array>}
-   */
-  signAsync: async (message, privateKey, extraEntropy) =>
-    sign(message, privateKey, {
-      extraEntropy,
-      canonical: true,
-      der: false,
-    }),
-
-  /**
-   * @param message {Uint8Array}
-   * @param privateKey {Uint8Array}
-   * @param extraEntropy {Uint8Array}
-   * @returns {Promise<Uint8Array>}
-   */
-  signSchnorrAsync: async (message, privateKey, extraEntropy) =>
-    schnorr.sign(message, privateKey, extraEntropy),
-
-  /**
-   * @param message {Uint8Array}
-   * @param publicKey {Uint8Array}
-   * @param signature {Uint8Array}
-   * @returns {Promise<boolean>}
-   */
-  verifySchnorrAsync: async (message, publicKey, signature) =>
-    schnorr.verify(signature, message, publicKey),
-
-  // The underlying library does not expose sync functions for Schnorr sign and verify.
-  // These function are explicitly defined here as `null` for documentation purposes.
-  // Update, latest version of https://github.com/paulmillr/noble-secp256k1 does support SYNC
-  signSchnorr: null,
-  verifySchnorr: null,
-
-  /**
-   * @param publicKey {Uint8Array}
-   * @returns {boolean}
-   */
-  isPoint: (publicKey) => {
-    try {
-      Point.fromHex(publicKey).assertValidity()
-      return true
-    } catch {
-      return false
-    }
-  },
-
-  /**
-   * @param publicKey {Uint8Array}
-   * @returns {boolean}
-   */
-  isXOnlyPoint: (publicKey) => {
-    try {
-      Point.fromHex(toPubKey(publicKey)).assertValidity()
-      return true
-    } catch {
-      return false
-    }
-  },
-
-  /**
-   * @param publicKey {Uint8Array}
-   * @param compressed {boolean}
-   * @returns {Uint8Array}
-   */
-  pointCompress: (publicKey, compressed) => Point.fromHex(publicKey).toRawBytes(compressed),
-}
-
-initEccLib(desktopEcc)