@ledgerhq/coin-tron 0.0.1

package/src/bridge/getTransactionStatus.ts

@@ -0,0 +1,263 @@
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account";
+import {
+  AmountRequired,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+  RecipientRequired,
+} from "@ledgerhq/errors";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies";
+import BigNumber from "bignumber.js";
+import sumBy from "lodash/sumBy";
+import { ONE_TRX } from "../logic/constants";
+import {
+  fetchTronAccount,
+  fetchTronContract,
+  getContractUserEnergyRatioConsumption,
+  getDelegatedResource,
+  getTronSuperRepresentatives,
+  validateAddress,
+} from "../network";
+import { Transaction, TransactionStatus, TronAccount } from "../types";
+import {
+  TronInvalidFreezeAmount,
+  TronInvalidUnDelegateResourceAmount,
+  TronInvalidVoteCount,
+  TronLegacyUnfreezeNotExpired,
+  TronNoFrozenForBandwidth,
+  TronNoFrozenForEnergy,
+  TronNoReward,
+  TronNotEnoughEnergy,
+  TronNotEnoughTronPower,
+  TronNoUnfrozenResource,
+  TronRewardNotAvailable,
+  TronSendTrc20ToNewAccountForbidden,
+  TronUnexpectedFees,
+  TronUnfreezeNotExpired,
+  TronVoteRequired,
+} from "../types/errors";
+import getEstimatedFees from "./getEstimateFees";
+
+const getTransactionStatus = async (
+  acc: TronAccount,
+  transaction: Transaction,
+): Promise<TransactionStatus> => {
+  const errors: Record<string, Error> = {};
+  const warnings: Record<string, Error> = {};
+  const { family, mode, recipient, resource, votes, useAllAmount = false } = transaction;
+  const tokenAccount = !transaction.subAccountId
+    ? null
+    : acc.subAccounts && acc.subAccounts.find(ta => ta.id === transaction.subAccountId);
+  const account = tokenAccount || acc;
+  const isContractAddressRecipient = (await fetchTronContract(recipient)) !== undefined;
+
+  if (mode === "send" && !recipient) {
+    errors.recipient = new RecipientRequired();
+  }
+
+  if (["send", "unDelegateResource", "legacyUnfreeze"].includes(mode)) {
+    if (recipient === acc.freshAddress) {
+      errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+    } else if (recipient && !(await validateAddress(recipient))) {
+      errors.recipient = new InvalidAddress(undefined, {
+        currencyName: acc.currency.name,
+      });
+    } else if (
+      recipient &&
+      mode === "send" &&
+      account.type === "TokenAccount" &&
+      account.token.tokenType === "trc20" &&
+      !isContractAddressRecipient && // send trc20 to a smart contract is allowed
+      (await fetchTronAccount(recipient)).length === 0
+    ) {
+      // send trc20 to a new account is forbidden by us (because it will not activate the account)
+      errors.recipient = new TronSendTrc20ToNewAccountForbidden();
+    }
+  }
+
+  if (mode === "unfreeze") {
+    const { bandwidth, energy } = acc.tronResources.frozen;
+    if (resource === "BANDWIDTH" && transaction.amount.gt(bandwidth?.amount || new BigNumber(0))) {
+      errors.resource = new TronNoFrozenForBandwidth();
+    } else if (resource === "ENERGY" && transaction.amount.gt(energy?.amount || new BigNumber(0))) {
+      errors.resource = new TronNoFrozenForEnergy();
+    }
+  }
+
+  if (mode === "legacyUnfreeze") {
+    const now = new Date();
+    const expirationDate =
+      resource === "ENERGY"
+        ? acc.tronResources.legacyFrozen.energy?.expiredAt
+        : acc.tronResources.legacyFrozen.bandwidth?.expiredAt;
+
+    if (!expirationDate) {
+      if (resource === "BANDWIDTH") {
+        errors.resource = new TronNoFrozenForBandwidth();
+      } else {
+        errors.resource = new TronNoFrozenForEnergy();
+      }
+    } else if (now.getTime() < expirationDate.getTime()) {
+      errors.resource = new TronLegacyUnfreezeNotExpired();
+    }
+  }
+
+  if (mode === "withdrawExpireUnfreeze") {
+    const now = new Date();
+    if (
+      (!acc.tronResources.unFrozen.bandwidth ||
+        acc.tronResources.unFrozen.bandwidth.length === 0) &&
+      (!acc.tronResources.unFrozen.energy || acc.tronResources.unFrozen.energy.length === 0)
+    ) {
+      errors.resource = new TronNoUnfrozenResource();
+    } else {
+      const unfreezingResources = [
+        ...(acc.tronResources.unFrozen.bandwidth ?? []),
+        ...(acc.tronResources.unFrozen.energy ?? []),
+      ];
+
+      const hasNoExpiredResource = !unfreezingResources.some(
+        unfrozen => unfrozen.expireTime.getTime() <= now.getTime(),
+      );
+
+      if (hasNoExpiredResource) {
+        const closestExpireTime = unfreezingResources.reduce((closest, current) => {
+          if (!closest) {
+            return current;
+          }
+          const closestTimeDifference = Math.abs(closest.expireTime.getTime() - now.getTime());
+          const currentTimeDifference = Math.abs(current.expireTime.getTime() - now.getTime());
+
+          return currentTimeDifference < closestTimeDifference ? current : closest;
+        });
+        errors.resource = new TronUnfreezeNotExpired(undefined, {
+          time: closestExpireTime.expireTime.toISOString(),
+        });
+      }
+    }
+  }
+
+  if (mode === "unDelegateResource" && resource && acc.tronResources) {
+    const delegatedResourceAmount = await getDelegatedResource(acc, transaction, resource);
+    if (delegatedResourceAmount.lt(transaction.amount)) {
+      errors.resource = new TronInvalidUnDelegateResourceAmount();
+    }
+  }
+
+  if (mode === "vote") {
+    if (votes.length === 0) {
+      errors.vote = new TronVoteRequired();
+    } else {
+      const superRepresentatives = await getTronSuperRepresentatives();
+      const isValidVoteCounts = votes.every(v => v.voteCount > 0);
+      const isValidAddresses = votes.every(v =>
+        superRepresentatives.some(s => s.address === v.address),
+      );
+
+      if (!isValidAddresses) {
+        errors.vote = new InvalidAddress("", {
+          currencyName: acc.currency.name,
+        });
+      } else if (!isValidVoteCounts) {
+        errors.vote = new TronInvalidVoteCount();
+      } else {
+        const totalVoteCount = sumBy(votes, "voteCount");
+        const tronPower = (acc.tronResources && acc.tronResources.tronPower) || 0;
+
+        if (totalVoteCount > tronPower) {
+          errors.vote = new TronNotEnoughTronPower();
+        }
+      }
+    }
+  }
+
+  if (mode === "claimReward") {
+    const lastRewardOp = account.operations.find(o => o.type === "REWARD");
+    const claimableRewardDate = lastRewardOp
+      ? new Date(lastRewardOp.date.getTime() + 24 * 60 * 60 * 1000) // date + 24 hours
+      : new Date();
+
+    if (acc.tronResources && acc.tronResources.unwithdrawnReward.eq(0)) {
+      errors.reward = new TronNoReward();
+    } else if (lastRewardOp && claimableRewardDate.valueOf() > new Date().valueOf()) {
+      errors.reward = new TronRewardNotAvailable("Reward is not claimable", {
+        until: claimableRewardDate.toISOString(),
+      });
+    }
+  }
+
+  const estimatedFees =
+    Object.entries(errors).length > 0
+      ? new BigNumber(0)
+      : await getEstimatedFees(acc, transaction, isContractAddressRecipient);
+  const balance =
+    account.type === "Account"
+      ? BigNumber.max(0, account.spendableBalance.minus(estimatedFees))
+      : account.balance;
+  const amount = useAllAmount ? balance : transaction.amount;
+  const amountSpent = ["send", "freeze", "undelegateResource"].includes(mode)
+    ? amount
+    : new BigNumber(0);
+
+  if (mode === "freeze" && amount.lt(ONE_TRX)) {
+    errors.amount = new TronInvalidFreezeAmount();
+  }
+
+  // fees are applied in the parent only (TRX)
+  const totalSpent = account.type === "Account" ? amountSpent.plus(estimatedFees) : amountSpent;
+
+  if (["send", "freeze"].includes(mode)) {
+    if (amount.eq(0)) {
+      errors.amount = new AmountRequired();
+    }
+    if (amountSpent.eq(0)) {
+      errors.amount = useAllAmount ? new NotEnoughBalance() : new AmountRequired();
+    } else if (amount.gt(balance)) {
+      errors.amount = new NotEnoughBalance();
+    } else if (account.type === "TokenAccount" && estimatedFees.gt(acc.balance)) {
+      errors.amount = new NotEnoughBalance();
+    }
+
+    const energy = (acc.tronResources && acc.tronResources.energy) || new BigNumber(0);
+
+    // For the moment, we rely on this rule:
+    // Add a 'TronNotEnoughEnergy' warning only if the account sastifies theses 3 conditions:
+    // - no energy
+    // - balance is lower than 1 TRX
+    // - contract consumes user energy (ie: user's ratio > 0%)
+    if (
+      account.type === "TokenAccount" &&
+      account.token.tokenType === "trc20" &&
+      energy.lt(47619) // temporary value corresponding to usdt trc20 energy
+    ) {
+      const contractUserEnergyConsumption = await getContractUserEnergyRatioConsumption(
+        account.token.contractAddress,
+      );
+
+      if (contractUserEnergyConsumption > 0) {
+        warnings.amount = new TronNotEnoughEnergy();
+      }
+    }
+  }
+
+  if (!errors.recipient && estimatedFees.gt(0)) {
+    const fees = formatCurrencyUnit(getAccountCurrency(acc).units[0], estimatedFees, {
+      showCode: true,
+      disableRounding: true,
+    });
+    warnings.fee = new TronUnexpectedFees("Estimated fees", {
+      fees,
+    });
+  }
+
+  return Promise.resolve({
+    errors,
+    warnings,
+    amount: amountSpent,
+    estimatedFees,
+    totalSpent,
+    family,
+  });
+};
+
+export default getTransactionStatus;

