@aeternity/aepp-sdk 13.3.3 → 14.1.0

package/src/utils/autorest.ts

@@ -1,153 +0,0 @@
-import { RestError, PipelineResponse } from '@azure/core-rest-pipeline';
-import { AdditionalPolicyConfig, FullOperationResponse, OperationOptions } 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);
-        requestQueues.set(key, req.catch(() => {}));
-        return req;
-      },
-    },
-    position: 'perCall',
-  };
-};
-
-export const genCombineGetRequestsPolicy = (): AdditionalPolicyConfig => {
-  const pendingGetRequests = new Map<string, Promise<PipelineResponse>>();
-
-  return {
-    policy: {
-      name: 'combine-get-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 genAggressiveCacheGetResponsesPolicy = (): AdditionalPolicyConfig => {
-  const getRequests = new Map<string, Promise<PipelineResponse>>();
-
-  return {
-    policy: {
-      name: 'aggressive-cache-get-responses',
-      async sendRequest(request, next) {
-        if (request.method !== 'GET') return next(request);
-        const key = JSON.stringify([request.url, request.body]);
-        const response = getRequests.get(key) ?? next(request);
-        getRequests.set(key, response);
-        return response;
-      },
-    },
-    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;
-        const prefix = `${new URL(error.request.url).pathname.slice(1)} error`;
-
-        if (error.response?.bodyAsText == null) {
-          if (error.message === '') error.message = `${prefix}: ${error.code}`;
-          throw error;
-        }
-
-        const body = (error.response as FullOperationResponse).parsedBody;
-        error.message = prefix;
-        const message = body == null ? ` ${error.response.status} status code` : getMessage(body);
-        if (message !== '') error.message += `:${message}`;
-        throw error;
-      }
-    },
-  },
-  position: 'perCall',
-});
-
-export const genVersionCheckPolicy = (
-  name: string,
-  versionCb: (options: OperationOptions) => Promise<string>,
-  geVersion: string,
-  ltVersion: string,
-): AdditionalPolicyConfig => ({
-  policy: {
-    name: 'version-check',
-    async sendRequest(request, next) {
-      if (request.headers.has('__version-check')) {
-        request.headers.delete('__version-check');
-        return next(request);
-      }
-      const options = { requestOptions: { customHeaders: { '__version-check': 'true' } } };
-      const args = [await versionCb(options), geVersion, ltVersion] as const;
-      if (!semverSatisfies(...args)) throw new UnsupportedVersionError(name, ...args);
-      return next(request);
-    },
-  },
-  position: 'perCall',
-});
-
-export const genRetryOnFailurePolicy = (
-  retryCount: number,
-  retryOverallDelay: number,
-): AdditionalPolicyConfig => ({
-  policy: {
-    name: 'retry-on-failure',
-    async sendRequest(request, next) {
-      const retryCode = request.headers.get('__retry-code') ?? NaN;
-      request.headers.delete('__retry-code');
-      const statusesToNotRetry = [200, 400, 403, 410, 500].filter((c) => c !== +retryCode);
-
-      const intervals = new Array(retryCount).fill(0)
-        .map((_, idx) => ((idx + 1) / retryCount) ** 2);
-      const intervalSum = intervals.reduce((a, b) => a + b, 0);
-      const intervalsInMs = intervals.map((e) => Math.floor((e / intervalSum) * retryOverallDelay));
-
-      let error = new RestError('Not expected to be thrown');
-      for (let attempt = 0; attempt <= retryCount; attempt += 1) {
-        if (attempt !== 0) {
-          await pause(intervalsInMs[attempt - 1]);
-          const urlParsed = new URL(request.url);
-          urlParsed.searchParams.set('__sdk-retry', attempt.toString());
-          request.url = urlParsed.toString();
-        }
-        try {
-          return await next(request);
-        } catch (e) {
-          if (!(e instanceof RestError)) throw e;
-          if (statusesToNotRetry.includes(e.response?.status ?? 0)) throw e;
-          error = e;
-        }
-      }
-      throw error;
-    },
-  },
-  position: 'perCall',
-});

package/src/utils/bignumber.ts

@@ -1,21 +0,0 @@
-/**
- * Big Number Helpers
- */
-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)
-    // 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);

package/src/utils/bytes.ts

@@ -1,28 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { NoSerializerFoundError, TypeError } from './errors';
-
-/**
- * Convert string, number, or BigNumber to byte array
- * @param val - value to convert
- * @param big - enables force conversion to BigNumber
- * @returns Buffer
- */
-// eslint-disable-next-line import/prefer-default-export
-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 == null) return Buffer.from([]);
-  if (Number.isInteger(val) || BigNumber.isBigNumber(val) || big) {
-    if (!BigNumber.isBigNumber(val)) val = new BigNumber(val);
-    if (!val.isInteger()) throw new TypeError(`Unexpected not integer value: ${val.toFixed()}`);
-    let hexString = val.toString(16);
-    if (hexString.length % 2 === 1) hexString = `0${hexString}`;
-    return Buffer.from(hexString, 'hex');
-  }
-  if (typeof val === 'string') {
-    return Buffer.from(val);
-  }
-  throw new NoSerializerFoundError();
-}

package/src/utils/crypto.ts

