@aeternity/aepp-sdk 13.3.3 → 14.0.0

package/src/tx/execution-cost.ts

@@ -1,164 +0,0 @@
-import { Encoded } from '../utils/encoder';
-import { buildTx, buildTxHash, unpackTx } from './builder';
-import { Tag } from './builder/constants';
-import { verify } from '../utils/crypto';
-import { getBufferToSign } from '../account/Memory';
-import { IllegalArgumentError, InternalError, TransactionError } from '../utils/errors';
-import Node from '../Node';
-import getTransactionSignerAddress from './transaction-signer';
-
-/**
- * Calculates the cost of transaction execution
- * Provides an upper cost of contract-call-related transactions because of `gasLimit`.
- * Also assumes that oracle query fee is 0 unless it is provided in options.
- *
- * The idea is that if you need to show transaction details with some accuracy you can define
- * expense fields that you want to show separately. And to show `getExecutionCost` result as a fee,
- * subtracting all fields shown separately.
- *
- * @example
- * ```vue
- * <template>
- * Amount: {{ txUnpacked.amount }}
- * Name fee: {{ txUnpacked.nameFee }}
- * Other fees: {{ getExecutionCost(txEncoded) - txUnpacked.amount - txUnpacked.nameFee }}
- * </template>
- * ```
- *
- * Doing this way you won't worry to show wrong fee for a transaction you may not support. Because
- * the SDK calculates the overall price of any transaction on its side.
- *
- * @param transaction - Transaction to calculate the cost of
- * @param options - Options
- * @param options.innerTx - Should be provided if transaction wrapped with Tag.PayingForTx
- * @param options.gasUsed - Amount of gas actually used to make calculation more accurate
- * @param options.queryFee - Oracle query fee
- * @param options.isInitiator - Is transaction signer an initiator of state channel
- */
-export function getExecutionCost(
-  transaction: Encoded.Transaction,
-  {
-    innerTx, gasUsed, queryFee, isInitiator,
-  }: {
-    innerTx?: 'fee-payer' | 'freeloader';
-    gasUsed?: number;
-    queryFee?: string;
-    isInitiator?: boolean;
-  } = {},
-): bigint {
-  const params = unpackTx(transaction);
-  if (params.tag === Tag.SignedTx) {
-    throw new IllegalArgumentError('Transaction shouldn\'t be a SignedTx, use `getExecutionCostBySignedTx` instead');
-  }
-
-  let res = 0n;
-  if ('fee' in params && innerTx !== 'freeloader') {
-    res += BigInt(params.fee);
-  }
-  if (params.tag === Tag.NameClaimTx) {
-    res += BigInt(params.nameFee);
-  }
-  if (params.tag === Tag.OracleQueryTx) {
-    res += BigInt(params.queryFee);
-  }
-  if (params.tag === Tag.OracleResponseTx) {
-    res -= BigInt(queryFee ?? 0);
-  }
-  if (params.tag === Tag.ChannelSettleTx) {
-    if (isInitiator === true) res -= BigInt(params.initiatorAmountFinal);
-    if (isInitiator === false) res -= BigInt(params.responderAmountFinal);
-  }
-  if (
-    ((params.tag === Tag.SpendTx && params.senderId !== params.recipientId)
-    || params.tag === Tag.ContractCreateTx || params.tag === Tag.ContractCallTx
-    || params.tag === Tag.ChannelDepositTx) && innerTx !== 'fee-payer'
-  ) {
-    res += BigInt(params.amount);
-  }
-  if (params.tag === Tag.ContractCreateTx) res += BigInt(params.deposit);
-  if (
-    (params.tag === Tag.ContractCreateTx || params.tag === Tag.ContractCallTx
-      || params.tag === Tag.GaAttachTx || params.tag === Tag.GaMetaTx)
-    && innerTx !== 'freeloader'
-  ) {
-    res += BigInt(params.gasPrice) * BigInt(gasUsed ?? params.gasLimit);
-  }
-  if (params.tag === Tag.GaMetaTx || params.tag === Tag.PayingForTx) {
-    res += getExecutionCost(
-      buildTx(params.tx.encodedTx),
-      params.tag === Tag.PayingForTx ? { innerTx: 'fee-payer' } : {},
-    );
-  }
-  return res;
-}
-
-/**
- * Calculates the cost of signed transaction execution
- * @param transaction - Transaction to calculate the cost of
- * @param networkId - Network id used to sign the transaction
- * @param options - Options
- */
-export function getExecutionCostBySignedTx(
-  transaction: Encoded.Transaction,
-  networkId: string,
-  options?: Omit<Parameters<typeof getExecutionCost>[1], 'innerTx'>,
-): bigint {
-  const params = unpackTx(transaction, Tag.SignedTx);
-  if (params.encodedTx.tag === Tag.GaMetaTx) {
-    return getExecutionCost(buildTx(params.encodedTx), options);
-  }
-
-  const tx = buildTx(params.encodedTx);
-  const address = getTransactionSignerAddress(tx);
-  const [isInnerTx, isNotInnerTx] = [true, false]
-    .map((f) => verify(getBufferToSign(tx, networkId, f), params.signatures[0], address));
-  if (!isInnerTx && !isNotInnerTx) throw new TransactionError('Can\'t verify signature');
-  return getExecutionCost(
-    buildTx(params.encodedTx),
-    { ...isInnerTx && { innerTx: 'freeloader' }, ...options },
-  );
-}
-
-/**
- * Calculates the cost of signed and not signed transaction execution using node
- * @param transaction - Transaction to calculate the cost of
- * @param node - Node to use
- * @param options - Options
- * @param options.isMined - Is transaction already mined or not
- */
-export async function getExecutionCostUsingNode(
-  transaction: Encoded.Transaction,
-  node: Node,
-  { isMined, ...options }: { isMined?: boolean } & Parameters<typeof getExecutionCost>[1] = {},
-): Promise<bigint> {
-  let params = unpackTx(transaction);
-  const isSignedTx = params.tag === Tag.SignedTx;
-  const txHash = isSignedTx && isMined === true && buildTxHash(transaction);
-  if (params.tag === Tag.SignedTx) params = params.encodedTx;
-
-  // TODO: set gasUsed for PayingForTx after solving https://github.com/aeternity/aeternity/issues/4087
-  if (
-    options.gasUsed == null && txHash !== false
-    && [Tag.ContractCreateTx, Tag.ContractCallTx, Tag.GaAttachTx, Tag.GaMetaTx].includes(params.tag)
-  ) {
-    const { callInfo, gaInfo } = await node.getTransactionInfoByHash(txHash);
-    const combinedInfo = callInfo ?? gaInfo;
-    if (combinedInfo == null) {
-      throw new InternalError(`callInfo and gaInfo is not available for transaction ${txHash}`);
-    }
-    options.gasUsed = combinedInfo.gasUsed;
-  }
-
-  if (options.queryFee == null && Tag.OracleResponseTx === params.tag) {
-    options.queryFee = (await node.getOracleByPubkey(params.oracleId)).queryFee.toString();
-  }
-
-  if (options.isInitiator == null && Tag.ChannelSettleTx === params.tag && isMined !== true) {
-    const { initiatorId } = await node.getChannelByPubkey(params.channelId);
-    options.isInitiator = params.fromId === initiatorId;
-  }
-
-  return isSignedTx
-    ? getExecutionCostBySignedTx(transaction, await node.getNetworkId(), options)
-    : getExecutionCost(transaction, options);
-}

