@aeternity/aepp-sdk 12.0.0 → 12.1.0

package/src/tx/validator.ts

@@ -1,226 +1,230 @@
-import { verify, hash } from '../utils/crypto'
-import { encode, decode } from './builder/helpers'
-import BigNumber from 'bignumber.js'
+import BigNumber from 'bignumber.js';
+import { hash, verify } from '../utils/crypto';
 import {
-  PROTOCOL_VM_ABI, RawTxObject, TxSchema, TxParamsCommon, TX_TYPE, TxTypeSchemas, CtVersion
-} from './builder/schema'
-import { TxUnpacked, unpackTx } from './builder'
-import calculateMinFee from './min-fee'
-import { UnsupportedProtocolError } from '../utils/errors'
-import { concatBuffers, isKeyOfObject } from '../utils/other'
-import { EncodedData } from '../utils/encoder'
-import Node from '../Node'
+  CtVersion,
+  PROTOCOL_VM_ABI,
+  RawTxObject,
+  TxParamsCommon,
+  TxSchema,
+  TxTypeSchemas,
+} from './builder/schema';
+import { Tag } from './builder/constants';
+import { TxUnpacked, unpackTx } from './builder';
+import { UnsupportedProtocolError } from '../utils/errors';
+import { concatBuffers, isKeyOfObject } from '../utils/other';
+import {
+  decode, encode, Encoded, Encoding,
+} from '../utils/encoder';
+import Node from '../Node';
 
 interface Account {
-  balance: bigint
-  id: EncodedData<'ak'>
-  nonce: number
+  balance: bigint;
+  id: Encoded.AccountAddress;
+  nonce: number;
 }
 
 export interface ValidatorResult {
-  message: string
-  key: string
-  checkedKeys: string[]
+  message: string;
+  key: string;
+  checkedKeys: string[];
 }
 
 type Validator = (
   tx: {
-    encodedTx: TxUnpacked<TxSchema>
-    signatures: Buffer[]
+    encodedTx: TxUnpacked<TxSchema>;
+    signatures: Buffer[];
     tx: TxUnpacked<TxSchema> & {
-      tx: TxTypeSchemas[TX_TYPE.signed]
-    }
-    nonce?: number
-    ttl?: number
-    amount?: number
-    fee?: number
-    nameFee?: number
-    ctVersion?: Partial<CtVersion>
-    abiVersion?: number
-    contractId?: EncodedData<'ct'>
+      tx: TxTypeSchemas[Tag.SignedTx];
+    };
+    nonce?: number;
+    ttl?: number;
+    amount?: number;
+    fee?: number;
+    nameFee?: number;
+    ctVersion?: Partial<CtVersion>;
+    abiVersion?: number;
+    contractId?: Encoded.ContractAddress;
   },
   options: {
-    account?: Account
-    nodeNetworkId: string
-    parentTxTypes: TX_TYPE[]
-    node: Node
-    txType: TX_TYPE
-    height: number
-    consensusProtocolVersion: number
+    account?: Account;
+    nodeNetworkId: string;
+    parentTxTypes: Tag[];
+    node: Node;
+    txType: Tag;
+    height: number;
+    consensusProtocolVersion: number;
   }
-) => ValidatorResult[] | Promise<ValidatorResult[]>
+) => ValidatorResult[] | Promise<ValidatorResult[]>;
+
+const validators: Validator[] = [];
 