@@ -1,216 +0,0 @@
-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 { concatBuffers, isItemOfArray } from './other';
-import {
-  decode, encode, Encoded, Encoding,
-} from './encoder';
-import { ArgumentError } from './errors';
-
-/**
- * Generate address from secret key
- * @param secret - Private key as hex string
- * @returns Public key encoded as address
- */
-export function getAddressFromPriv(secret: string | Uint8Array): Encoded.AccountAddress {
-  const secretBuffer = typeof secret === 'string' ? Buffer.from(secret, 'hex') : secret;
-  const keys = nacl.sign.keyPair.fromSecretKey(secretBuffer);
-  return encode(keys.publicKey, Encoding.AccountAddress);
-}
-
-/**
- * Check if address is valid
- * @param maybeAddress - Address to check
- */
-export function isAddressValid(maybeAddress: string): maybeAddress is Encoded.AccountAddress;
-/**
- * Check if data is encoded in one of provided encodings
- * @param maybeEncoded - Data to check
- * @param encodings - Rest parameters with encodings to check against
- */
-export function isAddressValid<E extends Encoding>(
-  maybeEncoded: string,
-  ...encodings: E[]
-): maybeEncoded is Encoded.Generic<E>;
-export function isAddressValid(maybeEncoded: string, ...encodings: Encoding[]): boolean {
-  if (encodings.length === 0) encodings = [Encoding.AccountAddress];
-  try {
-    decode(maybeEncoded as Encoded.Any);
-    const encoding = maybeEncoded.split('_')[0];
-    if (!isItemOfArray(encoding, encodings)) {
-      throw new ArgumentError(
-        'Encoded string type',
-        encodings.length > 1 ? `one of ${encodings.join(', ')}` : encodings[0],
-        encoding,
-      );
-    }
-    return true;
-  } catch (error) {
-    return false;
-  }
-}
-
-/**
- * Generate a random salt (positive integer)
- * @returns random salt
- */
-export function genSalt(): number {
-  const [random] = new BigUint64Array(nacl.randomBytes(8).buffer);
-  return Number(random % BigInt(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 that was signed
- * @param signature - Signature of data
- * @param address - Address to verify against
- * @returns is data was signed by address
- */
-export function verify(
-  data: Uint8Array,
-  signature: Uint8Array,
-  address: Encoded.AccountAddress,
-): boolean {
-  return nacl.sign.detached.verify(data, signature, decode(address));
-}
-
-const messagePrefix = Buffer.from('aeternity Signed Message:\n', 'utf8');
-export const messagePrefixLength = varuintEncode(messagePrefix.length);
-
-// TODO: consider rename to hashMessage
-export function messageToHash(message: string): Buffer {
-  const msg = Buffer.from(message, 'utf8');
-  return hash(concatBuffers([messagePrefixLength, messagePrefix, varuintEncode(msg.length), msg]));
-}
-
-export function signMessage(message: string, privateKey: string | Buffer): Uint8Array {
-  return sign(messageToHash(message), privateKey);
-}
-
-/**
- * Verify that message was signed by address
- * @param message - Message that was signed
- * @param signature - Signature of message
- * @param address - Address to verify against
- * @returns is data was signed by address
- */
-// TODO: deprecate in favour of `verify(messageToHash(message), ...`, also the name is confusing
-// it should contain "signature"
-export function verifyMessage(
-  message: string,
-  signature: Uint8Array,
-  address: Encoded.AccountAddress,
-): boolean {
-  return verify(messageToHash(message), signature, address);
-}
-
-/**
- * Check key pair for validity
- *
- * Signs a message, and then verifies that signature
- * @param privateKey - Private key to verify
- * @param publicKey - Public key to verify as hex string
- * @returns Valid?
- */
-export function isValidKeypair(
-  privateKey: string | Uint8Array,
-  publicKey: string | Uint8Array,
-): boolean {
-  const message = Buffer.from('TheMessage');
-  const signature = sign(message, privateKey);
-  const publicKeyBuffer = typeof publicKey === 'string' ? Buffer.from(publicKey, 'hex') : publicKey;
-  return verify(message, signature, encode(publicKeyBuffer, Encoding.AccountAddress));
-}

package/src/utils/encoder-types.ts

@@ -1,63 +0,0 @@
-/**
- * @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}`;

package/src/utils/encoder.ts

@@ -1,145 +0,0 @@
-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,
-  ArgumentError,
-  InvalidChecksumError,
-  PayloadLengthError,
-} 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`
- * @param input - Data to hash
- * @returns Hash
- */
-export function sha256hash(input: Uint8Array | string): Buffer {
-  return new Sha256().update(input).digest();
-}
-
-/**
- * @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: 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: Uint8Array): Buffer => sha256hash(sha256hash(payload)).slice(0, 4);
-
-const addChecksum = (payload: Uint8Array): Buffer => concatBuffers([payload, getChecksum(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: Uint8Array) => addChecksum(buffer).toString('base64'),
-  decode: (string: string) => getPayload(Buffer.from(string, 'base64')),
-};
-
-const base58 = {
-  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
- * @param data - An Base58/64check encoded and prefixed string
- * (ex tx_..., sg_..., ak_....)
- * @returns Decoded data
- */
-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
- * @param data - An decoded data
- * @param type - Prefix of Transaction
- * @returns Encoded string Base58check or Base64check 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)}`;
-}