@aeternity/aepp-sdk 11.0.1 → 12.0.0

package/src/tx/index.ts

@@ -0,0 +1,199 @@
+/*
+ * ISC License (ISC)
+ * Copyright (c) 2022 aeternity developers
+ *
+ *  Permission to use, copy, modify, and/or distribute this software for any
+ *  purpose with or without fee is hereby granted, provided that the above
+ *  copyright notice and this permission notice appear in all copies.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+ *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ *  PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/**
+ * Transaction methods
+ *
+ * This is implementation of [Tx](api/tx.md) relays
+ * the creation of transactions to {@link Node}.
+ * These methods provide ability to create native transactions.
+ */
+import {
+  ABI_VERSIONS, CtVersion, PROTOCOL_VM_ABI, TX_TYPE, TX_TTL, TxParamsCommon
+} from './builder/schema'
+import {
+  ArgumentError, UnsupportedProtocolError, UnknownTxError, InvalidTxParamsError
+} from '../utils/errors'
+import BigNumber from 'bignumber.js'
+import Node from '../Node'
+import { EncodedData } from '../utils/encoder'
+import { buildTx as syncBuildTx, unpackTx } from './builder/index'
+import calculateMinFee from './min-fee'
+import { isKeyOfObject } from '../utils/other'
+import { AE_AMOUNT_FORMATS } from '../utils/amount-formatter'
+
+type Int = number | string | BigNumber
+
+// uses a new feature, probably typescript-eslint doesn't support it yet
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export type BuildTxOptions <TxType extends TX_TYPE, OmitFields extends string> =
+  Omit<Parameters<typeof _buildTx<TxType>>[1], OmitFields>
+
+// TODO: find a better name or rearrange methods
+export async function _buildTx<TxType extends TX_TYPE> (
+  txType: TxType,
+  { denomination, absoluteTtl, ..._params }:
+  Omit<Parameters<typeof syncBuildTx<TxType, 'tx'>>[0], 'fee' | 'nonce' | 'ttl' | 'ctVersion' | 'abiVersion'>
+  & {
+    onNode: Node
+    fee?: Int
+    nonce?: number
+    ttl?: number
+    denomination?: AE_AMOUNT_FORMATS
+    absoluteTtl?: boolean
+  }
+  & (TxType extends TX_TYPE.oracleExtend | TX_TYPE.oracleResponse ? { callerId: EncodedData<'ak'> } : {})
+  & (TxType extends TX_TYPE.contractCreate | TX_TYPE.gaAttach ? { ctVersion?: CtVersion } : {})
+  & (TxType extends TX_TYPE.contractCall | TX_TYPE.oracleRegister
+    ? { abiVersion?: ABI_VERSIONS } : {})
+): Promise<EncodedData<'tx'>> {
+  // TODO: avoid this assertion
+  const params = _params as unknown as TxParamsCommon & { onNode: Node }
+  let senderKey: keyof TxParamsCommon | '<absent>'
+  switch (txType) {
+    case TX_TYPE.spend:
+    case TX_TYPE.oracleQuery:
+      senderKey = 'senderId'
+      break
+    case TX_TYPE.nameClaim:
+    case TX_TYPE.nameUpdate:
+    case TX_TYPE.nameRevoke:
+    case TX_TYPE.nameTransfer:
+    case TX_TYPE.namePreClaim:
+    case TX_TYPE.oracleRegister:
+      senderKey = 'accountId'
+      break
+    case TX_TYPE.contractCreate:
+    case TX_TYPE.gaAttach:
+      senderKey = 'ownerId'
+      break
+    case TX_TYPE.contractCall:
+    case TX_TYPE.oracleExtend:
+    case TX_TYPE.oracleResponse:
+      senderKey = 'callerId'
+      break
+    case TX_TYPE.channelCloseSolo:
+    case TX_TYPE.channelSlash:
+    case TX_TYPE.channelSettle:
+    case TX_TYPE.channelSnapshotSolo:
+      senderKey = 'fromId'
+      break
+    case TX_TYPE.payingFor:
+      senderKey = 'payerId'
+      break
+    default:
+      throw new ArgumentError('txType', 'valid transaction type', txType)
+  }
+  // TODO: move specific cases to field-types
+  if ([TX_TYPE.contractCreate, TX_TYPE.gaAttach].includes(txType)) {
+    params.ctVersion = await getVmVersion(
+      TX_TYPE.contractCreate, { ...params, ...params.ctVersion }
+    )
+  }
+  if (txType === TX_TYPE.contractCall) {
+    params.abiVersion = (await getVmVersion(TX_TYPE.contractCall, params)).abiVersion
+  }
+  if (txType === TX_TYPE.oracleRegister) {
+    params.abiVersion ??= ABI_VERSIONS.NO_ABI
+  }
+  if (txType === TX_TYPE.payingFor) {
+    params.tx = unpackTx(params.tx)
+  }
+  const senderId = params[senderKey]
+  // TODO: do this check on TypeScript level
+  if (senderId == null) throw new InvalidTxParamsError(`Transaction field ${senderKey} is missed`)
+  const extraParams = await prepareTxParams(
+    txType, { ...params, senderId, denomination, absoluteTtl }
+  )
+  return syncBuildTx({ ...params, ...extraParams } as any, txType, { denomination }).tx
+}
+
+/**
+ * Validated vm/abi version or get default based on transaction type and NODE version
+ *
+ * @param txType - Type of transaction
+ * @param ctVersion - Object with vm and abi version fields
+ * @returns Object with vm/abi version
+ */
+export async function getVmVersion (
+  txType: TX_TYPE.contractCreate, ctVersion: Partial<CtVersion> & { onNode: Node }
+): Promise<CtVersion>
+export async function getVmVersion (
+  txType: TX_TYPE, ctVersion: Partial<Pick<CtVersion, 'abiVersion'>> & { onNode: Node }
+): Promise<Pick<CtVersion, 'abiVersion'>>
+export async function getVmVersion (
+  txType: TX_TYPE, { vmVersion, abiVersion, onNode }: Partial<CtVersion> & { onNode: Node }
+): Promise<Partial<CtVersion>> {
+  const { consensusProtocolVersion } = await onNode.getNodeInfo()
+  if (!isKeyOfObject(consensusProtocolVersion, PROTOCOL_VM_ABI)) {
+    throw new UnsupportedProtocolError('Not supported consensus protocol version')
+  }
+  const supportedProtocol = PROTOCOL_VM_ABI[consensusProtocolVersion]
+  if (!isKeyOfObject(txType, supportedProtocol)) {
+    throw new UnknownTxError('Not supported tx type')
+  }
+  const protocolForTX = supportedProtocol[txType]
+  abiVersion ??= protocolForTX.abiVersion[0]
+  vmVersion ??= protocolForTX.vmVersion[0]
+  return { vmVersion, abiVersion }
+}
+
+/**
+ * Calculate fee, get absolute ttl (ttl + height), get account nonce
+ *
+ * @param txType - Type of transaction
+ * @param params - Object which contains all tx data
+ * @returns Object with account nonce, absolute ttl and transaction fee
+ */
+export async function prepareTxParams (
+  txType: TX_TYPE,
+  {
+    senderId,
+    nonce,
+    ttl = TX_TTL,
+    fee: f,
+    absoluteTtl,
+    vsn,
+    strategy,
+    denomination,
+    onNode,
+    ...txParams
+  }: PrepareTxParamsOptions
+): Promise<{ fee: BigNumber, ttl: number, nonce: number }> {
+  nonce ??= (
+    await onNode.getAccountNextNonce(senderId, { strategy }).catch(() => ({ nextNonce: 1 }))
+  ).nextNonce
+
+  if (ttl !== 0) {
+    if (ttl < 0) throw new ArgumentError('ttl', 'greater or equal to 0', ttl)
+    ttl += absoluteTtl === true ? 0 : (await onNode.getCurrentKeyBlock()).height
+  }
+
+  const fee = f != null
+    ? new BigNumber(f)
+    : calculateMinFee(txType, { params: { ...txParams, senderId, nonce, ttl }, vsn, denomination })
+  return { fee, ttl, nonce }
+}
+
+interface PrepareTxParamsOptions extends Pick<TxParamsCommon, 'nonce' | 'ttl' | 'fee'> {
+  senderId: EncodedData<'ak'>
+  vsn?: number
+  absoluteTtl?: boolean
+  strategy?: 'continuity' | 'max'
+  denomination?: AE_AMOUNT_FORMATS
+  onNode: Node
+}