-const validators: Validator[] = [
+const getSenderAddress = (
+  tx: TxParamsCommon | RawTxObject<TxSchema>,
+): Encoded.AccountAddress | undefined => [
+  'senderId', 'accountId', 'ownerId', 'callerId',
+  'oracleId', 'fromId', 'initiator', 'gaId', 'payerId',
+]
+  .map((key: keyof TxSchema) => tx[key])
+  .filter((a) => a)
+  .map((a) => a?.toString().replace(/^ok_/, 'ak_'))[0] as Encoded.AccountAddress | undefined;
+
+/**
+ * Transaction Validator
+ * This function validates some of transaction properties,
+ * to make sure it can be posted it to the chain
+ * @category transaction builder
+ * @param transaction - Base64Check-encoded transaction
+ * @param node - Node to validate transaction against
+ * @param parentTxTypes - Types of parent transactions
+ * @returns Array with verification errors
+ * @example const errors = await verifyTransaction(transaction, node)
+ */
+export default async function verifyTransaction(
+  transaction: Encoded.Transaction | Encoded.Poi,
+  node: Node,
+  parentTxTypes: Tag[] = [],
+): Promise<ValidatorResult[]> {
+  const { tx, txType } = unpackTx<Tag.SignedTx>(transaction);
+  const address = getSenderAddress(tx)
+    ?? (txType === Tag.SignedTx ? getSenderAddress(tx.encodedTx.tx) : undefined);
+  const [account, { height }, { consensusProtocolVersion, nodeNetworkId }] = await Promise.all([
+    address == null
+      ? undefined
+      : node.getAccountByPubkey(address)
+        .catch(() => ({ id: address, balance: 0n, nonce: 0 }))
+        // TODO: remove after fixing https://github.com/aeternity/aepp-sdk-js/issues/1537
+        .then((acc) => ({ ...acc, id: acc.id as Encoded.AccountAddress })),
+    node.getCurrentKeyBlockHeight(),
+    node.getNodeInfo(),
+  ]);
+
+  return (await Promise.all(
+    validators.map((v) => v(
+      tx as any,
+      {
+        txType, node, account, height, consensusProtocolVersion, nodeNetworkId, parentTxTypes,
+      },
+    )),
+  )).flat();
+}
+
+validators.push(
   ({ encodedTx, signatures }, { account, nodeNetworkId, parentTxTypes }) => {
-    if ((encodedTx ?? signatures) === undefined) return []
-    if (account == null) return []
-    if (signatures.length !== 1) return [] // TODO: Support multisignature?
+    if ((encodedTx ?? signatures) === undefined) return [];
+    if (account == null) return [];
+    if (signatures.length !== 1) return []; // TODO: Support multisignature?
     const prefix = Buffer.from([
       nodeNetworkId,
-      ...parentTxTypes.includes(TX_TYPE.payingFor) ? ['inner_tx'] : []
-    ].join('-'))
-    const txWithNetworkId = concatBuffers([prefix, encodedTx.rlpEncoded])
-    const txHashWithNetworkId = concatBuffers([prefix, hash(encodedTx.rlpEncoded)])
-    const decodedPub = decode(account.id)
-    if (verify(txWithNetworkId, signatures[0], decodedPub) ||
-      verify(txHashWithNetworkId, signatures[0], decodedPub)) return []
+      ...parentTxTypes.includes(Tag.PayingForTx) ? ['inner_tx'] : [],
+    ].join('-'));
+    const txWithNetworkId = concatBuffers([prefix, encodedTx.rlpEncoded]);
+    const txHashWithNetworkId = concatBuffers([prefix, hash(encodedTx.rlpEncoded)]);
+    const decodedPub = decode(account.id);
+    if (verify(txWithNetworkId, signatures[0], decodedPub)
+      || verify(txHashWithNetworkId, signatures[0], decodedPub)) return [];
     return [{
-      message: 'Signature cannot be verified, please ensure that you transaction have' +
-        ' the correct prefix and the correct private key for the sender address',
+      message: 'Signature cannot be verified, please ensure that you transaction have'
+        + ' the correct prefix and the correct private key for the sender address',
       key: 'InvalidSignature',
-      checkedKeys: ['encodedTx', 'signatures']
-    }]
+      checkedKeys: ['encodedTx', 'signatures'],
+    }];
   },
   async ({ encodedTx, tx }, { node, parentTxTypes, txType }) => {
-    if ((encodedTx ?? tx) === undefined) return []
-    return await verifyTransaction(
-      encode((encodedTx ?? tx).rlpEncoded, 'tx'),
+    if ((encodedTx ?? tx) === undefined) return [];
+    return verifyTransaction(
+      encode((encodedTx ?? tx).rlpEncoded, Encoding.Transaction),
       node,
-      [...parentTxTypes, txType]
-    )
-  },
-  (tx: any, { txType }) => {
-    if (tx.fee === undefined) return []
-    const minFee = calculateMinFee(txType, { params: tx, vsn: tx.VSN })
-    if (minFee.lte(tx.fee)) return []
-    return [{
-      message: `Fee ${tx.fee as string} is too low, minimum fee for this transaction is ${minFee.toString()}`,
-      key: 'InsufficientFee',
-      checkedKeys: ['fee']
-    }]
+      [...parentTxTypes, txType],
+    );
   },
   ({ ttl }, { height }) => {
-    if (ttl === undefined) return []
-    ttl = +ttl
-    if (ttl === 0 || ttl >= height) return []
+    if (ttl === undefined) return [];
+    ttl = +ttl;
+    if (ttl === 0 || ttl >= height) return [];
     return [{
       message: `TTL ${ttl} is already expired, current height is ${height}`,
       key: 'ExpiredTTL',
-      checkedKeys: ['ttl']
-    }]
+      checkedKeys: ['ttl'],
+    }];
   },
