@aeternity/aepp-sdk 12.0.0 → 12.1.2

package/src/utils/autorest.ts

@@ -1,90 +1,93 @@
-import { RestError, PipelineResponse, PipelinePolicy } from '@azure/core-rest-pipeline'
-import { AdditionalPolicyConfig } from '@azure/core-client'
-import { pause } from './other'
-import semverSatisfies from './semver-satisfies'
-import { UnsupportedVersionError } from './errors'
+import { RestError, PipelineResponse, PipelinePolicy } from '@azure/core-rest-pipeline';
+import { AdditionalPolicyConfig } from '@azure/core-client';
+import { pause } from './other';
+import semverSatisfies from './semver-satisfies';
+import { UnsupportedVersionError } from './errors';
 
 export const genRequestQueuesPolicy = (): AdditionalPolicyConfig => {
-  const requestQueues = new Map<string, Promise<unknown>>()
+  const requestQueues = new Map<string, Promise<unknown>>();
 
   return {
     policy: {
       name: 'request-queues',
-      async sendRequest (request, next) {
-        const key = request.headers.get('__queue')
-        request.headers.delete('__queue')
-        const getResponse = async (): Promise<PipelineResponse> => await next(request)
-        if (key == null) return await getResponse()
-        const req = (requestQueues.get(key) ?? Promise.resolve()).then(getResponse, getResponse)
+      async sendRequest(request, next) {
+        const key = request.headers.get('__queue');
+        request.headers.delete('__queue');
+        const getResponse = async (): Promise<PipelineResponse> => next(request);
+        if (key == null) return getResponse();
+        const req = (requestQueues.get(key) ?? Promise.resolve()).then(getResponse, getResponse);
         // TODO: remove after fixing https://github.com/aeternity/aeternity/issues/3803
         // gap to ensure that node won't reject the nonce
-        requestQueues.set(key, req.then(async () => await pause(750)))
-        return await req
-      }
+        requestQueues.set(key, req.then(async () => pause(750)));
+        return req;
+      },
     },
-    position: 'perCall'
-  }
-}
+    position: 'perCall',
+  };
+};
 
 export const genCombineGetRequestsPolicy = (): AdditionalPolicyConfig => {
-  const pendingGetRequests = new Map<string, Promise<PipelineResponse>>()
+  const pendingGetRequests = new Map<string, Promise<PipelineResponse>>();
 
   return {
     policy: {
       name: 'combine-requests',
-      async sendRequest (request, next) {
-        if (request.method !== 'GET') return await next(request)
-        const key = JSON.stringify([request.url, request.body])
-        const response = pendingGetRequests.get(key) ?? next(request)
-        pendingGetRequests.set(key, response)
+      async sendRequest(request, next) {
+        if (request.method !== 'GET') return next(request);
+        const key = JSON.stringify([request.url, request.body]);
+        const response = pendingGetRequests.get(key) ?? next(request);
+        pendingGetRequests.set(key, response);
         try {
-          return await response
+          return await response;
         } finally {
-          pendingGetRequests.delete(key)
+          pendingGetRequests.delete(key);
         }
-      }
+      },
     },
-    position: 'perCall'
-  }
-}
+    position: 'perCall',
+  };
+};
 
 export const genErrorFormatterPolicy = (
-  getMessage: (b: any) => string
+  getMessage: (b: any) => string,
 ): AdditionalPolicyConfig => ({
   policy: {
     name: 'error-formatter',
-    async sendRequest (request, next) {
+    async sendRequest(request, next) {
       try {
-        return await next(request)
+        return await next(request);
       } catch (error) {
-        if (!(error instanceof RestError) || error.request == null) throw error
-        if (error.response?.bodyAsText == null) throw error
+        if (!(error instanceof RestError) || error.request == null) throw error;
+        if (error.response?.bodyAsText == null) throw error;
 
-        let body
+        let body;
         try {
-          body = JSON.parse(error.response.bodyAsText)
+          body = JSON.parse(error.response.bodyAsText);
         } catch (e) {
-          throw error
+          throw error;
         }
-        error.message = `${new URL(error.request.url).pathname.slice(1)} error`
-        const message = getMessage(body)
-        if (message !== '') error.message += `:${message}`
-        throw error
+        error.message = `${new URL(error.request.url).pathname.slice(1)} error`;
+        const message = getMessage(body);
+        if (message !== '') error.message += `:${message}`;
+        throw error;
       }
-    }
+    },
   },
-  position: 'perCall'
-})
+  position: 'perCall',
+});
 
 export const genVersionCheckPolicy = (
-  name: string, ignorePath: string,
-  versionPromise: Promise<string>, geVersion: string, ltVersion: string
+  name: string,
+  ignorePath: string,
+  versionPromise: Promise<string>,
+  geVersion: string,
+  ltVersion: string,
 ): PipelinePolicy => ({
   name: 'version-check',
-  async sendRequest (request, next) {
-    if (new URL(request.url).pathname === ignorePath) return await next(request)
-    const args = [await versionPromise, geVersion, ltVersion] as const
-    if (!semverSatisfies(...args)) throw new UnsupportedVersionError(name, ...args)
-    return await next(request)
-  }
-})
+  async sendRequest(request, next) {
+    if (new URL(request.url).pathname === ignorePath) return next(request);
+    const args = [await versionPromise, geVersion, ltVersion] as const;
+    if (!semverSatisfies(...args)) throw new UnsupportedVersionError(name, ...args);
+    return next(request);
+  },
+});

