@exodus/ethereum-api 2.13.2 → 2.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "2.13.2",
+  "version": "2.15.0",
   "description": "Ethereum Api",
   "main": "src/index.js",
   "author": "Exodus Movement, Inc.",
@@ -12,7 +12,7 @@
   "dependencies": {
     "@exodus/asset-lib": "^3.5.4",
     "@exodus/crypto": "^1.0.0-rc.0",
-    "@exodus/ethereum-lib": "^2.13.6",
+    "@exodus/ethereum-lib": "^2.14.0",
     "@exodus/ethereumjs-util": "^7.1.0-exodus.6",
     "@exodus/simple-retry": "^0.0.6",
     "fetchival": "0.3.3",
@@ -28,5 +28,5 @@
     "@exodus/assets-base": "^8.0.136",
     "@exodus/models": "^8.7.2"
   },
-  "gitHead": "f1d39b200c106794d81bd19b7e41073eeec15cba"
+  "gitHead": "5d4cf293088ce0e75848409b3c1af528afb32789"
 }

package/src/index.js

@@ -8,3 +8,4 @@ export * from './exodus-eth-server'
 export * from './tx-log'
 export * from './get-balances'
 export * from './staking'
+export * from './simulate-tx'

package/src/simulate-tx/fetch-tx-preview.js

@@ -0,0 +1,21 @@
+const ETHEREUM_TX_PREVIEW_API = 'https://simulation.a.exodus.io/simulate'
+
+export async function fetchTxPreview(transaction) {
+  const response = await fetch(ETHEREUM_TX_PREVIEW_API, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      network: 'ethereum',
+      chain: 'main',
+      transactions: [transaction],
+    }),
+  })
+
+  if (!response.ok) {
+    throw new Error(await response.text())
+  }
+
+  return response.json()
+}

package/src/simulate-tx/index.js

@@ -0,0 +1,2 @@
+export * from './fetch-tx-preview'
+export * from './simulate-eth-tx'

package/src/simulate-tx/simulate-eth-tx.js

@@ -0,0 +1,68 @@
+import assets from '@exodus/assets'
+
+import { fetchTxPreview } from './fetch-tx-preview'
+
+function weiToEth(wei) {
+  const asset = assets.ethereum
+  const currency = asset.currency
+
+  const valueInEth = currency.baseUnit(wei).toDefaultString()
+
+  return valueInEth
+}
+
+const ethHexToInt = (hexValue) => parseInt(hexValue, '16')
+
+export async function simulateTx(transaction) {
+  let accounts = {}
+
+  if (!transaction.to) throw new Error(`'to' field is missing in the TX object`)
+
+  const blocknativeTxObject = {
+    to: transaction.to,
+    input: transaction.data,
+    from: transaction.from,
+    value: ethHexToInt(transaction.value),
+    gas: ethHexToInt(transaction.gas),
+    maxFeePerGas: ethHexToInt(transaction.maxFeePerGas),
+    maxPriorityFeePerGas: ethHexToInt(transaction.maxPriorityFeePerGas),
+  }
+
+  try {
+    const simulatedTx = await fetchTxPreview(blocknativeTxObject)
+
+    const [simulatedBalanceChanges] = simulatedTx.netBalanceChanges
+
+    const [sender] =
+      simulatedBalanceChanges &&
+      simulatedBalanceChanges.filter(({ address }) => address === transaction.from)
+
+    if (sender) {
+      sender.balanceChanges.forEach((balanceChange) => {
+        const delta = balanceChange.delta
+        if (delta.startsWith('-')) {
+          accounts.willSend = {
+            symbol: balanceChange.asset.symbol,
+            amount: weiToEth(delta.slice(1)),
+          }
+        } else {
+          accounts.willReceive = {
+            symbol: balanceChange.asset.symbol,
+            amount: weiToEth(delta),
+          }
+        }
+      })
+    }
+
+    if (!accounts.willSend) {
+      accounts.willSend = {
+        symbol: 'ETH',
+        amount: weiToEth(transaction.value),
+      }
+    }
+  } catch (_) {
+    throw new Error('Simulation of Ethereum transaction failed.')
+  }
+
+  return accounts
+}

package/src/staking/fantom-staking.js

