@aeternity/aepp-sdk 11.0.1 → 12.1.1

package/src/utils/amount-formatter.ts

@@ -14,114 +14,101 @@
  *  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';
 
-/**
- * Amount Formatter
- * @module @aeternity/aepp-sdk/es/utils/amount-formatter
- * @example import { AmountFormatter } from '@aeternity/aepp-sdk'
- */
-import BigNumber from 'bignumber.js'
-import { isBigNumber } from './bignumber'
-import { ArgumentError, InvalidDenominationError } from './errors'
-
-/**
- * AE amount formats
- */
-export const AE_AMOUNT_FORMATS = {
-  AE: 'ae',
-  MILI_AE: 'miliAE',
-  MICRO_AE: 'microAE',
-  NANO_AE: 'nanoAE',
-  PICO_AE: 'picoAE',
-  FEMTO_AE: 'femtoAE',
-  AETTOS: 'aettos'
+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
  */
-export const 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
-}
+  [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 {String|Number|BigNumber} value amount to convert
- * @param {Object} [options={}] options
- * @param {String} [options.denomination='aettos'] denomination of amount, can be ['ae', 'aettos']
- * @return {String}
+ * @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 } = {}
-): string => formatAmount(value, { denomination, targetDenomination: AE_AMOUNT_FORMATS.AE })
+  { denomination = AE_AMOUNT_FORMATS.AETTOS }: { denomination?: AE_AMOUNT_FORMATS } = {},
+): string => formatAmount(value, { denomination, targetDenomination: AE_AMOUNT_FORMATS.AE });
 
 /**
  * Convert amount to aettos
- * @param {String|Number|BigNumber} value amount to convert
- * @param {Object} [options={}] options
- * @param {String} [options.denomination='ae'] denomination of amount, can be ['ae', 'aettos']
- * @return {String}
+ * @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 } = {}
-): string => formatAmount(value, { denomination })
-
-/**
- * Convert amount from one to other denomination
- * @param {String|Number|BigNumber} value amount to convert
- * @param {Object} [options={}] options
- * @param {String} [options.denomination='aettos'] denomination of amount, can be ['ae', 'aettos']
- * @param {String} [options.targetDenomination='aettos'] target denomination, can be ['ae', 'aettos']
- * @return {String}
- */
-export const formatAmount = (
-  value: string | number | BigNumber,
-  { denomination = AE_AMOUNT_FORMATS.AETTOS, targetDenomination = AE_AMOUNT_FORMATS.AETTOS } = {}
-): string => {
-  const denominations = Object.values(AE_AMOUNT_FORMATS)
-  if (!denominations.includes(denomination)) throw new InvalidDenominationError(`Invalid denomination: ${denomination}`)
-  if (!denominations.includes(targetDenomination)) throw new InvalidDenominationError(`Invalid target denomination: ${targetDenomination}`)
-  if (!isBigNumber(value)) throw new ArgumentError('value', `a number`, value)
-
-  return new BigNumber(value)
-    .shiftedBy(DENOMINATION_MAGNITUDE[denomination] - DENOMINATION_MAGNITUDE[targetDenomination])
-    .toFixed()
-}
+  { 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}`;
+};

package/src/utils/autorest.ts

@@ -0,0 +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';
+
+export const genRequestQueuesPolicy = (): AdditionalPolicyConfig => {
+  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> => 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 () => pause(750)));
+        return req;
+      },
+    },
+    position: 'perCall',
+  };
+};
+
+export const genCombineGetRequestsPolicy = (): AdditionalPolicyConfig => {
+  const pendingGetRequests = new Map<string, Promise<PipelineResponse>>();
+
+  return {
+    policy: {
+      name: 'combine-requests',
+      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;
+        } finally {
+          pendingGetRequests.delete(key);
+        }
+      },
+    },
+    position: 'perCall',
+  };
+};
+
+export const genErrorFormatterPolicy = (
+  getMessage: (b: any) => string,
+): AdditionalPolicyConfig => ({
+  policy: {
+    name: 'error-formatter',
+    async sendRequest(request, next) {
+      try {
+        return await next(request);
+      } catch (error) {
+        if (!(error instanceof RestError) || error.request == null) throw error;
+        if (error.response?.bodyAsText == null) throw error;
+
+        let body;
+        try {
+          body = JSON.parse(error.response.bodyAsText);
+        } catch (e) {
+          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',
+});
+
+export const genVersionCheckPolicy = (
+  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 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,22 +1,21 @@
 /**
  * Big Number Helpers
- * @module @aeternity/aepp-sdk/es/utils/bignumber
- * @example import { isBigNumber, ceil } from '@aeternity/aepp-sdk/es/utils/bignumber'
  */
-import BigNumber from 'bignumber.js'
+import BigNumber from 'bignumber.js';
 
 /**
- * Check if value is BigNumber, Number or number string representation
- * @param {String|Number|BigNumber} number number to convert
- * @return {Boolean}
+ * Check if value is BigNumber, Number, BigInt or number string representation
+ * @param number - number to check
  */
-export const isBigNumber = (number: string | number | BigNumber): boolean =>
-  ['number', 'object', 'string', 'bigint'].includes(typeof number) &&
-  (!isNaN(number as number) || Number.isInteger(number) || BigNumber.isBigNumber(number))
+export const isBigNumber = (number: string | number | bigint | BigNumber): boolean => {
+  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
- * @param {BigNumber} bigNumber
- * @return {BigNumber}
  */
-export const ceil = (bigNumber: BigNumber): BigNumber => bigNumber.integerValue(BigNumber.ROUND_CEIL)
+export const ceil = (bigNumber: BigNumber): BigNumber => bigNumber
+  .integerValue(BigNumber.ROUND_CEIL);

package/src/utils/bytes.ts

@@ -14,61 +14,59 @@
  *  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'
-
-/**
- * Bytes module
- * @module @aeternity/aepp-sdk/es/utils/bytes
- * @example import { Crypto } from '@aeternity/aepp-sdk'
- */
+import BigNumber from 'bignumber.js';
+import { NoSerializerFoundError, TypeError } from './errors';
+import { isBase64, isHex } from './string';
 
 /**
  * Convert bignumber to byte array
- * @param {BigNumber} x bignumber instance
- * @return Buffer
+ * @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');
 }
 
 /**
  * Convert string, number, or BigNumber to byte array
- * @param {null|string|number|BigNumber} val
- * @param {boolean} big enables force conversion to BigNumber
- * @return Buffer
+ * @param val - value to convert
+ * @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();
 }
 
 /**
  * Convert a string to a Buffer.  If encoding is not specified, hex-encoding
  * will be used if the input is valid hex.  If the input is valid base64 but
  * not valid hex, base64 will be used.  Otherwise, utf8 will be used.
- * @param {string} str String to be converted.
- * @param {string} [enc] Encoding of the input string.
- * @return {buffer} Buffer containing the input data.
+ * @param str - String to be converted.
+ * @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 hexToBytes = (s: string): Uint8Array => Buffer.from(s, 'hex');

package/src/utils/crypto.ts

@@ -0,0 +1,205 @@
+/*
+ * ISC License (ISC)
+ * Copyright 2018 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.
+ */
+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): Encoded.AccountAddress {
+  const secretBuffer = typeof secret === 'string' ? str2buf(secret) : secret;
+  const keys = nacl.sign.keyPair.fromSecretKey(secretBuffer);
+  return encode(keys.publicKey, Encoding.AccountAddress);
+}
+
+/**
+ * Check if address is valid
+ * @param address - Address
+ * @param prefix - Transaction prefix. Default: 'ak'
+ * @returns is valid
+ */
+export function isAddressValid(
+  address: string,
+  prefix: Encoding = Encoding.AccountAddress,
+): boolean {
+  try {
+    decode(address as Encoded.Generic<typeof prefix>);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Generate a random salt (positive integer)
+ * @returns random salt
+ */
+export function genSalt(): number {
+  return Math.floor(Math.random() * Math.floor(Number.MAX_SAFE_INTEGER));
+}
+
+/**
+ * Converts a positive integer to the smallest possible
+ * representation in a binary digit representation
+ * @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));
+}
+
+/**
+ * Calculate 256bits Blake2b hash of `input`
+ * @param input - Data to hash
+ * @returns Hash
+ */
+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: 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
+
+/**
+ * Generate keyPair from secret key
+ * @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);
+}
+
+/**
+ * Generate a random ED25519 keypair
+ * @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: 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);
+
+  if (raw) {
+    return {
+      publicKey: publicBuffer,
+      secretKey: secretBuffer,
+    };
+  }
+  return {
+    publicKey: encode(publicBuffer, Encoding.AccountAddress),
+    secretKey: secretBuffer.toString('hex'),
+  };
+}
+
+// SIGNATURES
+
+/**
+ * Generate signature
+ * @param data - Data to sign
+ * @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));
+}
+
+/**
+ * Verify that signature was signed by public key
+ * @param data - Data to verify
+ * @param signature - Signature to verify
+ * @param publicKey - Key to verify against
+ * @returns Valid?
+ */
+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);
+}
+
+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 verifyMessage(
+  str: string,
+  signature: Uint8Array,
+  publicKey: string | Uint8Array,
+): boolean {
+  return verify(messageToHash(str), signature, publicKey);
+}
+
+/**
+ * Check key pair for validity
+ *
+ * Sign a message, and then verifying that signature
+ * @param privateKey - Private key to verify
+ * @param publicKey - Public key to verify
+ * @returns Valid?
+ */
+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);
+}

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}`;