package/src/utils/bignumber.ts

@@ -1,20 +1,21 @@
 /**
  * Big Number Helpers
  */
-import BigNumber from 'bignumber.js'
+import BigNumber from 'bignumber.js';
 
 /**
  * Check if value is BigNumber, Number, BigInt or number string representation
  * @param number - number to check
  */
 export const isBigNumber = (number: string | number | bigint | BigNumber): boolean => {
-  if (typeof number === 'bigint') return true
-  return ['number', 'object', 'string'].includes(typeof number) &&
-    (!isNaN(number as number) || Number.isInteger(number) || BigNumber.isBigNumber(number))
-}
+  if (typeof number === 'bigint') return true;
+  return ['number', 'object', 'string'].includes(typeof number)
+    // eslint-disable-next-line no-restricted-globals
+    && (!isNaN(number as number) || Number.isInteger(number) || BigNumber.isBigNumber(number));
+};
 
 /**
  * BigNumber ceil operation
  */
 export const ceil = (bigNumber: BigNumber): BigNumber => bigNumber
-  .integerValue(BigNumber.ROUND_CEIL)
+  .integerValue(BigNumber.ROUND_CEIL);

package/src/utils/bytes.ts

@@ -14,20 +14,20 @@
  *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  *  PERFORMANCE OF THIS SOFTWARE.
  */
-import BigNumber from 'bignumber.js'
-import { NoSerializerFoundError, TypeError } from './errors'
-import { isBase64, isHex } from './string'
+import BigNumber from 'bignumber.js';
+import { NoSerializerFoundError, TypeError } from './errors';
+import { isBase64, isHex } from './string';
 
 /**
  * Convert bignumber to byte array
  * @param x - bignumber instance
  * @returns Buffer
  */