-  ({ amount, fee, nameFee, tx }, { account, parentTxTypes, txType }) => {
-    if (account == null) return []
-    if ((amount ?? fee ?? nameFee) === undefined) return []
-    fee ??= 0
+  ({
+    amount, fee, nameFee, tx,
+  }, { account, parentTxTypes, txType }) => {
+    if (account == null) return [];
+    if ((amount ?? fee ?? nameFee) === undefined) return [];
+    fee ??= 0;
     const cost = new BigNumber(fee).plus(nameFee ?? 0).plus(amount ?? 0)
-      .plus(txType === TX_TYPE.payingFor ? (tx.tx.encodedTx.tx).fee : 0)
-      .minus(parentTxTypes.includes(TX_TYPE.payingFor) ? fee : 0)
-    if (cost.lte(account.balance.toString())) return []
+      .plus(txType === Tag.PayingForTx ? (tx.tx.encodedTx.tx).fee : 0)
+      .minus(parentTxTypes.includes(Tag.PayingForTx) ? fee : 0);
+    if (cost.lte(account.balance.toString())) return [];
     return [{
       message: `Account balance ${account.balance.toString()} is not enough to execute the transaction that costs ${cost.toFixed()}`,
       key: 'InsufficientBalance',
-      checkedKeys: ['amount', 'fee', 'nameFee']
-    }]
+      checkedKeys: ['amount', 'fee', 'nameFee'],
+    }];
   },
   ({ nonce }, { account, parentTxTypes }) => {
-    if (nonce == null || account == null || parentTxTypes.includes(TX_TYPE.gaMeta)) return []
-    nonce = +nonce
-    const validNonce = account.nonce + 1
-    if (nonce === validNonce) return []
+    if (nonce == null || account == null || parentTxTypes.includes(Tag.GaMetaTx)) return [];
+    nonce = +nonce;
+    const validNonce = account.nonce + 1;
+    if (nonce === validNonce) return [];
     return [{
       ...nonce < validNonce
         ? {
-            message: `Nonce ${nonce} is already used, valid nonce is ${validNonce}`,
-            key: 'NonceAlreadyUsed'
-          }
+          message: `Nonce ${nonce} is already used, valid nonce is ${validNonce}`,
+          key: 'NonceAlreadyUsed',
+        }
         : {
-            message: `Nonce ${nonce} is too high, valid nonce is ${validNonce}`,
-            key: 'NonceHigh'
-          },
-      checkedKeys: ['nonce']
-    }]
+          message: `Nonce ${nonce} is too high, valid nonce is ${validNonce}`,
+          key: 'NonceHigh',
+        },
+      checkedKeys: ['nonce'],
+    }];
   },
   ({ ctVersion, abiVersion }, { txType, consensusProtocolVersion }) => {
     if (!isKeyOfObject(consensusProtocolVersion, PROTOCOL_VM_ABI)) {
-      throw new UnsupportedProtocolError(`Unsupported protocol: ${consensusProtocolVersion}`)
+      throw new UnsupportedProtocolError(`Unsupported protocol: ${consensusProtocolVersion}`);
     }
-    const protocol = PROTOCOL_VM_ABI[consensusProtocolVersion]
+    const protocol = PROTOCOL_VM_ABI[consensusProtocolVersion];
 
     // If not contract create tx
-    if (ctVersion == null) ctVersion = { abiVersion }
-    const txProtocol = protocol[txType as keyof typeof protocol]
-    if (txProtocol == null) return []
+    if (ctVersion == null) ctVersion = { abiVersion };
+    const txProtocol = protocol[txType as keyof typeof protocol];
+    if (txProtocol == null) return [];
     if (Object.entries(ctVersion).some(
       ([
         key,
-        value
+        value,
       ]: [
         key:keyof typeof txProtocol,
-        value:any]) => !(txProtocol[key].includes(+value as never)))) {
+        value:any]) => !(txProtocol[key].includes(+value as never)),
+    )) {
       return [{
         message: `ABI/VM version ${JSON.stringify(ctVersion)} is wrong, supported is: ${JSON.stringify(txProtocol)}`,
         key: 'VmAndAbiVersionMismatch',
-        checkedKeys: ['ctVersion', 'abiVersion']
-      }]
+        checkedKeys: ['ctVersion', 'abiVersion'],
+      }];
     }