package/src/bridge/index.ts

@@ -0,0 +1,78 @@
+import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import {
+  defaultUpdateTransaction,
+  makeAccountBridgeReceive,
+  makeScanAccounts,
+} from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { CoinConfig } from "@ledgerhq/coin-framework/config";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import type { AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
+import { type Transaction, TronAccount, TronSigner } from "../types";
+import signerGetAddress from "../signer";
+import broadcast from "./broadcast";
+import createTransaction from "./createTransaction";
+import estimateMaxSpendable from "./estimateMaxSpendable";
+import getTransactionStatus from "./getTransactionStatus";
+import { hydrate, preload } from "./preload";
+import { prepareTransaction } from "./prepareTransaction";
+import {
+  assignFromAccountRaw,
+  assignToAccountRaw,
+  fromOperationExtraRaw,
+  toOperationExtraRaw,
+} from "./serialization";
+import { buildSignOperation } from "./signOperation";
+import { getAccountShape, sync } from "./synchronization";
+import { setCoinConfig, TronCoinConfig } from "../config";
+
+function buildCurrencyBridge(signerContext: SignerContext<TronSigner>): CurrencyBridge {
+  const getAddress = signerGetAddress(signerContext);
+
+  const scanAccounts = makeScanAccounts({
+    getAccountShape,
+    getAddressFn: getAddressWrapper(getAddress),
+  });
+
+  return {
+    preload,
+    hydrate,
+    scanAccounts,
+  };
+}
+
+function buildAccountBridge(
+  signerContext: SignerContext<TronSigner>,
+): AccountBridge<Transaction, TronAccount> {
+  const getAddress = signerGetAddress(signerContext);
+
+  const receive = makeAccountBridgeReceive(getAddressWrapper(getAddress));
+  const signOperation = buildSignOperation(signerContext);
+
+  return {
+    estimateMaxSpendable,
+    createTransaction,
+    updateTransaction: defaultUpdateTransaction,
+    getTransactionStatus,
+    prepareTransaction,
+    sync,
+    receive,
+    signOperation,
+    broadcast,
+    assignFromAccountRaw,
+    assignToAccountRaw,
+    fromOperationExtraRaw,
+    toOperationExtraRaw,
+  };
+}
+
+export function createBridges(
+  signerContext: SignerContext<TronSigner>,
+  coinConfig: CoinConfig<TronCoinConfig>,
+) {
+  setCoinConfig(coinConfig);
+
+  return {
+    currencyBridge: buildCurrencyBridge(signerContext),
+    accountBridge: buildAccountBridge(signerContext),
+  };
+}

package/src/bridge/preload.ts

@@ -0,0 +1,24 @@
+import { getTronSuperRepresentatives, hydrateSuperRepresentatives } from "../network";
+import { SuperRepresentative } from "../types";
+
+export const preload = async () => {
+  const superRepresentatives = await getTronSuperRepresentatives();
+  return {
+    superRepresentatives,
+  };
+};
+
+export const hydrate = (data?: { superRepresentatives?: SuperRepresentative[] }) => {
+  if (!data || !data.superRepresentatives) return;
+
+  const { superRepresentatives } = data;
+
+  if (
+    !superRepresentatives ||
+    typeof superRepresentatives !== "object" ||
+    !Array.isArray(superRepresentatives)
+  )
+    return;
+
+  hydrateSuperRepresentatives(superRepresentatives);
+};

package/src/bridge/prepareTransaction.ts

@@ -0,0 +1,12 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import { getTronAccountNetwork } from "../network";
+import { Transaction, TronAccount } from "../types";
+
+export const prepareTransaction: AccountBridge<
+  Transaction,
+  TronAccount
+>["prepareTransaction"] = async (account, transaction) => {
+  const networkInfo =
+    transaction.networkInfo || (await getTronAccountNetwork(account.freshAddress));
+  return transaction.networkInfo === networkInfo ? transaction : { ...transaction, networkInfo };
+};

package/src/bridge/serialization.ts

@@ -0,0 +1,288 @@
+import { BigNumber } from "bignumber.js";
+import {
+  TronTransactionInfo,
+  TronTransactionInfoRaw,
+  isTrongridExtraTxInfo,
+  isTrongridExtraTxInfoRaw,
+  type TronAccount,
+  type TronAccountRaw,
+  type TronResources,
+  type TronResourcesRaw,
+  type TrongridExtraTxInfo,
+  type TrongridExtraTxInfoRaw,
+} from "../types";
+import { Account, AccountRaw, OperationExtra, OperationExtraRaw } from "@ledgerhq/types-live";
+
+export const toTronResourcesRaw = ({
+  frozen,
+  unFrozen,
+  delegatedFrozen,
+  legacyFrozen,
+  votes,
+  tronPower,
+  energy,
+  bandwidth,
+  unwithdrawnReward,
+  lastWithdrawnRewardDate,
+  lastVotedDate,
+  cacheTransactionInfoById: cacheTx,
+}: TronResources): TronResourcesRaw => {
+  const frozenBandwidth = frozen.bandwidth;
+  const frozenEnergy = frozen.energy;
+  const delegatedFrozenBandwidth = delegatedFrozen.bandwidth;
+  const delegatedFrozenEnergy = delegatedFrozen.energy;
+  const cacheTransactionInfoById: Record<string, TronTransactionInfoRaw> = {};
+  const unFrozenBandwidth = unFrozen?.bandwidth;
+  const unFrozenEnergy = unFrozen?.energy;
+  const legacyFrozenBandwidth = legacyFrozen?.bandwidth;
+  const legacyFrozenEnergy = legacyFrozen?.energy;
+
+  for (const k in cacheTx) {
+    const { fee, blockNumber, withdraw_amount, unfreeze_amount } = cacheTx[k];
+    cacheTransactionInfoById[k] = [fee, blockNumber, withdraw_amount, unfreeze_amount];
+  }
+
+  return {
+    frozen: {
+      bandwidth: frozenBandwidth
+        ? {
+            amount: frozenBandwidth.amount.toString(),
+          }
+        : undefined,
+      energy: frozenEnergy
+        ? {
+            amount: frozenEnergy.amount.toString(),
+          }
+        : undefined,
+    },
+    delegatedFrozen: {
+      bandwidth: delegatedFrozenBandwidth
+        ? {
+            amount: delegatedFrozenBandwidth.amount.toString(),
+          }
+        : undefined,
+      energy: delegatedFrozenEnergy
+        ? {
+            amount: delegatedFrozenEnergy.amount.toString(),
+          }
+        : undefined,
+    },
+    unFrozen: {
+      bandwidth: unFrozenBandwidth
+        ? unFrozenBandwidth.map(entry => {
+            return { amount: entry.amount.toString(), expireTime: entry.expireTime.toISOString() };
+          })
+        : undefined,
+      energy: unFrozenEnergy
+        ? unFrozenEnergy.map(entry => {
+            return { amount: entry.amount.toString(), expireTime: entry.expireTime.toISOString() };
+          })
+        : undefined,
+    },
+    legacyFrozen: {
+      bandwidth: legacyFrozenBandwidth
+        ? {
+            amount: legacyFrozenBandwidth.amount.toString(),
+            expiredAt: legacyFrozenBandwidth.expiredAt.toISOString(),
+          }
+        : undefined,
+      energy: legacyFrozenEnergy
+        ? {
+            amount: legacyFrozenEnergy.amount.toString(),
+            expiredAt: legacyFrozenEnergy.expiredAt.toISOString(),
+          }
+        : undefined,
+    },
+    votes,
+    tronPower,
+    energy: energy.toString(),
+    bandwidth: {
+      freeUsed: bandwidth.freeUsed.toString(),
+      freeLimit: bandwidth.freeLimit.toString(),
+      gainedUsed: bandwidth.gainedUsed.toString(),
+      gainedLimit: bandwidth.gainedLimit.toString(),
+    },
+    unwithdrawnReward: unwithdrawnReward.toString(),
+    lastWithdrawnRewardDate: lastWithdrawnRewardDate
+      ? lastWithdrawnRewardDate.toISOString()
+      : undefined,
+    lastVotedDate: lastVotedDate ? lastVotedDate.toISOString() : undefined,
+    cacheTransactionInfoById,
+  };
+};
+export const fromTronResourcesRaw = ({
+  frozen,
+  unFrozen,
+  delegatedFrozen,
+  legacyFrozen,
+  votes,
+  tronPower,
+  energy,
+  bandwidth,
+  unwithdrawnReward,
+  lastWithdrawnRewardDate,
+  lastVotedDate,
+  cacheTransactionInfoById: cacheTransactionInfoByIdRaw,
+}: TronResourcesRaw): TronResources => {
+  const frozenBandwidth = frozen.bandwidth;
+  const frozenEnergy = frozen.energy;
+  const delegatedFrozenBandwidth = delegatedFrozen.bandwidth;
+  const delegatedFrozenEnergy = delegatedFrozen.energy;
+  const unFrozenBandwidth = unFrozen?.bandwidth;
+  const unFrozenEnergy = unFrozen?.energy;
+  const legacyFrozenBandwidth = legacyFrozen?.bandwidth;
+  const legacyFrozenEnergy = legacyFrozen?.energy;
+
+  const cacheTransactionInfoById: Record<string, TronTransactionInfo> = {};
+
+  if (cacheTransactionInfoByIdRaw) {
+    for (const k in cacheTransactionInfoByIdRaw) {
+      const [fee, blockNumber, withdraw_amount, unfreeze_amount] = cacheTransactionInfoByIdRaw[k];
+      cacheTransactionInfoById[k] = {
+        fee,
+        blockNumber,
+        withdraw_amount,
+        unfreeze_amount,
+      };
+    }
+  }
+
+  return {
+    frozen: {
+      bandwidth: frozenBandwidth
+        ? {
+            amount: new BigNumber(frozenBandwidth.amount),
+          }
+        : undefined,
+      energy: frozenEnergy
+        ? {
+            amount: new BigNumber(frozenEnergy.amount),
+          }
+        : undefined,
+    },
+    delegatedFrozen: {
+      bandwidth: delegatedFrozenBandwidth
+        ? {
+            amount: new BigNumber(delegatedFrozenBandwidth.amount),
+          }
+        : undefined,
+      energy: delegatedFrozenEnergy
+        ? {
+            amount: new BigNumber(delegatedFrozenEnergy.amount),
+          }
+        : undefined,
+    },
+    unFrozen: {
+      bandwidth: unFrozenBandwidth
+        ? unFrozenBandwidth.map(entry => {
+            return { amount: new BigNumber(entry.amount), expireTime: new Date(entry.expireTime) };
+          })
+        : undefined,
+      energy: unFrozenEnergy
+        ? unFrozenEnergy.map(entry => {
+            return { amount: new BigNumber(entry.amount), expireTime: new Date(entry.expireTime) };
+          })
+        : undefined,
+    },
+    legacyFrozen: {
+      bandwidth: legacyFrozenBandwidth
+        ? {
+            amount: new BigNumber(legacyFrozenBandwidth.amount),
+            expiredAt: new Date(legacyFrozenBandwidth.expiredAt),
+          }
+        : undefined,
+      energy: legacyFrozenEnergy
+        ? {
+            amount: new BigNumber(legacyFrozenEnergy.amount),
+            expiredAt: new Date(legacyFrozenEnergy.expiredAt),
+          }
+        : undefined,
+    },
+    votes,
+    tronPower,
+    energy: new BigNumber(energy),
+    bandwidth: {
+      freeUsed: new BigNumber(bandwidth.freeUsed),
+      freeLimit: new BigNumber(bandwidth.freeLimit),
+      gainedUsed: new BigNumber(bandwidth.gainedUsed),
+      gainedLimit: new BigNumber(bandwidth.gainedLimit),
+    },
+    unwithdrawnReward: new BigNumber(unwithdrawnReward),
+    lastWithdrawnRewardDate: lastWithdrawnRewardDate
+      ? new Date(lastWithdrawnRewardDate)
+      : undefined,
+    lastVotedDate: lastVotedDate ? new Date(lastVotedDate) : undefined,
+    cacheTransactionInfoById,
+  };
+};
+
+export function assignToAccountRaw(account: Account, accountRaw: AccountRaw) {
+  const tronAccount = account as TronAccount;
+  if (tronAccount.tronResources) {
+    (accountRaw as TronAccountRaw).tronResources = toTronResourcesRaw(tronAccount.tronResources);
+  }
+}
+
+export function assignFromAccountRaw(accountRaw: AccountRaw, account: Account) {
+  const tronResourcesRaw = (accountRaw as TronAccountRaw).tronResources;
+  if (tronResourcesRaw)
+    (account as TronAccount).tronResources = fromTronResourcesRaw(tronResourcesRaw);
+}
+
+export function fromOperationExtraRaw(extraRaw: OperationExtraRaw): TrongridExtraTxInfo {
+  const extra: TrongridExtraTxInfo = {};
+  if (!isTrongridExtraTxInfoRaw(extraRaw)) {
+    return extra;
+  }
+
+  if (extraRaw.frozenAmount) {
+    extra.frozenAmount = new BigNumber(extraRaw.frozenAmount);
+  }
+
+  if (extraRaw.unfreezeAmount) {
+    extra.unfreezeAmount = new BigNumber(extraRaw.unfreezeAmount);
+  }
+
+  if (extraRaw.votes) {
+    extra.votes = extraRaw.votes;
+  }
+
+  if (extraRaw.unDelegatedAmount) {
+    extra.unDelegatedAmount = new BigNumber(extraRaw.unDelegatedAmount);
+  }
+
+  if (extraRaw.receiverAddress) {
+    extra.receiverAddress = extraRaw.receiverAddress;
+  }
+
+  return extra;
+}
+
+export function toOperationExtraRaw(extra: OperationExtra): TrongridExtraTxInfoRaw {
+  const extraRaw: TrongridExtraTxInfoRaw = {};
+  if (!isTrongridExtraTxInfo(extra)) {
+    return extraRaw;
+  }
+
+  if (extra.frozenAmount) {
+    extraRaw.frozenAmount = extra.frozenAmount.toString();
+  }
+
+  if (extra.unfreezeAmount) {
+    extraRaw.unfreezeAmount = extra.unfreezeAmount.toString();
+  }
+
+  if (extra.votes) {
+    extraRaw.votes = extra.votes;
+  }
+
+  if (extra.unDelegatedAmount) {
+    extraRaw.unDelegatedAmount = extra.unDelegatedAmount.toString();
+  }
+
+  if (extra.receiverAddress) {
+    extraRaw.receiverAddress = extra.receiverAddress;
+  }
+
+  return extraRaw;
+}