package/src/tx/transaction-signer.ts

@@ -1,27 +0,0 @@
-import { Encoded } from '../utils/encoder';
-import { buildTx, getSchema, unpackTx } from './builder';
-import { Tag } from './builder/constants';
-import { TransactionError, UnexpectedTsError } from '../utils/errors';
-
-/**
- * Returns account address that signed a transaction
- * @param transaction - transaction to get a signer of
- */
-export default function getTransactionSignerAddress(
-  transaction: Encoded.Transaction,
-): Encoded.AccountAddress {
-  const params = unpackTx(transaction);
-  switch (params.tag) {
-    case Tag.SignedTx:
-      return getTransactionSignerAddress(buildTx(params.encodedTx));
-    case Tag.GaMetaTx:
-      return params.gaId;
-    default:
-  }
-
-  const nonce = getSchema(params.tag, params.version).find(([name]) => name === 'nonce')?.[1];
-  if (nonce == null) throw new TransactionError(`Transaction doesn't have nonce: ${Tag[params.tag]}`);
-  if (!('senderKey' in nonce)) throw new UnexpectedTsError();
-  const address = params[nonce.senderKey as keyof typeof params] as unknown as string;
-  return address.replace(/^ok_/, 'ak_') as Encoded.AccountAddress;
-}