-    return []
+    return [];
   },
   async ({ contractId }, { txType, node }) => {
-    if (TX_TYPE.contractCall !== txType) return []
-    contractId = contractId as EncodedData<'ct'>
+    if (Tag.ContractCallTx !== txType) return [];
+    contractId = contractId as Encoded.ContractAddress;
     try {
-      const { active } = await node.getContract(contractId)
-      if (active) return []
+      const { active } = await node.getContract(contractId);
+      if (active) return [];
       return [{
         message: `Contract ${contractId} is not active`,
         key: 'ContractNotActive',
-        checkedKeys: ['contractId']
-      }]
+        checkedKeys: ['contractId'],
+      }];
     } catch (error) {
-      if (error.response?.parsedBody?.reason == null) throw error
+      if (error.response?.parsedBody?.reason == null) throw error;
       return [{
         message: error.response.parsedBody.reason,
         key: 'ContractNotFound',
-        checkedKeys: ['contractId']
-      }]
+        checkedKeys: ['contractId'],
+      }];
     }
-  }
-]
-
-const getSenderAddress = (
-  tx: TxParamsCommon | RawTxObject<TxSchema>
-): EncodedData<'ak'> | undefined => [
-  'senderId', 'accountId', 'ownerId', 'callerId',
-  'oracleId', 'fromId', 'initiator', 'gaId', 'payerId'
-]
-  .map((key: keyof TxSchema) => tx[key])
-  .filter(a => a)
-  .map((a) => a?.toString().replace(/^ok_/, 'ak_'))[0] as EncodedData<'ak'> | undefined
-
-/**
- * Transaction Validator
- * This function validates some of transaction properties,
- * to make sure it can be posted it to the chain
- * @param transaction - Base64Check-encoded transaction
- * @param node - Node to validate transaction against
- * @param parentTxTypes - Types of parent transactions
- * @returns Array with verification errors
- * @example const errors = await verifyTransaction(transaction, node)
- */
-export default async function verifyTransaction (
-  transaction: EncodedData<'tx' | 'pi'>,
-  node: Node,
-  parentTxTypes: TX_TYPE[] = []
-): Promise<ValidatorResult[]> {
-  const { tx, txType } = unpackTx<TX_TYPE.signed>(transaction)
-  const address = getSenderAddress(tx) ??
-    (txType === TX_TYPE.signed ? getSenderAddress(tx.encodedTx.tx) : undefined)
-  const [account, { height }, { consensusProtocolVersion, nodeNetworkId }] = await Promise.all([
-    address == null
-      ? undefined
-      : node.getAccountByPubkey(address)
-        .catch(() => ({ id: address, balance: 0n, nonce: 0 }))
-        // TODO: remove after fixing https://github.com/aeternity/aepp-sdk-js/issues/1537
-        .then(acc => ({ ...acc, id: acc.id as EncodedData<'ak'> })),
-    node.getCurrentKeyBlockHeight(),
-    node.getNodeInfo()
-  ])
-
-  return (await Promise.all(
-    validators.map(v => v(
-      tx as any,
-      { txType, node, account, height, consensusProtocolVersion, nodeNetworkId, parentTxTypes }
-    ))
-  )).flat()
-}
+  },
+);

