@aeternity/aepp-sdk 11.0.1 → 12.1.1

package/src/utils/encoder.ts

@@ -1,101 +1,146 @@
-import * as bs58 from 'bs58'
-import { sha256 } from 'sha.js'
+import { encode as bs58Encode, decode as bs58Decode } from 'bs58';
+// js extension is required for mjs build, not importing the whole package to reduce bundle size
+// eslint-disable-next-line import/extensions
+import Sha256 from 'sha.js/sha256.js';
 import {
   DecodeError,
-  EncodeError,
+  ArgumentError,
   InvalidChecksumError,
   PayloadLengthError,
-  PrefixMismatchError
-} from './errors'
+} from './errors';
+import { concatBuffers, isKeyOfObject } from './other';
+import * as Encoded from './encoder-types';
+import { Encoding } from './encoder-types';
+
+export { Encoded, Encoding };
 
 /**
  * Calculate SHA256 hash of `input`
- * @rtype (input: String) => hash: String
- * @param {Buffer|String} input - Data to hash
- * @return {String} Hash
+ * @param input - Data to hash
+ * @returns Hash
+ * @deprecated use `SubtleCrypto.digest` or `sha.js` package instead
  */
-export function sha256hash (input: Buffer | string) {
-  return new sha256().update(input).digest()
+export function sha256hash(input: Uint8Array | string): Buffer {
+  return new Sha256().update(input).digest();
 }
 
-// based on https://github.com/aeternity/protocol/blob/master/node/api/api_encoding.md
-const base64Types = ['ba', 'cb', 'or', 'ov', 'pi', 'ss', 'cs', 'ck', 'cv', 'st', 'tx']
-const base58Types = ['ak', 'bf', 'bs', 'bx', 'ch', 'cm', 'ct', 'kh', 'mh', 'nm', 'ok', 'oq', 'pp', 'sg', 'th']
-// TODO: add all types with a fixed length
-const typesLength: { [name: string]: number } = {
-  ak: 32,
-  ct: 32,
-  ok: 32
-} as const
+/**
+ * @see {@link https://github.com/aeternity/aeserialization/blob/eb68fe331bd476910394966b7f5ede7a74d37e35/src/aeser_api_encoder.erl#L177-L202}
+ */
+const base64Types = [
+  Encoding.ContractBytearray,
+  Encoding.ContractStoreKey,
+  Encoding.ContractStoreValue,
+  Encoding.Transaction,
+  Encoding.OracleQuery,
+  Encoding.OracleResponse,
+  Encoding.State,
+  Encoding.Poi,
+  Encoding.StateTrees,
+  Encoding.CallStateTree,
+  Encoding.Bytearray,
+] as const;
+const base58Types = [
+  Encoding.KeyBlockHash,
+  Encoding.MicroBlockHash,
+  Encoding.BlockPofHash,
+  Encoding.BlockTxHash,
+  Encoding.BlockStateHash,
+  Encoding.Channel,
+  Encoding.ContractAddress,
+  Encoding.TxHash,
+  Encoding.OracleAddress,
+  Encoding.OracleQueryId,
+  Encoding.AccountAddress,
+  Encoding.Signature,
+  Encoding.Commitment,
+  Encoding.PeerPubkey,
+  Encoding.Name,
+] as const;
+
+/**
+ * @see {@link https://github.com/aeternity/aeserialization/blob/eb68fe331bd476910394966b7f5ede7a74d37e35/src/aeser_api_encoder.erl#L261-L286}
+ */
+const byteSizeForType = {
+  [Encoding.KeyBlockHash]: 32,
+  [Encoding.MicroBlockHash]: 32,
+  [Encoding.BlockPofHash]: 32,
+  [Encoding.BlockTxHash]: 32,
+  [Encoding.BlockStateHash]: 32,
+  [Encoding.Channel]: 32,
+  [Encoding.ContractAddress]: 32,
+  [Encoding.TxHash]: 32,
+  [Encoding.OracleAddress]: 32,
+  [Encoding.OracleQueryId]: 32,
+  [Encoding.AccountAddress]: 32,
+  [Encoding.Signature]: 64,
+  [Encoding.Commitment]: 32,
+  [Encoding.PeerPubkey]: 32,
+  [Encoding.State]: 32,
+} as const;
 
-function ensureValidLength (data: Buffer | string, type: string) {
-  if (!typesLength[type]) return
-  if (data.length === typesLength[type]) return
-  throw new PayloadLengthError(`Payload should be ${typesLength[type]} bytes, got ${data.length} instead`)
+function ensureValidLength(data: Uint8Array, type: Encoding): void {
+  if (!isKeyOfObject(type, byteSizeForType)) return;
+  const reqLen = byteSizeForType[type];
+  if (reqLen == null || data.length === reqLen) return;
+  throw new PayloadLengthError(`Payload should be ${reqLen} bytes, got ${data.length} instead`);
 }
 
-const getChecksum = (payload: Buffer | string) => sha256hash(sha256hash(payload)).slice(0, 4)
+const getChecksum = (payload: Uint8Array): Buffer => sha256hash(sha256hash(payload)).slice(0, 4);
 
-const addChecksum = (input: Buffer | string) => {
-  const payload = Buffer.from(input)
-  return Buffer.concat([payload, getChecksum(payload)])
-}
+const addChecksum = (payload: Uint8Array): Buffer => concatBuffers([payload, getChecksum(payload)]);
 
-function getPayload (buffer: Buffer) {
-  const payload = buffer.slice(0, -4)
-  if (!getChecksum(payload).equals(buffer.slice(-4))) throw new InvalidChecksumError()
-  return payload
+function getPayload(buffer: Buffer): Buffer {
+  const payload = buffer.slice(0, -4);
+  if (!getChecksum(payload).equals(buffer.slice(-4))) throw new InvalidChecksumError();
+  return payload;
 }
 
 const base64 = {
-  encode: (buffer: Buffer | string) => addChecksum(buffer).toString('base64'),
-  decode: (string: string) => getPayload(Buffer.from(string, 'base64'))
-}
+  encode: (buffer: Uint8Array) => addChecksum(buffer).toString('base64'),
+  decode: (string: string) => getPayload(Buffer.from(string, 'base64')),
+};
 
 const base58 = {
-  encode: (buffer: Buffer | string) => bs58.encode(addChecksum(buffer)),
-  decode: (string: string) => getPayload(bs58.decode(string))
-}
+  encode: (buffer: Uint8Array) => bs58Encode(addChecksum(buffer)),
+  decode: (string: string) => getPayload(Buffer.from(bs58Decode(string))),
+};
+
+const parseType = (maybeType: unknown): [Encoding, typeof base64] => {
+  const base64Type = base64Types.find((t) => t === maybeType);
+  if (base64Type != null) return [base64Type, base64];
+  const base58Type = base58Types.find((t) => t === maybeType);
+  if (base58Type != null) return [base58Type, base58];
+  throw new ArgumentError('prefix', `one of ${[...base58Types, ...base64Types].join(', ')}`, maybeType);
+};
 
 /**
  * Decode data using the default encoding/decoding algorithm
- * @function
- * @alias module:@aeternity/aepp-sdk/es/tx/builder/helpers
- * @param {string} data An Base58/64check encoded and prefixed string (ex tx_..., sg_..., ak_....)
- * @param {string} [requiredPrefix] Ensure that data have this prefix
- * @return {Buffer} Decoded data
+ * @param data - An Base58/64check encoded and prefixed string
+ * (ex tx_..., sg_..., ak_....)
+ * @returns Decoded data
  */
-export function decode (data: string, requiredPrefix?: string) {
-  const [prefix, encodedPayload, extra] = data.split('_')
-  if (!encodedPayload) throw new DecodeError(`Encoded string missing payload: ${data}`)
-  if (extra) throw new DecodeError(`Encoded string have extra parts: ${data}`)
-  if (requiredPrefix && requiredPrefix !== prefix) {
-    throw new PrefixMismatchError(prefix, requiredPrefix)
-  }
-  const decoder = (base64Types.includes(prefix) && base64.decode) ||
-    (base58Types.includes(prefix) && base58.decode)
-  if (!decoder) {
-    throw new DecodeError(`Encoded string have unknown type: ${prefix}`)
-  }
-  const payload = decoder(encodedPayload)
-  ensureValidLength(payload, prefix)
-  return payload
+export function decode(data: Encoded.Any): Buffer {
+  const [prefix, encodedPayload, extra] = data.split('_');
+  if (encodedPayload == null) throw new DecodeError(`Encoded string missing payload: ${data}`);
+  if (extra != null) throw new DecodeError(`Encoded string have extra parts: ${data}`);
+  const [type, encoder] = parseType(prefix);
+  const payload = encoder.decode(encodedPayload);
+  ensureValidLength(payload, type);
+  return payload;
 }
 
 /**
  * Encode data using the default encoding/decoding algorithm
- * @function
- * @alias module:@aeternity/aepp-sdk/es/tx/builder/helpers
- * @param {Buffer|String} data  An decoded data
- * @param {string} type Prefix of Transaction
- * @return {String} Encoded string Base58check or Base64check data
+ * @param data - An decoded data
+ * @param type - Prefix of Transaction
+ * @returns Encoded string Base58check or Base64check data
  */
-export function encode (data: Buffer | string, type: string) {
-  const encoder = (base64Types.includes(type) && base64.encode) ||
-    (base58Types.includes(type) && base58.encode)
-  if (!encoder) {
-    throw new EncodeError(`Unknown type: ${type}`)
-  }
-  ensureValidLength(data, type)
-  return `${type}_${encoder(data)}`
+export function encode<Type extends Encoding>(
+  data: Uint8Array,
+  type: Type,
+): Encoded.Generic<Type> {
+  const [, encoder] = parseType(type);
+  ensureValidLength(data, type);
+  return `${type}_${encoder.encode(data)}`;
 }