package/src/tx/min-fee.ts

@@ -0,0 +1,136 @@
+import BigNumber from 'bignumber.js'
+import { MIN_GAS_PRICE, TX_TYPE, TxParamsCommon } from './builder/schema'
+import { AE_AMOUNT_FORMATS } from '../utils/amount-formatter'
+import { buildTx } from './builder'
+import { isKeyOfObject } from '../utils/other'
+
+const BASE_GAS = 15000
+const GAS_PER_BYTE = 20
+const KEY_BLOCK_INTERVAL = 3
+
+/**
+ * Calculate the Base fee gas
+ * @see {@link https://github.com/aeternity/protocol/blob/master/consensus/README.md#gas}
+ * @param txType - The transaction type
+ * @returns The base fee
+ * @example
+ * ```js
+ * TX_FEE_BASE('channelForceProgress') => new BigNumber(30 * 15000)
+ * ```
+ */
+const TX_FEE_BASE_GAS = (txType: TX_TYPE): BigNumber => {
+  const feeFactors = {
+    [TX_TYPE.channelForceProgress]: 30,
+    [TX_TYPE.channelOffChain]: 0,
+    [TX_TYPE.channelOffChainCallContract]: 0,
+    [TX_TYPE.channelOffChainCreateContract]: 0,
+    [TX_TYPE.channelOffChainUpdateDeposit]: 0,
+    [TX_TYPE.channelOffChainUpdateWithdrawal]: 0,
+    [TX_TYPE.channelOffChainUpdateTransfer]: 0,
+    [TX_TYPE.contractCreate]: 5,
+    [TX_TYPE.contractCall]: 12,
+    [TX_TYPE.gaAttach]: 5,
+    [TX_TYPE.gaMeta]: 5,
+    [TX_TYPE.payingFor]: 1 / 5
+  } as const
+  const factor = feeFactors[txType as keyof typeof feeFactors] ?? 1
+  return new BigNumber(factor * BASE_GAS)
+}
+
+/**
+ * Calculate fee for Other types of transactions
+ * @see {@link https://github.com/aeternity/protocol/blob/master/consensus/README.md#gas}
+ * @param txType - The transaction type
+ * @param txSize - The transaction size
+ * @returns parameters - The transaction parameters
+ * @returns parameters.relativeTtl - The relative ttl
+ * @returns parameters.innerTxSize - The size of the inner transaction
+ * @returns The Other fee
+ * @example
+ * ```js
+ * TX_FEE_OTHER_GAS('oracleResponse',10, { relativeTtl: 10, innerTxSize: 10 })
+ *  => new BigNumber(10).times(20).plus(Math.ceil(32000 * 10 / Math.floor(60 * 24 * 365 / 2)))
+ * ```
+ */
+const TX_FEE_OTHER_GAS = (
+  txType: TX_TYPE,
+  txSize: number,
+  { relativeTtl, innerTxSize }: { relativeTtl: number, innerTxSize: number }
+): BigNumber => {
+  switch (txType) {
+    case TX_TYPE.oracleRegister:
+    case TX_TYPE.oracleExtend:
+    case TX_TYPE.oracleQuery:
+    case TX_TYPE.oracleResponse:
+      return new BigNumber(txSize)
+        .times(GAS_PER_BYTE)
+        .plus(
+          Math.ceil(32000 * relativeTtl / Math.floor(60 * 24 * 365 / KEY_BLOCK_INTERVAL))
+        )
+    case TX_TYPE.gaMeta:
+    case TX_TYPE.payingFor:
+      return new BigNumber(txSize).minus(innerTxSize).times(GAS_PER_BYTE)
+    default:
+      return new BigNumber(txSize).times(GAS_PER_BYTE)
+  }
+}
+
+function getOracleRelativeTtl (params: any, txType: TX_TYPE): number {
+  const ttlKeys = {
+    [TX_TYPE.oracleRegister]: 'oracleTtlValue',
+    [TX_TYPE.oracleExtend]: 'oracleTtlValue',
+    [TX_TYPE.oracleQuery]: 'queryTtlValue',
+    [TX_TYPE.oracleResponse]: 'responseTtlValue'
+  } as const
+
+  if (!isKeyOfObject(txType, ttlKeys)) return 1
+  else return params[ttlKeys[txType]]
+}
+
+/**
+ * Calculate fee based on tx type and params
+ */
+function buildFee (
+  txType: TX_TYPE,
+  { params, vsn, denomination }:
+  { params: TxParamsCommon, vsn?: number, denomination?: AE_AMOUNT_FORMATS }
+): BigNumber {
+  const { rlpEncoded: { length } } = buildTx(params, txType, { vsn, denomination })
+
+  return TX_FEE_BASE_GAS(txType)
+    .plus(TX_FEE_OTHER_GAS(txType, length, {
+      relativeTtl: getOracleRelativeTtl(params, txType),
+      innerTxSize: [TX_TYPE.gaMeta, TX_TYPE.payingFor].includes(txType)
+        ? params.tx.tx.encodedTx.rlpEncoded.length
+        : 0
+    }))
+    .times(MIN_GAS_PRICE)
+}
+
+/**
+ * Calculate min fee
+ * @param txType - Transaction type
+ * @param options - Options object
+ * @param options.params - Tx params
+ * @example
+ * ```js
+ * calculateMinFee('spendTx', { gasLimit, params })
+ * ```
+ */
+export default function calculateMinFee (
+  txType: TX_TYPE, { params, vsn, denomination }: CalculateMinFeeOptions
+): BigNumber {
+  let fee = new BigNumber(0)
+  let previousFee
+  do {
+    previousFee = fee
+    fee = buildFee(txType, { params: { ...params, fee }, vsn, denomination })
+  } while (!fee.eq(previousFee))
+  return fee
+}
+
+interface CalculateMinFeeOptions {
+  params: TxParamsCommon
+  vsn?: number
+  denomination?: AE_AMOUNT_FORMATS
+}