-export function bigNumberToByteArray (x: BigNumber): Buffer {
-  if (!x.isInteger()) throw new TypeError(`Unexpected not integer value: ${x.toFixed()}`)
-  let hexString = x.toString(16)
-  if (hexString.length % 2 === 1) hexString = '0' + hexString
-  return Buffer.from(hexString, 'hex')
+export function bigNumberToByteArray(x: BigNumber): Buffer {
+  if (!x.isInteger()) throw new TypeError(`Unexpected not integer value: ${x.toFixed()}`);
+  let hexString = x.toString(16);
+  if (hexString.length % 2 === 1) hexString = `0${hexString}`;
+  return Buffer.from(hexString, 'hex');
 }
 
 /**
@@ -36,20 +36,20 @@ export function bigNumberToByteArray (x: BigNumber): Buffer {
  * @param big - enables force conversion to BigNumber
  * @returns Buffer
  */
-export function toBytes (val?: null | string | number | BigNumber, big: boolean = false): Buffer {
+export function toBytes(val?: null | string | number | BigNumber, big = false): Buffer {
   // Encode a value to bytes.
   // If the value is an int it will be encoded as bytes big endian
   // Raises ValueError if the input is not an int or string
 
-  if (val === undefined || val === null) return Buffer.from([])
+  if (val === undefined || val === null) return Buffer.from([]);
   if (Number.isInteger(val) || BigNumber.isBigNumber(val) || big) {
-    if (!BigNumber.isBigNumber(val)) val = new BigNumber(val)
-    return bigNumberToByteArray(val)
+    if (!BigNumber.isBigNumber(val)) val = new BigNumber(val);
+    return bigNumberToByteArray(val);
   }
   if (typeof val === 'string') {
-    return Buffer.from(val)
+    return Buffer.from(val);
   }
-  throw new NoSerializerFoundError()
+  throw new NoSerializerFoundError();
 }
 
 /**
@@ -60,13 +60,13 @@ export function toBytes (val?: null | string | number | BigNumber, big: boolean
  * @param enc - Encoding of the input string.
  * @returns Buffer containing the input data.
  */
-export function str2buf (str: string, enc?: BufferEncoding): Buffer {
+export function str2buf(str: string, enc?: BufferEncoding): Buffer {
   return Buffer.from(
     str,
-    enc ?? (isHex(str) ? 'hex' : undefined) ?? (isBase64(str) ? 'base64' : undefined)
-  )
+    enc ?? (isHex(str) ? 'hex' : undefined) ?? (isBase64(str) ? 'base64' : undefined),
+  );
 }
 
-export const bytesToHex = (b: Uint8Array): string => Buffer.from(b).toString('hex')
+export const bytesToHex = (b: Uint8Array): string => Buffer.from(b).toString('hex');
 
-export const hexToBytes = (s: string): Uint8Array => Buffer.from(s, 'hex')
+export const hexToBytes = (s: string): Uint8Array => Buffer.from(s, 'hex');

package/src/utils/crypto.ts

@@ -14,28 +14,27 @@
  *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  *  PERFORMANCE OF THIS SOFTWARE.
  */
-import nacl, { SignKeyPair } from 'tweetnacl'
-import aesjs from 'aes-js'
-import { blake2b, Data } from 'blakejs'
-import { encode as varuintEncode } from 'varuint-bitcoin'
-
-import { str2buf } from './bytes'
-import { concatBuffers } from './other'
-import { encode, decode, sha256hash, EncodedData, EncodingType } from './encoder'
-
-export { sha256hash }
-
-const Ecb = aesjs.ModeOfOperation.ecb
+import nacl, { SignKeyPair } from 'tweetnacl';
+// js extension is required for mjs build, not importing the whole package to reduce bundle size
+// eslint-disable-next-line import/extensions
+import { blake2b } from 'blakejs/blake2b.js';
+import { encode as varuintEncode } from 'varuint-bitcoin';
+
+import { str2buf } from './bytes';
+import { concatBuffers } from './other';
+import {
+  decode, encode, Encoded, Encoding,
+} from './encoder';
 
 /**
  * Generate address from secret key
  * @param secret - Private key
  * @returns Public key encoded as address
  */
-export function getAddressFromPriv (secret: string | Uint8Array): EncodedData<'ak'> {
-  const secretBuffer = typeof secret === 'string' ? str2buf(secret) : secret
-  const keys = nacl.sign.keyPair.fromSecretKey(secretBuffer)
-  return encode(keys.publicKey, 'ak')
+export function getAddressFromPriv(secret: string | Uint8Array): Encoded.AccountAddress {
+  const secretBuffer = typeof secret === 'string' ? str2buf(secret) : secret;
+  const keys = nacl.sign.keyPair.fromSecretKey(secretBuffer);
+  return encode(keys.publicKey, Encoding.AccountAddress);
 }
 
 /**
@@ -44,12 +43,15 @@ export function getAddressFromPriv (secret: string | Uint8Array): EncodedData<'a
  * @param prefix - Transaction prefix. Default: 'ak'
  * @returns is valid
  */
-export function isAddressValid (address: string, prefix: EncodingType = 'ak'): boolean {
+export function isAddressValid(
+  address: string,
+  prefix: Encoding = Encoding.AccountAddress,
+): boolean {
   try {
-    decode(address as EncodedData<typeof prefix>)
-    return true
+    decode(address as Encoded.Generic<typeof prefix>);
+    return true;
   } catch (e) {
-    return false
+    return false;
   }
 }
 
@@ -57,8 +59,8 @@ export function isAddressValid (address: string, prefix: EncodingType = 'ak'): b
  * Generate a random salt (positive integer)
  * @returns random salt
  */
-export function salt (): number {
-  return Math.floor(Math.random() * Math.floor(Number.MAX_SAFE_INTEGER))
+export function genSalt(): number {
+  return Math.floor(Math.random() * Math.floor(Number.MAX_SAFE_INTEGER));
 }
 
 /**
@@ -67,10 +69,10 @@ export function salt (): number {
  * @param value - Value to encode
  * @returns Encoded number
  */
-export function encodeUnsigned (value: number): Buffer {
-  const binary = Buffer.allocUnsafe(4)
-  binary.writeUInt32BE(value)
-  return binary.slice(binary.findIndex(i => i !== 0))
+export function encodeUnsigned(value: number): Buffer {
+  const binary = Buffer.allocUnsafe(4);
+  binary.writeUInt32BE(value);
+  return binary.slice(binary.findIndex((i) => i !== 0));
 }
 
 /**
@@ -78,21 +80,25 @@ export function encodeUnsigned (value: number): Buffer {
  * @param input - Data to hash
  * @returns Hash
  */
-export function hash (input: Data): Buffer {
-  return Buffer.from(blake2b(input, undefined, 32)) // 256 bits
+export function hash(input: string | Uint8Array): Buffer {
+  return Buffer.from(blake2b(input, undefined, 32)); // 256 bits
 }
 
 // Todo Duplicated in tx builder. remove
 /**
  * Compute contract address
+ * @category contract
  * @param owner - Address of contract owner
  * @param nonce - Round when contract was created
  * @returns Contract address
  */
-export function encodeContractAddress (owner: EncodedData<'ak'>, nonce: number): EncodedData<'ct'> {
-  const publicKey = decode(owner)
-  const binary = concatBuffers([publicKey, encodeUnsigned(nonce)])
-  return encode(hash(binary), 'ct')
+export function encodeContractAddress(
+  owner: Encoded.AccountAddress,
+  nonce: number,
+): Encoded.ContractAddress {
+  const publicKey = decode(owner);
+  const binary = concatBuffers([publicKey, encodeUnsigned(nonce)]);
+  return encode(hash(binary), Encoding.ContractAddress);
 }
 
 // KEY-PAIR HELPERS
@@ -102,8 +108,8 @@ export function encodeContractAddress (owner: EncodedData<'ak'>, nonce: number):
  * @param secret - secret key
  * @returns Object with Private(privateKey) and Public(publicKey) keys
  */
-export function generateKeyPairFromSecret (secret: Uint8Array): SignKeyPair {
-  return nacl.sign.keyPair.fromSecretKey(secret)
+export function generateKeyPairFromSecret(secret: Uint8Array): SignKeyPair {
+  return nacl.sign.keyPair.fromSecretKey(secret);
 }
 
 /**
@@ -111,52 +117,28 @@ export function generateKeyPairFromSecret (secret: Uint8Array): SignKeyPair {
  * @param raw - Whether to return raw (binary) keys
  * @returns Key pair
  */
-export function generateKeyPair (raw: true): { publicKey: Buffer, secretKey: Buffer }
-export function generateKeyPair (raw?: false): { publicKey: EncodedData<'ak'>, secretKey: string }
-export function generateKeyPair (raw: boolean = false): {
-  publicKey: EncodedData<'ak'> | Buffer
-  secretKey: string | Buffer
+export function generateKeyPair(raw: true): { publicKey: Buffer; secretKey: Buffer };
+export function generateKeyPair(raw?: false): {
+  publicKey: Encoded.AccountAddress; secretKey: string;
+};
+export function generateKeyPair(raw = false): {
+  publicKey: Encoded.AccountAddress | Buffer;
+  secretKey: string | Buffer;
 } {
-  const keyPair = nacl.sign.keyPair()
-  const publicBuffer = Buffer.from(keyPair.publicKey)
-  const secretBuffer = Buffer.from(keyPair.secretKey)
+  const keyPair = nacl.sign.keyPair();
+  const publicBuffer = Buffer.from(keyPair.publicKey);
+  const secretBuffer = Buffer.from(keyPair.secretKey);
 
   if (raw) {
     return {
       publicKey: publicBuffer,
-      secretKey: secretBuffer
-    }
-  } else {
-    return {
-      publicKey: encode(publicBuffer, 'ak'),
-      secretKey: secretBuffer.toString('hex')
-    }
+      secretKey: secretBuffer,
+    };
   }
-}
-
-/**
- * Encrypt given data using `password`
- * @param password - Password to encrypt with
- * @param binaryData - Data to encrypt
- * @returns Encrypted data
- */
-export function encryptKey (password: string, binaryData: Uint8Array): Uint8Array {
-  const hashedPasswordBytes = sha256hash(password)
-  const aesEcb = new Ecb(hashedPasswordBytes)
-  return aesEcb.encrypt(binaryData)
-}
-
-/**
- * Decrypt given data using `password`
- * @param password - Password to decrypt with
- * @param encrypted - Data to decrypt
- * @returns Decrypted data
- */
-export function decryptKey (password: string, encrypted: Uint8Array): Uint8Array {
-  const encryptedBytes = Buffer.from(encrypted)
-  const hashedPasswordBytes = sha256hash(password)
-  const aesEcb = new Ecb(hashedPasswordBytes)
-  return aesEcb.decrypt(encryptedBytes)
+  return {
+    publicKey: encode(publicBuffer, Encoding.AccountAddress),
+    secretKey: secretBuffer.toString('hex'),
+  };
 }
 
 // SIGNATURES
@@ -167,8 +149,8 @@ export function decryptKey (password: string, encrypted: Uint8Array): Uint8Array
  * @param privateKey - Key to sign with
  * @returns Signature
  */
-export function sign (data: string | Uint8Array, privateKey: string | Uint8Array): Uint8Array {
-  return nacl.sign.detached(Buffer.from(data), Buffer.from(privateKey))
+export function sign(data: string | Uint8Array, privateKey: string | Uint8Array): Uint8Array {
+  return nacl.sign.detached(Buffer.from(data), Buffer.from(privateKey));
 }
 
 /**
@@ -178,26 +160,31 @@ export function sign (data: string | Uint8Array, privateKey: string | Uint8Array
  * @param publicKey - Key to verify against
  * @returns Valid?
  */
-export function verify (
-  data: Uint8Array, signature: Uint8Array, publicKey: string | Uint8Array
+export function verify(
+  data: Uint8Array,
+  signature: Uint8Array,
+  publicKey: string | Uint8Array,
 ): boolean {
-  const publicKeyBuffer = typeof publicKey === 'string' ? str2buf(publicKey) : publicKey
-  return nacl.sign.detached.verify(data, signature, publicKeyBuffer)
+  const publicKeyBuffer = typeof publicKey === 'string' ? str2buf(publicKey) : publicKey;
+  return nacl.sign.detached.verify(data, signature, publicKeyBuffer);
 }
 
-export function messageToHash (message: string): Buffer {
-  const p = Buffer.from('aeternity Signed Message:\n', 'utf8')
-  const msg = Buffer.from(message, 'utf8')
-  return hash(concatBuffers([varuintEncode(p.length), p, varuintEncode(msg.length), msg]))
+export function messageToHash(message: string): Buffer {
+  const p = Buffer.from('aeternity Signed Message:\n', 'utf8');
+  const msg = Buffer.from(message, 'utf8');
+  return hash(concatBuffers([varuintEncode(p.length), p, varuintEncode(msg.length), msg]));
 }
 
-export function signMessage (message: string, privateKey: string | Buffer): Uint8Array {
-  return sign(messageToHash(message), privateKey)
+export function signMessage(message: string, privateKey: string | Buffer): Uint8Array {
+  return sign(messageToHash(message), privateKey);
 }
 
-export function verifyMessage (
-  str: string, signature: Uint8Array, publicKey: string | Uint8Array): boolean {
-  return verify(messageToHash(str), signature, publicKey)
+export function verifyMessage(
+  str: string,
+  signature: Uint8Array,
+  publicKey: string | Uint8Array,
+): boolean {
+  return verify(messageToHash(str), signature, publicKey);
 }
 
 /**
@@ -208,10 +195,11 @@ export function verifyMessage (
  * @param publicKey - Public key to verify
  * @returns Valid?
  */
-export function isValidKeypair (
-  privateKey: string | Uint8Array, publicKey: string | Uint8Array
+export function isValidKeypair(
+  privateKey: string | Uint8Array,
+  publicKey: string | Uint8Array,
 ): boolean {
-  const message = Buffer.from('TheMessage')
-  const signature = sign(message, privateKey)
-  return verify(message, signature, publicKey)
+  const message = Buffer.from('TheMessage');
+  const signature = sign(message, privateKey);
+  return verify(message, signature, publicKey);
 }

package/src/utils/encoder-types.ts

@@ -0,0 +1,63 @@
+/**
+ * @category transaction builder
+ * @see {@link https://github.com/aeternity/protocol/blob/master/node/api/api_encoding.md}
+ * @see {@link https://github.com/aeternity/aeserialization/blob/eb68fe331bd476910394966b7f5ede7a74d37e35/src/aeser_api_encoder.erl#L205-L230}
+ */
+export enum Encoding {
+  KeyBlockHash = 'kh',
+  MicroBlockHash = 'mh',
+  BlockPofHash = 'bf',
+  BlockTxHash = 'bx',
+  BlockStateHash = 'bs',
+  Channel = 'ch',
+  ContractAddress = 'ct',
+  ContractBytearray = 'cb',
+  ContractStoreKey = 'ck',
+  ContractStoreValue = 'cv',
+  Transaction = 'tx',
+  TxHash = 'th',
+  OracleAddress = 'ok',
+  OracleQuery = 'ov',
+  OracleQueryId = 'oq',
+  OracleResponse = 'or',
+  AccountAddress = 'ak',
+  Signature = 'sg',
+  Commitment = 'cm',
+  PeerPubkey = 'pp',
+  Name = 'nm',
+  State = 'st',
+  Poi = 'pi',
+  StateTrees = 'ss',
+  CallStateTree = 'cs',
+  Bytearray = 'ba',
+}
+
+export type KeyBlockHash = `${Encoding.KeyBlockHash}_${string}`;
+export type MicroBlockHash = `${Encoding.MicroBlockHash}_${string}`;
+export type BlockPofHash = `${Encoding.BlockPofHash}_${string}`;
+export type BlockTxHash = `${Encoding.BlockTxHash}_${string}`;
+export type BlockStateHash = `${Encoding.BlockStateHash}_${string}`;
+export type Channel = `${Encoding.Channel}_${string}`;
+export type ContractAddress = `${Encoding.ContractAddress}_${string}`;
+export type ContractBytearray = `${Encoding.ContractBytearray}_${string}`;
+export type ContractStoreKey = `${Encoding.ContractStoreKey}_${string}`;
+export type ContractStoreValue = `${Encoding.ContractStoreValue}_${string}`;
+export type Transaction = `${Encoding.Transaction}_${string}`;
+export type TxHash = `${Encoding.TxHash}_${string}`;
+export type OracleAddress = `${Encoding.OracleAddress}_${string}`;
+export type OracleQuery = `${Encoding.OracleQuery}_${string}`;
+export type OracleQueryId = `${Encoding.OracleQueryId}_${string}`;
+export type OracleResponse = `${Encoding.OracleResponse}_${string}`;
+export type AccountAddress = `${Encoding.AccountAddress}_${string}`;
+export type Signature = `${Encoding.Signature}_${string}`;
+export type Commitment = `${Encoding.Commitment}_${string}`;
+export type PeerPubkey = `${Encoding.PeerPubkey}_${string}`;
+export type Name = `${Encoding.Name}_${string}`;
+export type State = `${Encoding.State}_${string}`;
+export type Poi = `${Encoding.Poi}_${string}`;
+export type StateTrees = `${Encoding.StateTrees}_${string}`;
+export type CallStateTree = `${Encoding.CallStateTree}_${string}`;
+export type Bytearray = `${Encoding.Bytearray}_${string}`;
+
+export type Generic<Type extends Encoding> = `${Type}_${string}`;
+export type Any = `${Encoding}_${string}`;