refactor(tests): migrate remaining tests ts

src/AeSdkBase.ts

@@ -52,10 +52,14 @@ function getValueOrErrorProxy<Value extends object> (valueCb: () => Value): Valu
  * available.
  */
 class AeSdkBase {
-  _options = {
-    denomination: AE_AMOUNT_FORMATS.AETTOS,
-    amount: AMOUNT
-  }
+  _options: {
+    denomination?: string
+    amount?: number
+    [key: string]: any
+  } = {
+      denomination: AE_AMOUNT_FORMATS.AETTOS,
+      amount: AMOUNT
+    }
 
   pool: Map<string, Node> = new Map()
   selectedNodeName?: string
@@ -262,7 +266,7 @@ type MakeOptional<Args extends any[]> = Args extends [infer Head, ...infer Tail]
     : [Head, ...MakeOptional<Tail>]
   : never
 
-type TransformMethods <Methods extends { [key: string]: Function }> =
+export type TransformMethods<Methods extends { [key: string]: Function }> =
   {
     [Name in keyof Methods]:
     Methods[Name] extends (...args: infer Args) => infer Ret

src/ae/aens.ts

@@ -27,13 +27,13 @@ import { salt } from '../utils/crypto'
 import { commitmentHash, isAuctionName, Pointer } from '../tx/builder/helpers'
 import { CLIENT_TTL, NAME_TTL, TX_TYPE } from '../tx/builder/schema'
 import { ArgumentError } from '../utils/errors'
-import { EncodedData } from '../utils/encoder'
-import { BigNumber } from 'bignumber.js'
+import { EncodedData } from './../utils/encoder'
 import { send } from './spend'
 import { AensName, getName, height } from '../chain'
 import { _buildTx, BuildTxOptions } from '../tx'
 import { TransformNodeType } from '../node'
 import { NameEntry } from '../apis/node'
+import AccountBase from '../account/base'
 
 interface KeyPointers {
   [key: string]: string | Buffer
@@ -101,17 +101,17 @@ export async function aensRevoke (
  */
 export async function aensUpdate (
   name: AensName,
-  pointers: KeyPointers = {},
+  pointers: KeyPointers | EncodedData<'ak'>,
   { extendPointers, ...options }: { extendPointers?: boolean } & Parameters<typeof send>[1]
   & BuildTxOptions<TX_TYPE.nameUpdate, 'nameId' | 'accountId' | 'pointers' | 'clientTtl' | 'nameTtl'>
   & { clientTtl?: number, nameTtl?: number }
 ): ReturnType<typeof send> {
   const allPointers = {
     ...extendPointers === true && Object.fromEntries(
       (await getName(name, options)).pointers
-        .map(({ key, id }: {key: string, id: string}) => [key, id])
+        .map(({ key, id }: { key: string, id: string }) => [key, id])
     ),
-    ...pointers
+    ...(typeof pointers === 'object' ? pointers : {})
   }
 
   const nameUpdateTx = await _buildTx(TX_TYPE.nameUpdate, {
@@ -196,16 +196,21 @@ export async function aensQuery (
     ttl: number
     update: (
       pointers: KeyPointers,
-      options: Parameters<typeof aensQuery>[1]
+      options?: Omit<Parameters<typeof aensQuery>[1], 'onNode' | 'onCompiler' | 'onAccount'> & {
+        onAccount?: AccountBase
+      }
     ) => ReturnType<typeof aensUpdate> & ReturnType<typeof aensQuery>
     transfer: (
       account: EncodedData<'ak'>,
-      options: Parameters<typeof aensQuery>[1]
+      options?: Parameters<typeof aensQuery>[1]
     ) => ReturnType<typeof aensUpdate> & ReturnType<typeof aensQuery>
-    revoke: (options: Parameters<typeof aensRevoke>[1]) => ReturnType<typeof aensRevoke>
+    revoke: (options?: Omit<Parameters<typeof aensRevoke>[1], 'onNode' | 'onCompiler' | 'onAccount'> & {
+      onAccount?: AccountBase
+    }
+    ) => ReturnType<typeof aensRevoke>
     extendTtl: (
       nameTtl: number,
-      options: Parameters<typeof aensQuery>[1]
+      options?: Omit<Parameters<typeof aensQuery>[1], 'onNode' | 'onCompiler' | 'onAccount'>
     ) => ReturnType<typeof aensUpdate> & ReturnType<typeof aensQuery>
   }
   >> {
@@ -318,7 +323,7 @@ export async function aensPreclaim (
     height: number
     salt: number
     commitmentId: string
-    claim: (opts: Parameters<typeof aensClaim>[2]) => ReturnType<typeof aensClaim>
+    claim: (opts?: Parameters<typeof aensClaim>[2]) => ReturnType<typeof aensClaim>
   }
   >> {
   const _salt = salt()
@@ -363,8 +368,7 @@ export async function aensPreclaim (
  */
 export async function aensBid (
   name: AensName,
-  nameFee: BigNumber,
-  options: Omit<Parameters<typeof aensClaim>[2], 'nameFee' | 'VSN'>
+  options: Omit<Parameters<typeof aensClaim>[2], 'VSN'>
 ): ReturnType<typeof aensClaim> {
-  return await aensClaim(name, 0, { ...options, nameFee, VSN: 2 })
+  return await aensClaim(name, 0, { ...options, VSN: 2 })
 }

src/ae/oracle.ts

@@ -43,7 +43,7 @@ import Node from '../node'
 import BigNumber from 'bignumber.js'
 import AccountBase from '../account/base'
 
-type OracleQueries = Awaited<ReturnType<Node['getOracleQueriesByPubkey']>>['oracleQueries']
+export type OracleQueries = Awaited<ReturnType<Node['getOracleQueriesByPubkey']>>['oracleQueries']
 
 /**
  * Constructor for Oracle Object (helper object for using Oracle)
@@ -141,9 +141,9 @@ export async function getQueryObject (
   Awaited<ReturnType<Node['getOracleQueryByPubkeyAndQueryId']>> & {
     decodedQuery: string
     decodedResponse: string
-    respond: (response: string, options: Parameters<typeof respondToQuery>[3]) =>
+    respond: (response: string, options?: Parameters<typeof respondToQuery>[3]) =>
     ReturnType<typeof respondToQuery>
-    pollForResponse: (options: Parameters<typeof pollForQueryResponse>[2]) =>
+    pollForResponse: (options?: Parameters<typeof pollForQueryResponse>[2]) =>
     ReturnType<typeof pollForQueryResponse>
   }
   > {

src/ae/spend.ts

@@ -35,8 +35,8 @@ import AccountBase from '../account/base'
 export async function send (
   tx: EncodedData<'tx'>,
   options: Parameters<AccountBase['signTransaction']>[1] & Parameters<typeof sendTransaction>[1]
-  & Partial<Omit<Parameters<typeof signUsingGA>[1], 'onAccount' | 'onCompiler'>>
-  & Pick<Parameters<typeof signUsingGA>[1], 'onAccount' | 'onCompiler'>
+  & Partial<Omit<Parameters<typeof signUsingGA>[1], 'onNode' | 'onAccount' | 'onCompiler'>>
+  & Pick<Parameters<typeof signUsingGA>[1], 'onNode' | 'onAccount' | 'onCompiler'>
 ): ReturnType<typeof sendTransaction> {
   const { contractId, authFun = undefined } = options.innerTx === true
     ? { contractId: null }
@@ -72,7 +72,9 @@ export async function signUsingGA (
 export async function spend (
   amount: number | string,
   recipientIdOrName: EncodedData<'ak'> | AensName,
-  options: BuildTxOptions<TX_TYPE.spend, 'senderId' | 'recipientId' | 'amount'>
+  options: BuildTxOptions<TX_TYPE.spend, 'senderId' | 'recipientId' | 'amount'> & {
+    denomination?: string
+  }
   & Parameters<typeof resolveName>[2] & { onAccount: AccountBase } & Parameters<typeof send>[1]
 ): ReturnType<typeof send> {
   return await send(

src/chain.ts

@@ -79,7 +79,7 @@ export async function sendTransaction (
     if (validation.length > 0) {
       const message = 'Transaction verification errors: ' +
         validation.map((v: { message: string }) => v.message).join(', ')
-      throw Object.assign(new InvalidTxError(message), {
+      throw new InvalidTxError(message, {
         code: 'TX_VERIFICATION_ERROR',
         validation,
         transaction: tx
@@ -157,7 +157,7 @@ export async function waitForTxConfirm (
  * @param options.onNode - Node to use
  */
 export async function getAccount (
-  address: EncodedData<'ak'>,
+  address: EncodedData<'ak' | 'ct'>,
   { height, hash, onNode }:
   { height?: number, hash?: EncodedData<'kh' | 'mh'>, onNode: Node }
 ): Promise<TransformNodeType<AccountNode>> {
@@ -176,9 +176,9 @@ export async function getAccount (
  * @param options.hash - The block hash on which to obtain the balance for (default: top of chain)
  */
 export async function getBalance (
-  address: EncodedData<'ak'>,
+  address: EncodedData<'ak' | 'ct'>,
   { format = AE_AMOUNT_FORMATS.AETTOS, ...options }:
-  { format: AE_AMOUNT_FORMATS } & Parameters<typeof getAccount>[1]
+  { format?: AE_AMOUNT_FORMATS } & Parameters<typeof getAccount>[1]
 ): Promise<string> {
   const { balance } = await getAccount(address, options).catch(() => ({ balance: 0n }))
 
@@ -425,25 +425,25 @@ export async function getName (
  * @param options.onNode - Node to use
  * @returns Address or AENS name hash
  */
-export async function resolveName <Type extends 'ak' | 'ct'> (
+export async function resolveName<Type extends 'ak' | 'ct'> (
   nameOrId: AensName | EncodedData<Type>,
   key: string,
-  { verify = true, resolveByNode, onNode }:
-  { verify?: boolean, resolveByNode: boolean, onNode: Node }
+  { verify = true, resolveByNode = false, onNode }:
+  { verify?: boolean, resolveByNode?: boolean, onNode: Node }
 ): Promise<EncodedData<Type | 'nm'>> {
   try {
     const id = nameOrId as EncodedData<Type>
     decode(id)
     return id
-  } catch (error) {}
+  } catch (error) { }
   if (isNameValid(nameOrId)) {
     if (verify || resolveByNode) {
       const name = await onNode.getNameEntryByName(nameOrId)
       const pointer = name.pointers.find(pointer => pointer.key === key)
       if (pointer == null) throw new AensPointerContextError(nameOrId, key)
       if (resolveByNode) return pointer.id as EncodedData<Type>
     }
-    return produceNameId(nameOrId as AensName)
+    return produceNameId(nameOrId)
   }
   throw new InvalidAensNameError(`Invalid name or address: ${nameOrId}`)
 }

src/contract/aci.ts

@@ -46,6 +46,7 @@ import {
   getAccount, getContract, getContractByteCode, getKeyBlock, resolveName, txDryRun
 } from '../chain'
 import AccountBase from '../account/base'
+import { AensName } from './../chain'
 
 interface FunctionACI {
   arguments: any[]
@@ -75,7 +76,7 @@ interface Event {
   topics: Array<string | number>
 }
 
-interface DecodedEvent {
+export interface DecodedEvent {
   name: string
   args: unknown
   contract: {
@@ -84,7 +85,7 @@ interface DecodedEvent {
   }
 }
 
-type TxData = Awaited<ReturnType<typeof send>>
+export type TxData = Awaited<ReturnType<typeof send>>
 
 export interface ContractInstance {
   _aci: Aci
@@ -113,10 +114,12 @@ export interface ContractInstance {
   options: any
   compile: (options?: {}) => Promise<EncodedData<'cb'>>
   _estimateGas: (name: string, params: any[], options: object) => Promise<number>
-  deploy: (params: any[], options: object) => Promise<any>
+  deploy: (params?: any[], options?: object) => Promise<any>
   call: (fn: string, params?: any[], options?: {}) => Promise<any>
-  decodeEvents: (events: Event[], { omitUnknown, ...opt }: {
-    omitUnknown?: boolean}) => DecodedEvent[]
+  decodeEvents: (events: Event[], { omitUnknown, contractAddressToName, ...opt }: {
+    omitUnknown?: boolean
+    contractAddressToName?: any
+  }) => DecodedEvent[]
   methods: any
 }
 
@@ -158,9 +161,10 @@ export default async function getContractInstance ({
   source?: string
   bytecode?: EncodedData<'cb'>
   aci?: Aci
-  contractAddress?: EncodedData<'ct'>
+  contractAddress?: EncodedData<'ct'> | AensName
   fileSystem?: Record<string, string>
   validateBytecode?: boolean
+  [key: string]: any
 }): Promise<ContractInstance> {
   if (_aci == null && source != null) {
     // TODO: should be fixed when the compiledAci interface gets updated
@@ -199,14 +203,15 @@ export default async function getContractInstance ({
       fileSystem,
       ...otherOptions
     },
-    compile: async function (_options?: {}): Promise<any> {},
-    _estimateGas: async function (_name: string, _params: any[], _options: object): Promise<any> {},
-    deploy: async function (_params: any[], _options: any): Promise<any> {},
-    call: async function (_fn: string, _params?: any[], _options?: {}): Promise<any> {},
+    compile: async function (_options?: {}): Promise<any> { },
+    _estimateGas:
+      async function (_name: string, _params: any[], _options: object): Promise<any> { },
+    deploy: async function (_params?: any[], _options?: any): Promise<any> { },
+    call: async function (_fn: string, _params?: any[], _options?: {}): Promise<any> { },
     decodeEvents (
       _events: Event[],
       { omitUnknown, ...opt }: { omitUnknown?: boolean }
-    ): any {},
+    ): any { },
     methods: undefined
   }
 
@@ -259,7 +264,8 @@ export default async function getContractInstance ({
   const handleCallError = (
     { returnType, returnValue }: {
       returnType: ContractCallReturnType
-      returnValue: EncodedData<EncodingType>},
+      returnValue: EncodedData<EncodingType>
+    },
     transaction: string): void => {
     let message: string
     switch (returnType) {
@@ -446,7 +452,7 @@ export default async function getContractInstance ({
    */
   instance.decodeEvents = (
     events: Event[],
-    { omitUnknown, ...opt }: {omitUnknown?: boolean} = {}
+    { omitUnknown, ...opt }: { omitUnknown?: boolean } = {}
   ): DecodedEvent[] => events
     .map(event => {
       const topics = event.topics.map((t: string | number) => BigInt(t))

src/tx/builder/field-types.ts

@@ -5,6 +5,7 @@ import { InsufficientNameFeeError, IllegalArgumentError } from '../../utils/erro
 import BigNumber from 'bignumber.js'
 import { MIN_GAS_PRICE } from './constants'
 import { AensName } from '../../chain'
+import { EncodedData } from '../../utils/encoder'
 
 // todo: update me
 // ? This is a TS workaround because this has to be a class with only static methods
@@ -40,7 +41,7 @@ export class NameId extends Field {
   /**
    * @param value - AENS name ID
    */
-  static serialize (value: AensName): Buffer {
+  static serialize (value: AensName | EncodedData<'nm'>): Buffer {
     return writeId(isNameValid(value) ? produceNameId(value) : value)
   }
 

src/tx/builder/helpers.ts

@@ -177,7 +177,7 @@ const AENS_SUFFIX = '.chain'
  * Is AENS name valid
  * @param name - AENS name
  */
-export function isNameValid (name: string): boolean {
+export function isNameValid (name: string): name is AensName {
   // TODO: probably there are stronger requirements
   return name.endsWith(AENS_SUFFIX)
 }
@@ -215,8 +215,14 @@ export function getMinimumNameFee (name: AensName): BigNumber {
  */
 export function computeBidFee (
   name: AensName,
-  startFee: number | string | null,
-  increment: number = NAME_FEE_BID_INCREMENT
+  {
+    startFee,
+    increment = NAME_FEE_BID_INCREMENT
+  }:
+  {
+    startFee?: number | string | BigNumber
+    increment?: number
+  } = {}
 ): BigNumber {
   if (!(Number(increment) === increment && increment % 1 !== 0)) throw new IllegalBidFeeError(`Increment must be float. Current increment ${increment}`)
   if (increment < NAME_FEE_BID_INCREMENT) throw new IllegalBidFeeError(`minimum increment percentage is ${NAME_FEE_BID_INCREMENT}`)

src/tx/index.ts

@@ -26,7 +26,8 @@ import {
   ABI_VERSIONS, CtVersion, PROTOCOL_VM_ABI, TX_TYPE, TX_TTL, TxParamsCommon, TxTypeSchemas
 } from './builder/schema'
 import {
-  ArgumentError, UnsupportedProtocolError, UnknownTxError, InvalidTxParamsError
+  ArgumentError, UnsupportedProtocolError,
+  UnknownTxError, InvalidTxParamsError, UnexpectedTsError
 } from '../utils/errors'
 import { BigNumber } from 'bignumber.js'
 import Node from '../node'
@@ -37,13 +38,14 @@ import AccountBase from '../account/base'
 
 // 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> =
+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,
-  { onAccount, ..._params }: TxTypeSchemas[TxType] & { onNode: Node, onAccount: AccountBase }
+  { onAccount, ..._params }: Partial<TxTypeSchemas[TxType]>
+  & { onNode: Node, onAccount: AccountBase, denomination?: string, absoluteTtl?: boolean }
 ): Promise<EncodedData<'tx'>> {
   // TODO: avoid this assertion
   const params = _params as unknown as TxParamsCommon & { onNode: Node }
@@ -174,6 +176,8 @@ export async function prepareTxParams (
     await onNode.getAccountNextNonce(senderId, { strategy }).catch(() => ({ nextNonce: 1 }))
   ).nextNonce
 
+  if (nonce == null) throw new UnexpectedTsError()
+
   if (ttl !== 0) {
     if (ttl < 0) throw new ArgumentError('ttl', 'greater or equal to 0', ttl)
     ttl += absoluteTtl === true ? 0 : (await onNode.getCurrentKeyBlock()).height
@@ -184,5 +188,6 @@ export async function prepareTxParams (
     txType,
     { showWarning, gasLimit, params: { ...arguments[1], nonce, ttl }, vsn }
   )
+  if (nonce == null) throw new UnexpectedTsError("'nonce' is null")
   return { fee, ttl, nonce }
 }