package/src/typings/@aeternity__argon2-browser/index.d.ts

@@ -1,3 +1,3 @@
 declare module '@aeternity/argon2-browser/dist/argon2-bundled.min.js' {
-  export * from 'argon2-browser'
+  export * from 'argon2-browser';
 }

package/src/typings/@aeternity__uuid/index.d.ts

@@ -1,3 +1,5 @@
 declare module '@aeternity/uuid' {
-  export * from 'uuid'
+  // Already depends on @types/uuid
+  // eslint-disable-next-line import/no-extraneous-dependencies
+  export * from 'uuid';
 }

package/src/typings/bip32-path/index.d.ts

@@ -2,32 +2,32 @@
 
 declare module 'bip32-path' {
   interface BipPath {
-    toPathArray: () => number[]
+    toPathArray: () => number[];
     /**
      * returns a text encoded path. Set to noRoot to true to omit the m/ prefix.
      * Set oldStyle true to use h instead of ' for marking hardened nodes.
      */
-    toString: (noRoot: boolean, oldStyle: boolean) => string
+    toString: (noRoot: boolean, oldStyle: boolean) => string;
 
     /**
      * returns true if the input is a valid path string
      */
-    validateString: (path: string) => boolean
+    validateString: (path: string) => boolean;
 
     /**
      * returns true if the input is a valid binary path array
      */
-    validatePathArray: (path: string) => boolean
+    validatePathArray: (path: string) => boolean;
   }
 
   /**
    * creates an instance from a path written as text.
    * Set reqRoot to true if the m/ prefix is mandatory.
    */
-  export const fromString: (text: string, reqRoot?: boolean) => BipPath
+  export const fromString: (text: string, reqRoot?: boolean) => BipPath;
 
   /**
    * creates an instance from a binary path array
    */
-  export const fromPathArray: (path: string) => BipPath
+  export const fromPathArray: (path: string) => BipPath;
 }

package/src/typings/blakejs/index.d.ts