package/src/tx/validator.ts

@@ -0,0 +1,226 @@
+import { verify, hash } from '../utils/crypto'
+import { encode, decode } from './builder/helpers'
+import BigNumber from 'bignumber.js'
+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'
+
+interface Account {
+  balance: bigint
+  id: EncodedData<'ak'>
+  nonce: number
+}
+
+export interface ValidatorResult {
+  message: string
+  key: string
+  checkedKeys: string[]
+}
+
+type Validator = (
+  tx: {
+    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'>
+  },
+  options: {
+    account?: Account
+    nodeNetworkId: string
+    parentTxTypes: TX_TYPE[]
+    node: Node
+    txType: TX_TYPE
+    height: number
+    consensusProtocolVersion: number
+  }
+) => ValidatorResult[] | Promise<ValidatorResult[]>
+
+const validators: Validator[] = [
+  ({ encodedTx, signatures }, { account, nodeNetworkId, parentTxTypes }) => {
+    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 []
+    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 ({ encodedTx, tx }, { node, parentTxTypes, txType }) => {
+    if ((encodedTx ?? tx) === undefined) return []
+    return await verifyTransaction(
+      encode((encodedTx ?? tx).rlpEncoded, 'tx'),
+      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']
+    }]
+  },
+  ({ ttl }, { height }) => {
+    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']
+    }]
+  },
+  ({ 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 []
+    return [{
+      message: `Account balance ${account.balance.toString()} is not enough to execute the transaction that costs ${cost.toFixed()}`,
+      key: 'InsufficientBalance',
+      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 []
+    return [{
+      ...nonce < validNonce
+        ? {
+            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']
+    }]
+  },
+  ({ ctVersion, abiVersion }, { txType, consensusProtocolVersion }) => {
+    if (!isKeyOfObject(consensusProtocolVersion, PROTOCOL_VM_ABI)) {
+      throw new UnsupportedProtocolError(`Unsupported protocol: ${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 (Object.entries(ctVersion).some(
+      ([
+        key,
+        value
+      ]: [
+        key:keyof typeof txProtocol,
+        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']
+      }]
+    }
+    return []
+  },
+  async ({ contractId }, { txType, node }) => {
+    if (TX_TYPE.contractCall !== txType) return []
+    contractId = contractId as EncodedData<'ct'>
+    try {
+      const { active } = await node.getContract(contractId)
+      if (active) return []
+      return [{
+        message: `Contract ${contractId} is not active`,
+        key: 'ContractNotActive',
+        checkedKeys: ['contractId']
+      }]
+    } catch (error) {
+      if (error.response?.parsedBody?.reason == null) throw error
+      return [{
+        message: error.response.parsedBody.reason,
+        key: 'ContractNotFound',
+        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

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

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

@@ -0,0 +1,3 @@
+declare module '@aeternity/uuid' {
+  export * from 'uuid'
+}

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

@@ -0,0 +1,33 @@
+// 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/tweetnacl-auth/index.d.ts

@@ -0,0 +1,14 @@
+// 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
+}