@@ -0,0 +1,115 @@
+import { createContract } from '@exodus/ethereum-lib'
+
+export const SFC_ADDRESS = '0xfc00face00000000000000000000000000000000'
+
+export class FantomStaking {
+  constructor() {
+    this.sfcContract = createContract(SFC_ADDRESS, 'fantomSfc')
+  }
+
+  buildTxData = (contract, method, ...args) => {
+    return contract[method].build(...args)
+  }
+
+  /**
+   * Get tx data of method to delegate (stake) amount to validator
+   */
+  delegate = ({ validatorId }) => {
+    this.#validateValidatorId(validatorId)
+    return this.buildTxData(this.sfcContract, 'delegate', validatorId)
+  }
+
+  /**
+   * undelegate creates a transaction preparing part of the delegations
+   * to be withdrawn.
+   *
+   * Note: The amount must be lower than the total delegation amount for that account. Also,
+   * the requestId value has to be unique and previously unused numeric identifier of the new
+   * withdrawal. The actual withdraw execution, available after a lock period, will use the same
+   * request id to process the prepared withdrawal.
+   */
+  undelegate = ({ requestId, validatorId, amount }) => {
+    this.#validateRequestId(requestId)
+    this.#validateValidatorId(validatorId)
+    return this.buildTxData(this.sfcContract, 'undelegate', validatorId, requestId, amount)
+  }
+
+  /**
+   * withdraw creates a transaction executing partial withdraw for the given
+   * prepared withdraw request.
+   *
+   * Note: The request id has to exist and has to be prepared for the withdraw to execute
+   * correctly.
+   */
+  withdraw = ({ requestId, validatorId }) => {
+    this.#validateRequestId(requestId)
+    this.#validateValidatorId(validatorId)
+    return this.buildTxData(this.sfcContract, 'withdraw', validatorId, requestId)
+  }
+
+  /**
+   * claimRewards creates a new delegator rewards claiming transaction.
+   * The call transfers all the rewards from SFC back to the stake in single transaction.
+   */
+  claimRewards = ({ validatorId }) => {
+    this.#validateValidatorId(validatorId)
+    return this.buildTxData(this.sfcContract, 'claimRewards', validatorId)
+  }
+
+  /**
+   * restakeRewards creates a new delegator rewards claiming transaction.
+   * The call transfers all the rewards from SFC back to the stake in single transaction.
+   */
+  restakeRewards = ({ validatorId }) => {
+    this.#validateValidatorId(validatorId)
+    return this.buildTxData(this.sfcContract, 'restakeRewards', validatorId)
+  }
+
+  /**
+   * lockStake creates a transaction for locking delegation.
+   */
+  lockStake = ({ validatorId, amount, durationSeconds }) => {
+    this.#validateValidatorId(validatorId)
+    this.#validateDuration(durationSeconds)
+    return this.buildTxData(this.sfcContract, 'lockStake', validatorId, durationSeconds, amount)
+  }
+
+  /**
+   * relockStake creates a transaction for re-locking delegation.
+   */
+  relockStake = ({ validatorId, amount, durationSeconds }) => {
+    this.#validateValidatorId(validatorId)
+    this.#validateDuration(durationSeconds)
+    return this.buildTxData(this.sfcContract, 'relockStake', validatorId, durationSeconds, amount)
+  }
+
+  /**
+   * unlockStake creates a transaction for unlocking delegation.
+   */
+  unlockStake = ({ validatorId, amount }) => {
+    this.#validateValidatorId(validatorId)
+    return this.buildTxData(this.sfcContract, 'unlockStake', validatorId, amount)
+  }
+
+  #validateValidatorId = (validatorId) => {
+    if (!Number.isInteger(validatorId) || validatorId <= 0) {
+      throw new Error('Validator id must be positive unsigned integer value.')
+    }
+  }
+
+  #validateRequestId = (requestId) => {
+    if (!Number.isInteger(requestId) || requestId <= 0) {
+      throw new Error('Request id must be a valid numeric identifier.')
+    }
+  }
+
+  #validateDuration = (duration) => {
+    if (!Number.isInteger(duration)) {
+      throw new Error('The lock duration must be an integer.')
+    }
+
+    if (duration > 365 * 86400) {
+      throw new Error('The lock duration must be at most 365 days.')
+    }
+  }
+}

package/src/staking/index.js

@@ -1 +1,2 @@
 export { MaticStaking } from './matic-staking'
+export { FantomStaking } from './fantom-staking'