package/src/tx/validator.ts

@@ -1,222 +0,0 @@
-import { RestError } from '@azure/core-rest-pipeline';
-import { hash, isAddressValid, verify } from '../utils/crypto';
-import { TxUnpacked } from './builder/schema.generated';
-import { CtVersion, ProtocolToVmAbi } from './builder/field-types/ct-version';
-import { Tag, ConsensusProtocolVersion } from './builder/constants';
-import { buildTx, unpackTx } from './builder';
-import { concatBuffers, isAccountNotFoundError } from '../utils/other';
-import { Encoded, Encoding, decode } from '../utils/encoder';
-import Node, { TransformNodeType } from '../Node';
-import { Account } from '../apis/node';
-import { genAggressiveCacheGetResponsesPolicy } from '../utils/autorest';
-import { UnexpectedTsError } from '../utils/errors';
-import getTransactionSignerAddress from './transaction-signer';
-import { getExecutionCostUsingNode } from './execution-cost';
-
-export interface ValidatorResult {
-  message: string;
-  key: string;
-  checkedKeys: string[];
-}
-
-type Validator = (
-  tx: TxUnpacked,
-  options: {
-    // TODO: remove after fixing node types
-    account: TransformNodeType<Account> & { id: Encoded.AccountAddress };
-    nodeNetworkId: string;
-    parentTxTypes: Tag[];
-    node: Node;
-    height: number;
-    consensusProtocolVersion: ConsensusProtocolVersion;
-  }
-) => ValidatorResult[] | Promise<ValidatorResult[]>;
-
-const validators: Validator[] = [];
-
-async function verifyTransactionInternal(
-  tx: TxUnpacked,
-  node: Node,
-  parentTxTypes: Tag[],
-): Promise<ValidatorResult[]> {
-  const address = getTransactionSignerAddress(buildTx(tx));
-  const [account, { height }, { consensusProtocolVersion, nodeNetworkId }] = await Promise.all([
-    node.getAccountByPubkey(address)
-      .catch((error) => {
-        if (!isAccountNotFoundError(error)) throw error;
-        return { 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(), // TODO: don't request height on each validation, use caching
-    node.getNodeInfo(),
-  ]);
-
-  return (await Promise.all(
-    validators.map(async (v) => v(
-      tx,
-      {
-        node, account, height, consensusProtocolVersion, nodeNetworkId, parentTxTypes,
-      },
-    )),
-  )).flat();
-}
-
-/**
- * Transaction Validator
- * This function validates some transaction properties,
- * to make sure it can be posted it to the chain
- * @category transaction builder
- * @param transaction - Base64Check-encoded transaction
- * @param nodeNotCached - Node to validate transaction against
- * @returns Array with verification errors
- * @example const errors = await verifyTransaction(transaction, node)
- */
-export default async function verifyTransaction(
-  transaction: Parameters<typeof unpackTx>[0],
-  nodeNotCached: Node,
-): Promise<ValidatorResult[]> {
-  const node = new Node(nodeNotCached.$host, {
-    ignoreVersion: true,
-    pipeline: nodeNotCached.pipeline.clone(),
-    additionalPolicies: [genAggressiveCacheGetResponsesPolicy()],
-  });
-  return verifyTransactionInternal(unpackTx(transaction), node, []);
-}
-
-validators.push(
-  (tx, { account, nodeNetworkId, parentTxTypes }) => {
-    if (tx.tag !== Tag.SignedTx) return [];
-    const { encodedTx, signatures } = tx;
-    if ((encodedTx ?? signatures) == null) return [];
-    if (signatures.length !== 1) return []; // TODO: Support multisignature like in state channels
-    const prefix = Buffer.from([
-      nodeNetworkId,
-      ...parentTxTypes.includes(Tag.PayingForTx) ? ['inner_tx'] : [],
-    ].join('-'));
-    const txBinary = decode(buildTx(encodedTx));
-    const txWithNetworkId = concatBuffers([prefix, txBinary]);
-    const txHashWithNetworkId = concatBuffers([prefix, hash(txBinary)]);
-    if (verify(txWithNetworkId, signatures[0], account.id)
-      || verify(txHashWithNetworkId, signatures[0], account.id)) 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',
-      key: 'InvalidSignature',
-      checkedKeys: ['encodedTx', 'signatures'],
-    }];
-  },
-  async (tx, { node, parentTxTypes }) => {
-    let nestedTx;
-    if ('encodedTx' in tx) nestedTx = tx.encodedTx;
-    if ('tx' in tx) nestedTx = tx.tx;
-    if (nestedTx == null) return [];
-    return verifyTransactionInternal(nestedTx, node, [...parentTxTypes, tx.tag]);
-  },
-  (tx, { height }) => {
-    if (!('ttl' in tx)) return [];
-    if (tx.ttl === 0 || tx.ttl > height) return [];
-    return [{
-      message: `TTL ${tx.ttl} is already expired, current height is ${height}`,
-      key: 'ExpiredTTL',
-      checkedKeys: ['ttl'],
-    }];
-  },
-  async (tx, { account, parentTxTypes, node }) => {
-    if (parentTxTypes.length !== 0) return [];
-    const cost = await getExecutionCostUsingNode(buildTx(tx), node).catch(() => 0n);
-    if (cost <= account.balance) return [];
-    return [{
-      message: `Account balance ${account.balance} is not enough to execute the transaction that costs ${cost}`,
-      key: 'InsufficientBalance',
-      checkedKeys: ['amount', 'fee', 'nameFee', 'gasLimit', 'gasPrice'],
-    }];
-  },
-  async (tx, { node }) => {
-    if (tx.tag !== Tag.SpendTx || isAddressValid(tx.recipientId, Encoding.Name)) return [];
-    const recipient = await node.getAccountByPubkey(tx.recipientId).catch((error) => {
-      if (!isAccountNotFoundError(error)) throw error;
-      return null;
-    });
-    if (recipient == null || recipient.payable === true) return [];
-    return [{
-      message: 'Recipient account is not payable',
-      key: 'RecipientAccountNotPayable',
-      checkedKeys: ['recipientId'],
-    }];
-  },
-  (tx, { account }) => {
-    let message;
-    if (tx.tag === Tag.SignedTx && account.kind === 'generalized' && tx.signatures.length !== 0) {
-      message = 'Generalized account can\'t be used to generate SignedTx with signatures';
-    }
-    if (tx.tag === Tag.GaMetaTx && account.kind === 'basic') {
-      message = 'Basic account can\'t be used to generate GaMetaTx';
-    }
-    if (message == null) return [];
-    return [{ message, key: 'InvalidAccountType', checkedKeys: ['tag'] }];
-  },
-  // TODO: revert nonce check
-  // TODO: ensure nonce valid when paying for own tx
-  (tx, { consensusProtocolVersion }) => {
-    const oracleCall = Tag.OracleRegisterTx === tx.tag;
-    const contractCreate = Tag.ContractCreateTx === tx.tag || Tag.GaAttachTx === tx.tag;
-    const contractCall = Tag.ContractCallTx === tx.tag || Tag.GaMetaTx === tx.tag;
-    const type = (oracleCall ? 'oracle-call' : null)
-      ?? (contractCreate ? 'contract-create' : null)
-      ?? (contractCall ? 'contract-call' : null);
-    if (type == null) return [];
-    const protocol = ProtocolToVmAbi[consensusProtocolVersion][type] as {
-      abiVersion: readonly any[];
-      vmVersion: readonly any[];
-    };
-
-    let ctVersion: Partial<CtVersion> | undefined;
-    if ('abiVersion' in tx) ctVersion = { abiVersion: tx.abiVersion };
-    if ('ctVersion' in tx) ctVersion = tx.ctVersion;
-    if (ctVersion == null) throw new UnexpectedTsError();
-    if (
-      !protocol.abiVersion.includes(ctVersion.abiVersion)
-      || (contractCreate && !protocol.vmVersion.includes(ctVersion.vmVersion))
-    ) {
-      return [{
-        message: `ABI/VM version ${JSON.stringify(ctVersion)} is wrong, supported is: ${JSON.stringify(protocol)}`,
-        key: 'VmAndAbiVersionMismatch',
-        checkedKeys: ['ctVersion', 'abiVersion'],
-      }];
-    }
-    return [];
-  },
-  async (tx, { node }) => {
-    if (Tag.ContractCallTx !== tx.tag) return [];
-    // TODO: remove after solving https://github.com/aeternity/aeternity/issues/3669
-    if (tx.contractId.startsWith('nm_')) return [];
-    try {
-      const { active } = await node.getContract(tx.contractId);
-      if (active) return [];
-      return [{
-        message: `Contract ${tx.contractId} is not active`,
-        key: 'ContractNotActive',
-        checkedKeys: ['contractId'],
-      }];
-    } catch (error) {
-      if (!(error instanceof RestError) || error.response?.bodyAsText == null) throw error;
-      return [{
-        message: JSON.parse(error.response.bodyAsText).reason, // TODO: use parsedBody instead
-        key: 'ContractNotFound',
-        checkedKeys: ['contractId'],
-      }];
-    }
-  },
-  // TODO: move to fee field of tx builder after dropping Iris
-  (tx, { consensusProtocolVersion }) => ((
-    Tag.GaAttachTx === tx.tag
-      && ConsensusProtocolVersion.Ceres === consensusProtocolVersion
-      && tx.nonce !== 1
-  ) ? [{
-      message: `Account ${tx.ownerId} can't become generalized because it is already used`,
-      key: 'AccountUsed',
-      checkedKeys: ['nonce'],
-    }]
-    : []),
-);

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

@@ -1,5 +0,0 @@
-declare module '@aeternity/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

@@ -1,33 +0,0 @@
-// TODO: remove after solving https://github.com/axic/bip32-path/issues/5
-
-declare module 'bip32-path' {
-  interface BipPath {
-    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;
-
-    /**
-     * returns true if the input is a valid path string
-     */
-    validateString: (path: string) => boolean;
-
-    /**
-     * returns true if the input is a valid binary path array
-     */
-    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;
-
-  /**
-   * creates an instance from a binary path array
-   */
-  export const fromPathArray: (path: string) => BipPath;
-}

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

@@ -1,5 +0,0 @@
-declare module 'blakejs/blake2b.js' {
-  export {
-    Blake2bCTX, blake2bInit, blake2bUpdate, blake2bFinal, blake2b, blake2bHex,
-  } from 'blakejs';
-}

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

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

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

@@ -1,14 +0,0 @@
-// TODO: remove after solving https://github.com/dchest/tweetnacl-auth-js/issues/3
-
-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;
-
-  /**
-   * Returns HMAC-SHA-512 (without truncation) of the message under the key
-   */
-  export const full: (message: Uint8Array, key: Uint8Array) => Uint8Array;
-}

package/src/utils/amount-formatter.ts

@@ -1,98 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { isBigNumber } from './bignumber';
-import { ArgumentError } from './errors';
-
-export enum AE_AMOUNT_FORMATS {
-  AE = 'ae',
-  MILI_AE = 'miliAE',
-  MICRO_AE = 'microAE',
-  NANO_AE = 'nanoAE',
-  PICO_AE = 'picoAE',
-  FEMTO_AE = 'femtoAE',
-  AETTOS = 'aettos',
-}
-
-/**
- * DENOMINATION_MAGNITUDE
- */
-const DENOMINATION_MAGNITUDE = {
-  [AE_AMOUNT_FORMATS.AE]: 0,
-  [AE_AMOUNT_FORMATS.MILI_AE]: -3,
-  [AE_AMOUNT_FORMATS.MICRO_AE]: -6,
-  [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;
-
-/**
- * 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 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 AE
- * @param value - amount to convert
- * @param options - options
- * @param options.denomination - denomination of amount, 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 });
-
-/**
- * Convert amount to aettos
- * @param value - amount to convert
- * @param options - options
- * @param options.denomination - denomination of amount, can be ['ae', 'aettos']
- */
-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;
-}
-
-const prefixes: Prefix[] = [
-  { name: 'exa', magnitude: 18 },
-  { name: 'giga', magnitude: 9 },
-  { name: '', magnitude: 0 },
-  { 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));
-
-const getLowerBoundPrefix = (exponent: number): Prefix => prefixes
-  .find((p) => p.magnitude <= exponent) ?? prefixes[prefixes.length - 1];
-
-export const prefixedAmount = (rawValue: string | number | BigNumber): string => {
-  const value: BigNumber = new BigNumber(rawValue);
-
-  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}`;
-};