@exodus/ethereum-lib 5.18.0 → 5.18.1

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [5.18.1](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-lib@5.18.0...@exodus/ethereum-lib@5.18.1) (2025-10-02)
+
+**Note:** Version bump only for package @exodus/ethereum-lib
+
+
+
+
+
 ## [5.18.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-lib@5.17.3...@exodus/ethereum-lib@5.18.0) (2025-09-26)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-lib",
-  "version": "5.18.0",
+  "version": "5.18.1",
   "description": "Ethereum utils, such as for cryptography, address encoding/decoding, transaction building, etc.",
   "type": "module",
   "main": "src/index.js",
@@ -50,5 +50,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "cf881908a1cff88e98d2f9a7a3f29357474e3d0c"
+  "gitHead": "f6ea2714c95f2e7ec71ffecdc589726b7974511e"
 }

package/src/unsigned-tx/create-ethereumjs-tx.js

@@ -6,6 +6,59 @@ import assert from 'minimalistic-assert'
 
 const { isEmpty } = lodash
 
+const getEthereumJsTxDefsByEip1559 = ({ eip1559Enabled }) => {
+  assert(typeof eip1559Enabled === 'boolean', 'expected eip1559Enabled')
+
+  const EthereumJsTransactionClass = eip1559Enabled ? FeeMarketEIP1559Transaction : Transaction
+  const hardfork = eip1559Enabled ? Hardfork.London : Hardfork.Istanbul
+
+  return { EthereumJsTransactionClass, hardfork }
+}
+
+const getEthereumJsTxDefsByTransactionBuffer = ({ transactionBuffer }) => {
+  assert(Buffer.isBuffer(transactionBuffer), 'expected Buffer transactionBuffer')
+
+  return getEthereumJsTxDefsByEip1559({
+    eip1559Enabled: FeeMarketEIP1559Transaction.isEip1559SerializedTx(transactionBuffer),
+  })
+}
+
+const getEthereumJsTxCommon = ({ chainId, ethereumJsTxDefs }) => {
+  assert(ethereumJsTxDefs, 'expected ethereumJsTxDefs')
+
+  const { hardfork } = ethereumJsTxDefs
+
+  return Common.custom(
+    ...[typeof chainId === 'number' && { chainId }, { hardfork }].filter(Boolean)
+  )
+}
+
+export const getEthereumJsTxByTransactionBuffer = ({ chainId, transactionBuffer }) => {
+  assert(typeof chainId === 'number', 'expected chainId')
+
+  const ethereumJsTxDefs = getEthereumJsTxDefsByTransactionBuffer({ transactionBuffer })
+  const { EthereumJsTransactionClass } = ethereumJsTxDefs
+
+  return EthereumJsTransactionClass.fromSerializedTx(transactionBuffer, {
+    common: getEthereumJsTxCommon({ chainId, ethereumJsTxDefs }),
+  })
+}
+
+export const getEthereumJsTxByTransactionProps = ({
+  chainId,
+  eip1559Enabled = false,
+  transactionProps,
+}) => {
+  assert(typeof chainId === 'number', 'expected chainId')
+
+  const ethereumJsTxDefs = getEthereumJsTxDefsByEip1559({ eip1559Enabled })
+  const { EthereumJsTransactionClass } = ethereumJsTxDefs
+
+  return EthereumJsTransactionClass.fromTxData(transactionProps, {
+    common: getEthereumJsTxCommon({ chainId, ethereumJsTxDefs }),
+  })
+}
+
 const parseBufferToJsTx = (unsignedTx) => {
   const { transactionBuffer, chainId, ...legacyTxData } = unsignedTx.txData
   assert(
@@ -13,21 +66,10 @@ const parseBufferToJsTx = (unsignedTx) => {
     'Cannot create ethereum js tx when transactionBuffer and other fields are provided!'
   )
   assert(chainId, 'chainId must be provided when parsing from transaction buffer!!!')
-  if (FeeMarketEIP1559Transaction.isEip1559SerializedTx(transactionBuffer)) {
-    return FeeMarketEIP1559Transaction.fromSerializedTx(transactionBuffer, {
-      common: Common.custom(
-        {
-          chainId,
-        },
-        { hardfork: Hardfork.London }
-      ),
-    })
-  }
 
-  return Transaction.fromSerializedTx(transactionBuffer, {
-    common: Common.custom({
-      chainId,
-    }),
+  return getEthereumJsTxByTransactionBuffer({
+    transactionBuffer,
+    chainId,
   })
 }
 
@@ -36,58 +78,77 @@ export default function createEthereumJsTx(unsignedTx) {
     txData: { transactionBuffer, ...legacyTxData },
   } = unsignedTx
 
-  if (transactionBuffer) {
-    return parseBufferToJsTx(unsignedTx)
-  }
+  if (transactionBuffer) return parseBufferToJsTx(unsignedTx)
 
   const {
     chainId,
     nonce: providedNonce,
-    gasPrice,
     gasLimit: providedGasLimit,
-    tipGasPrice,
     data: providedData,
-    value,
+
+    /* exodus eip1559 */
+    gasPrice,
+    tipGasPrice,
+
+    /* web3 eip1559 */
+    // NOTE: In Web3 EIP-1559, `maxFeePerGas` is mandatory, whilst
+    //       `maxPriorityFeePerGas` can default to zero. If a third
+    //       party transaction intends to do EIP-1559, they *must*
+    //       have defined a `maxFeePerGas`.
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+
     ...txData
   } = legacyTxData
 
   const bufferData = toBuffer(providedData)
-
   const gasLimit = toBuffer(providedGasLimit)
   const data = bufferData.equals(Buffer.from([0])) ? Buffer.alloc(0) : bufferData
   const nonce = providedNonce === 0 ? Buffer.alloc(0) : toBuffer(providedNonce)
-  /*
-    EIP1559 is not supported by all ethereum-like assets.
-    e.g BSC does not support EIP1559 at the moment, prevent building an EIP1559 transaction
-    if `tipGasPrice` or `maxPriorityFeePerGas` is set.
-  */
-  const isEip1559Tx = !!(unsignedTx.txData.tipGasPrice || unsignedTx.txData.maxPriorityFeePerGas)
-  if (unsignedTx.txMeta.eip1559Enabled && isEip1559Tx) {
-    return FeeMarketEIP1559Transaction.fromTxData(
-      {
-        maxFeePerGas: gasPrice,
-        maxPriorityFeePerGas: tipGasPrice,
-        nonce,
-        gasLimit,
-        data,
-        value,
-        // `maxPriorityFeePerGas`, `maxFeePerGas` set in `txData` below take precedence over ^.
-        ...txData,
-      },
-      {
-        common: Common.custom(
-          {
-            chainId,
-          },
-          { hardfork: Hardfork.London }
-        ),
-      }
-    )
+
+  const commonTransactionProps = {
+    ...txData,
+    nonce,
+    gasLimit,
+    data,
   }
 
-  // Legacy tx
-  return Transaction.fromTxData(
-    { nonce, gasPrice, tipGasPrice, gasLimit, data, value, ...txData },
-    { common: Common.custom({ chainId }) }
-  )
+  const createNonEip1559Transaction = () => {
+    assert(gasPrice, 'expected gasPrice')
+
+    return getEthereumJsTxByTransactionProps({
+      chainId,
+      transactionProps: { ...commonTransactionProps, gasPrice },
+    })
+  }
+
+  // If a non-EIP-1559 style transaction has been supplied,
+  // then create a legacy trasaction.
+  if (!unsignedTx.txMeta.eip1559Enabled) return createNonEip1559Transaction()
+
+  // Internally, Exodus uses the convention that an EIP-1559
+  // transaction must use `gasPrice` and `tipGasPrice`. Web3
+  // can provide a `maxFeePerGas` and optional
+  // `maxPriorityFeePerGas`.
+  //
+  // Likewise, if a `maxFeePerGas` has been omitted, the
+  // transaction *must* have defined a `gasPrice`.
+  if (tipGasPrice || !maxFeePerGas) assert(gasPrice, 'expected gasPrice')
+
+  // If neither properties were truthy, attempt to construct
+  // a legacy transaction.
+  if (!(tipGasPrice || maxFeePerGas)) return createNonEip1559Transaction()
+
+  // Create an EIP-1559 style transaction.
+  return getEthereumJsTxByTransactionProps({
+    chainId,
+    eip1559Enabled: true,
+    transactionProps: {
+      ...commonTransactionProps,
+      // NOTE: Here we force the appropriate conventions for gas.
+      ...(maxFeePerGas
+        ? { maxFeePerGas, maxPriorityFeePerGas } /* web3 */
+        : { maxFeePerGas: gasPrice, maxPriorityFeePerGas: tipGasPrice }) /* exodus */,
+    },
+  })
 }

package/src/unsigned-tx/index.js

@@ -2,6 +2,10 @@ export { default as createUnsignedTxFactory } from './create-unsigned-tx.js'
 export { default as parseUnsignedTx } from './parse-unsigned-tx.js'
 export { default as signUnsignedTx, signUnsignedTxWithSigner } from './sign-unsigned-tx.js'
 export { default as createAndSignTxFactory } from './create-and-sign-tx.js'
-export { default as createEthereumJsTx } from './create-ethereumjs-tx.js'
+export {
+  default as createEthereumJsTx,
+  getEthereumJsTxByTransactionBuffer,
+  getEthereumJsTxByTransactionProps,
+} from './create-ethereumjs-tx.js'
 export { signHardwareFactory } from './sign-hardware.js'
 export { default as updateNonce } from './update-nonce.js'

package/src/unsigned-tx/update-nonce.js

@@ -1,16 +1,22 @@
-import { FeeMarketEIP1559Transaction, Transaction } from '@exodus/ethereumjs/tx'
+import assert from 'minimalistic-assert'
 
-const updateNonce = (transactionBuffer, newNonce) => {
-  if (FeeMarketEIP1559Transaction.isEip1559SerializedTx(transactionBuffer)) {
-    const transaction = FeeMarketEIP1559Transaction.fromSerializedTx(transactionBuffer)
-    return FeeMarketEIP1559Transaction.fromTxData({
-      ...transaction.toJSON(),
-      nonce: newNonce,
-    }).serialize()
-  }
+import { getEthereumJsTxByTransactionBuffer } from './create-ethereumjs-tx.js'
 
-  const transaction = Transaction.fromSerializedTx(transactionBuffer)
-  return Transaction.fromTxData({ ...transaction.toJSON(), nonce: newNonce }).serialize()
+const updateNonce = ({ chainId, transactionBuffer, newNonce }) => {
+  assert(Buffer.isBuffer(transactionBuffer), 'expected Buffer transactionBuffer')
+  assert(typeof newNonce === 'number', 'expected number newNonce')
+  assert(typeof chainId === 'number', 'expected number chainId')
+
+  const transaction = getEthereumJsTxByTransactionBuffer({
+    chainId,
+    transactionBuffer,
+  })
+
+  // NOTE: Here we use the `static` `fromTxData` function via
+  //       the `transaction` instance.
+  return transaction.constructor
+    .fromTxData({ ...transaction.toJSON(), nonce: newNonce })
+    .serialize()
 }
 
 export default updateNonce