@exodus/ethereum-api 10.0.0 → 10.1.0

package/src/staking/evm/staking-errors.js

@@ -0,0 +1,37 @@
+export const createRejectionError = ({ operation, check }) => {
+  const error = new Error(`Cannot ${operation}: ${check.reasonCode}`)
+  error.name = 'StakingRejectionError'
+  error.reasonCode = check.reasonCode
+  if (check.shortfall) {
+    error.shortfall = check.shortfall
+    error.shortfallAssetName = check.shortfallAssetName
+  }
+
+  return error
+}
+
+export const createSubmitError = ({ error, txIds, failedIndex }) => {
+  const submitError = new Error(error.message, { cause: error })
+  submitError.name = 'StakingSubmitError'
+  submitError.txIds = txIds
+  submitError.failedIndex = failedIndex
+  return submitError
+}
+
+export const fail = (reasonCode, shortfall, shortfallAssetName) => ({
+  ok: false,
+  reasonCode,
+  ...(shortfall && { shortfall, shortfallAssetName }),
+})
+
+export const pass = (warnings = []) => (warnings.length > 0 ? { ok: true, warnings } : { ok: true })
+
+export const sumOperationFees = ({ estimateOperationFee, operations }) => {
+  if (!estimateOperationFee) return
+  const fees = operations.map(estimateOperationFee)
+  if (fees.some((fee) => !fee)) return
+  return fees.reduce((total, fee) => total.add(fee))
+}
+
+export const warnIfBelow = ({ balance, required, warning }) =>
+  pass(balance && required && balance.lt(required) ? [warning] : [])

package/src/staking/evm/staking-txs.js

@@ -0,0 +1,107 @@
+import assert from 'minimalistic-assert'
+
+export const STAKING_TX_MODE = Object.freeze({ single: 'single', bundle: 'bundle' })
+
+const createSingleTx = async ({ asset, walletAccount, step, gasPrice, tipGasPrice, feeData }) => {
+  const createdTx = await asset.baseAsset.api.createTx({
+    asset,
+    walletAccount,
+    address: step.to,
+    amount: step.amount || asset.currency.ZERO,
+    txInput: step.txInput,
+    gasPrice,
+    gasLimit: step.gasLimit,
+    tipGasPrice,
+    feeData,
+  })
+  return [createdTx]
+}
+
+const createBundleTxs = async ({
+  asset,
+  walletAccount,
+  fromAddress,
+  steps,
+  gasPrice,
+  tipGasPrice,
+}) => {
+  const baseNonce = await asset.baseAsset.getNonce({ asset, fromAddress, walletAccount })
+
+  return Promise.all(
+    steps.map((step, index) =>
+      asset.baseAsset.api.createTx({
+        asset,
+        walletAccount,
+        fromAddress,
+        amount: step.amount || asset.currency.ZERO,
+        tipGasPrice,
+        gasPrice,
+        toAddress: step.to,
+        txInput: step.txInput,
+        gasLimit: step.gasLimit,
+        nonce: baseNonce + index,
+      })
+    )
+  )
+}
+
+export async function createStakingTxs({
+  asset,
+  walletAccount,
+  fromAddress,
+  steps,
+  mode,
+  gasPrice,
+  tipGasPrice,
+  feeData,
+}) {
+  assert(steps.length > 0, 'staking txs require at least one step')
+  assert(
+    steps.every(({ amount }) => !amount || amount.unitType.equals(asset.currency)),
+    `staking tx amounts must be in ${asset.name}, the asset sending the txs`
+  )
+
+  switch (mode) {
+    case STAKING_TX_MODE.single:
+      assert(steps.length === 1, 'single staking tx mode requires exactly one step')
+      return createSingleTx({
+        asset,
+        walletAccount,
+        step: steps[0],
+        gasPrice,
+        tipGasPrice,
+        feeData,
+      })
+    case STAKING_TX_MODE.bundle:
+      return createBundleTxs({ asset, walletAccount, fromAddress, steps, gasPrice, tipGasPrice })
+    default:
+      throw new Error(`Unknown staking tx mode: ${mode}`)
+  }
+}
+
+export async function sendStakingTxs({ asset, walletAccount, unsignedTxs, mode, onProgress }) {
+  switch (mode) {
+    case STAKING_TX_MODE.single: {
+      assert(unsignedTxs.length === 1, 'single staking tx mode requires exactly one tx')
+      onProgress?.({ index: 0, total: 1 })
+      const { txId } = await asset.baseAsset.api.sendTx({
+        asset,
+        walletAccount,
+        unsignedTx: unsignedTxs[0],
+      })
+      return { txIds: [txId] }
+    }
+
+    case STAKING_TX_MODE.bundle: {
+      const { bundleHash, txIds } = await asset.baseAsset.sendPrivateBundle({
+        unsignedTxBundle: unsignedTxs.map((unsignedTx) => ({ asset, unsignedTx, walletAccount })),
+        onBeforeSign: onProgress,
+      })
+      assert(txIds.length === unsignedTxs.length, 'expected a tx id for every bundled tx')
+      return { bundleHash, txIds: [...txIds] }
+    }
+
+    default:
+      throw new Error(`Unknown staking tx mode: ${mode}`)
+  }
+}

package/src/staking/matic/index.js

@@ -6,4 +6,5 @@ export {
   isPolygonReward,
   isPolygonClaimUndelegate,
   isPendingPolygonUndelegateTxInEthereumTxLog,
+  isPolygonUndelegateTxInEthereumTxLog,
 } from './matic-staking-utils.js'