@@ -1,33 +1,5 @@
-declare module 'blakejs' {
-  interface Context {
-    b: Uint8Array
-    h: Uint32Array
-    t: number
-    c: number
-    outlen: number
-  }
-
-  export type Data = Buffer | Uint8Array | string
-
-  type Key = Uint8Array | null
-
-  export const blake2b: (data: Data, key?: Key, outlen?: number) => Uint8Array
-
-  export const blake2bFinal: (context: Context) => Uint8Array
-
-  export const blake2bHex: (data: Data, key?: Key, outlen?: number) => string
-
-  export const blake2bInit: (outlen?: number, key?: Key) => Context
-
-  export const blake2bUpdate: (context: Context, data: Data) => void
-
-  export const blake2s: (data: Data, key?: Key, outlen?: number) => Uint8Array
-
-  export const blake2sFinal: (context: Context) => Uint8Array
-
-  export const blake2sHex: (data: Data, key?: Key, outlen?: number) => string
-
-  export const blake2sInit: (outlen?: number, key?: Key) => Context
-
-  export const blake2sUpdate: (context: Context, data: Data) => void
+declare module 'blakejs/blake2b.js' {
+  export {
+    Blake2bCTX, blake2bInit, blake2bUpdate, blake2bFinal, blake2b, blake2bHex,
+  } from 'blakejs';
 }

package/src/typings/sha-js/index.d.ts

@@ -0,0 +1,5 @@
+declare module 'sha.js/sha256.js' {
+  import { sha256 } from 'sha.js';
+
+  export default sha256;
+}

package/src/typings/tweetnacl-auth/index.d.ts

@@ -5,10 +5,10 @@ declare module 'tweetnacl-auth' {
    * Authenticates the given message with the secret key.
    * (In other words, returns HMAC-SHA-512-256 of the message under the key.)
    */
-  export default function (message: Uint8Array, key: Uint8Array): Uint8Array
+  export default function (message: Uint8Array, key: Uint8Array): Uint8Array;
 
   /**
    * Returns HMAC-SHA-512 (without truncation) of the message under the key
    */
-  export const full: (message: Uint8Array, key: Uint8Array) => Uint8Array
+  export const full: (message: Uint8Array, key: Uint8Array) => Uint8Array;
 }

package/src/utils/amount-formatter.ts

@@ -14,9 +14,9 @@
  *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  *  PERFORMANCE OF THIS SOFTWARE.
  */
-import BigNumber from 'bignumber.js'
-import { isBigNumber } from './bignumber'
-import { ArgumentError } from './errors'
+import BigNumber from 'bignumber.js';
+import { isBigNumber } from './bignumber';
+import { ArgumentError } from './errors';
 
 export enum AE_AMOUNT_FORMATS {
   AE = 'ae',
@@ -25,7 +25,7 @@ export enum AE_AMOUNT_FORMATS {
   NANO_AE = 'nanoAE',
   PICO_AE = 'picoAE',
   FEMTO_AE = 'femtoAE',
-  AETTOS = 'aettos'
+  AETTOS = 'aettos',
 }
 
 /**
@@ -38,77 +38,77 @@ const DENOMINATION_MAGNITUDE = {
   [AE_AMOUNT_FORMATS.NANO_AE]: -9,
   [AE_AMOUNT_FORMATS.PICO_AE]: -12,
   [AE_AMOUNT_FORMATS.FEMTO_AE]: -15,
-  [AE_AMOUNT_FORMATS.AETTOS]: -18
-} as const
+  [AE_AMOUNT_FORMATS.AETTOS]: -18,
+} as const;
 
 /**
- * Convert amount to AE
+ * Convert amount from one to other denomination
  * @param value - amount to convert
  * @param options - options
  * @param options.denomination - denomination of amount, can be ['ae', 'aettos']
+ * @param options.targetDenomination - target denomination,
+ * can be ['ae', 'aettos']
  */
-export const toAe = (
-  value: string | number | BigNumber,
-  { denomination = AE_AMOUNT_FORMATS.AETTOS }: { denomination?: AE_AMOUNT_FORMATS } = {}
-): string => formatAmount(value, { denomination, targetDenomination: AE_AMOUNT_FORMATS.AE })
+export const formatAmount = (
+  value: string | number | bigint | BigNumber,
+  { denomination = AE_AMOUNT_FORMATS.AETTOS, targetDenomination = AE_AMOUNT_FORMATS.AETTOS }:
+  { denomination?: AE_AMOUNT_FORMATS; targetDenomination?: AE_AMOUNT_FORMATS },
+): string => {
+  if (!isBigNumber(value)) throw new ArgumentError('value', 'a number', value);
+
+  return new BigNumber(typeof value === 'bigint' ? value.toString() : value)
+    .shiftedBy(DENOMINATION_MAGNITUDE[denomination] - DENOMINATION_MAGNITUDE[targetDenomination])
+    .toFixed();
+};
 
 /**
- * Convert amount to aettos
+ * Convert amount to AE
  * @param value - amount to convert
  * @param options - options
  * @param options.denomination - denomination of amount, can be ['ae', 'aettos']
  */
-export const toAettos = (
+export const toAe = (
   value: string | number | BigNumber,
-  { denomination = AE_AMOUNT_FORMATS.AE }: { denomination?: AE_AMOUNT_FORMATS } = {}
-): string => formatAmount(value, { denomination })
+  { denomination = AE_AMOUNT_FORMATS.AETTOS }: { denomination?: AE_AMOUNT_FORMATS } = {},
+): string => formatAmount(value, { denomination, targetDenomination: AE_AMOUNT_FORMATS.AE });
 
 /**
- * Convert amount from one to other denomination
+ * Convert amount to aettos
  * @param value - amount to convert
  * @param options - options
  * @param options.denomination - denomination of amount, can be ['ae', 'aettos']
- * @param options.targetDenomination - target denomination,
- * can be ['ae', 'aettos']
  */
-export const formatAmount = (
-  value: string | number | bigint | BigNumber,
-  { denomination = AE_AMOUNT_FORMATS.AETTOS, targetDenomination = AE_AMOUNT_FORMATS.AETTOS }:
-  { denomination?: AE_AMOUNT_FORMATS, targetDenomination?: AE_AMOUNT_FORMATS }
-): string => {
-  if (!isBigNumber(value)) throw new ArgumentError('value', 'a number', value)
-
-  return new BigNumber(typeof value === 'bigint' ? value.toString() : value)
-    .shiftedBy(DENOMINATION_MAGNITUDE[denomination] - DENOMINATION_MAGNITUDE[targetDenomination])
-    .toFixed()
-}
+export const toAettos = (
+  value: string | number | BigNumber,
+  { denomination = AE_AMOUNT_FORMATS.AE }: { denomination?: AE_AMOUNT_FORMATS } = {},
+): string => formatAmount(value, { denomination });
 
 interface Prefix {
-  name: string
-  magnitude: number
+  name: string;
+  magnitude: number;
 }
 
 const prefixes: Prefix[] = [
   { name: 'exa', magnitude: 18 },
   { name: 'giga', magnitude: 9 },
   { name: '', magnitude: 0 },
-  { name: 'pico', magnitude: -12 }
-]
+  { name: 'pico', magnitude: -12 },
+];
 
 const getNearestPrefix = (exponent: number): Prefix => prefixes.reduce((p, n) => (
-  Math.abs(n.magnitude - exponent) < Math.abs(p.magnitude - exponent) ? n : p))
+  Math.abs(n.magnitude - exponent) < Math.abs(p.magnitude - exponent) ? n : p));
 
 const getLowerBoundPrefix = (exponent: number): Prefix => prefixes
-  .find(p => p.magnitude <= exponent) ?? prefixes[prefixes.length - 1]
+  .find((p) => p.magnitude <= exponent) ?? prefixes[prefixes.length - 1];
 
 export default (rawValue: string | number | BigNumber): string => {
-  const value: BigNumber = new BigNumber(rawValue)
+  const value: BigNumber = new BigNumber(rawValue);
 
-  const exp = value.e ?? 0
-  const { name, magnitude } = (exp < 0 ? getNearestPrefix : getLowerBoundPrefix)(exp)
+  const exp = value.e ?? 0;
+  const { name, magnitude } = (exp < 0 ? getNearestPrefix : getLowerBoundPrefix)(exp);
   const v = value
     .shiftedBy(-magnitude)
     .precision(9 + Math.min(exp - magnitude, 0))
-    .toFixed()
-  return `${v}${name !== '' ? ' ' : ''}${name}`
-}
+    .toFixed();
+  return `${v}${name !== '' ? ' ' : ''}${name}`;
+};