@aeternity/aepp-sdk 13.3.2 → 14.0.0

package/src/utils/hd-wallet.ts

@@ -1,189 +0,0 @@
-import nacl from 'tweetnacl';
-import { full as hmac } from 'tweetnacl-auth';
-import { fromString } from 'bip32-path';
-import aesjs from 'aes-js';
-import { sha256hash, encode, Encoding } from './encoder';
-import { CryptographyError } from './errors';
-import { concatBuffers } from './other';
-
-const Ecb = aesjs.ModeOfOperation.ecb;
-
-// TODO: use mnemonic encryption instead of AES
-/**
- * Encrypt given data using `password`
- * @param password - Password to encrypt with
- * @param binaryData - Data to encrypt
- * @returns Encrypted data
- */
-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
- */
-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);
-}
-
-/**
- * @category exception
- */
-export class DerivationError extends CryptographyError {
-  constructor(message: string) {
-    super(message);
-    this.name = 'DerivationError';
-  }
-}
-
-const ED25519_CURVE = Buffer.from('ed25519 seed');
-const HARDENED_OFFSET = 0x80000000;
-
-interface KeyTreeNode {
-  secretKey: Uint8Array;
-  chainCode: Uint8Array;
-}
-
-interface HDWallet {
-  secretKey: string;
-  chainCode: string;
-}
-
-interface Account {
-  secretKey: string;
-  publicKey: string;
-}
-
-type Dec<N extends number> = [-1, 0, 1, 2, 3, 4][N];
-type Bip32PathT<MaxLen extends number, H extends 'H' | 'h' | '\''> = MaxLen extends -1
-  ? `${number}${H}`
-  : Bip32PathT<Dec<MaxLen>, H> | `${Bip32PathT<Dec<MaxLen>, H>}/${number}${H}`;
-type Bip32Path<MaxLen extends number> =
-  '' | Bip32PathT<MaxLen, 'H'> | Bip32PathT<MaxLen, 'h'> | Bip32PathT<MaxLen, '\''>;
-
-/**
- * @category hd-wallet
- * @param keyTreeNode - A node of key tree
- * @param index - index of child node to derive
- */
-export function deriveChild({ secretKey, chainCode }: KeyTreeNode, index: number): KeyTreeNode {
-  if (index < HARDENED_OFFSET) {
-    throw new DerivationError(`Segment ${index} is not hardened`);
-  }
-  const indexBuffer = Buffer.allocUnsafe(4);
-  indexBuffer.writeUInt32BE(index, 0);
-
-  const data = concatBuffers([Buffer.alloc(1, 0), secretKey, indexBuffer]);
-
-  const I = hmac(data, chainCode);
-  const IL = I.slice(0, 32);
-  const IR = I.slice(32);
-  return {
-    secretKey: IL,
-    chainCode: IR,
-  };
-}
-
-/**
- * @category hd-wallet
- */
-export function derivePathFromKey(path: Bip32Path<5>, key: KeyTreeNode): KeyTreeNode {
-  const segments = path === '' ? [] : fromString(path).toPathArray();
-  segments.forEach((segment, i) => {
-    if (segment < HARDENED_OFFSET) {
-      throw new DerivationError(`Segment #${i + 1} is not hardened`);
-    }
-  });
-
-  return segments.reduce((parentKey, segment) => deriveChild(parentKey, segment), key);
-}
-
-/**
- * @category hd-wallet
- */
-export function getMasterKeyFromSeed(seed: Uint8Array): KeyTreeNode {
-  const I = hmac(seed, ED25519_CURVE);
-  const IL = I.slice(0, 32);
-  const IR = I.slice(32);
-  return {
-    secretKey: IL,
-    chainCode: IR,
-  };
-}
-
-/**
- * @category hd-wallet
- */
-export function derivePathFromSeed(path: 'm' | `m/${Bip32Path<5>}`, seed: Uint8Array): KeyTreeNode {
-  if (!['m', 'm/'].includes(path.slice(0, 2))) {
-    throw new DerivationError('Root element is required');
-  }
-  const masterKey = getMasterKeyFromSeed(seed);
-  return derivePathFromKey(path.slice(2) as Bip32Path<5>, masterKey);
-}
-
-function formatAccount(keys: nacl.SignKeyPair): Account {
-  const { secretKey, publicKey } = keys;
-  return {
-    secretKey: Buffer.from(secretKey).toString('hex'),
-    publicKey: encode(publicKey, Encoding.AccountAddress),
-  };
-}
-
-/**
- * @category hd-wallet
- */
-export function getKeyPair(secretKey: Uint8Array): nacl.SignKeyPair {
-  return nacl.sign.keyPair.fromSeed(secretKey);
-}
-
-/**
- * @category hd-wallet
- */
-export function generateSaveHDWalletFromSeed(seed: Uint8Array, password: string): HDWallet {
-  const walletKey = derivePathFromSeed('m/44h/457h', seed);
-  return {
-    secretKey: Buffer.from(encryptKey(password, walletKey.secretKey)).toString('hex'),
-    chainCode: Buffer.from(encryptKey(password, walletKey.chainCode)).toString('hex'),
-  };
-}
-
-/**
- * @category hd-wallet
- */
-export function getSaveHDWalletAccounts(
-  saveHDWallet: HDWallet,
-  password: string,
-  accountCount: number,
-): Account[] {
-  const walletKey = {
-    secretKey: decryptKey(password, Buffer.from(saveHDWallet.secretKey, 'hex')),
-    chainCode: decryptKey(password, Buffer.from(saveHDWallet.chainCode, 'hex')),
-  };
-  return (new Array(accountCount)).fill(undefined)
-    .map((_, idx) => formatAccount(getKeyPair(derivePathFromKey(`${idx}h/0h/0h`, walletKey).secretKey)));
-}
-
-/**
- * @category hd-wallet
- */
-export const getHdWalletAccountFromSeed = (
-  seed: Uint8Array,
-  accountIdx: number,
-): Account & { idx: number } => {
-  const walletKey = derivePathFromSeed('m/44h/457h', seed);
-  const derived = derivePathFromKey(`${accountIdx}h/0h/0h`, walletKey);
-  const keyPair = getKeyPair(derived.secretKey);
-  return {
-    ...formatAccount(keyPair),
-    idx: accountIdx,
-  };
-};

package/src/utils/json-big.ts

@@ -1,27 +0,0 @@
-import JsonBig from 'json-bigint';
-import BigNumber from 'bignumber.js';
-import { mapObject } from './other';
-
-const jsonBig = JsonBig({ storeAsString: true });
-
-const convertValuesToBigNumbers = (value: any): any => {
-  if (typeof value === 'object' && value !== null && value.constructor === Object) {
-    return mapObject(value, ([k, v]) => [k, convertValuesToBigNumbers(v)]);
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => convertValuesToBigNumbers(item));
-  }
-  if (typeof value === 'string' && new BigNumber(value).toString(10) === value) {
-    const bn = new BigNumber(value);
-    bn.toJSON = () => bn.toString(10);
-    return bn;
-  }
-  return value;
-};
-
-export default {
-  stringify: (...args: Parameters<typeof JsonBig['stringify']>): string => (
-    jsonBig.stringify(convertValuesToBigNumbers(args[0]), ...args.slice(1))
-  ),
-  parse: jsonBig.parse,
-};

package/src/utils/jwt.ts

@@ -1,126 +0,0 @@
-import canonicalize from 'canonicalize';
-import AccountBase from '../account/Base';
-import {
-  Encoded, Encoding, decode, encode,
-} from './encoder';
-import { verify } from './crypto';
-import { ArgumentError, InvalidSignatureError } from './errors';
-
-// TODO: use Buffer.from(data, 'base64url') after solving https://github.com/feross/buffer/issues/309
-const toBase64Url = (data: Buffer | Uint8Array | string): string => Buffer
-  .from(data)
-  .toString('base64')
-  .replaceAll('/', '_')
-  .replaceAll('+', '-')
-  .replace(/=+$/, '');
-
-const fromBase64Url = (data: string): Buffer => Buffer
-  .from(data.replaceAll('_', '/').replaceAll('-', '+'), 'base64');
-
-const objectToBase64Url = (data: any): string => toBase64Url(canonicalize(data) ?? '');
-
-const header = 'eyJhbGciOiJFZERTQSIsInR5cCI6IkpXVCJ9'; // objectToBase64Url({ alg: 'EdDSA', typ: 'JWT' })
-
-/**
- * JWT including specific header
- * @category JWT
- */
-export type Jwt = `${typeof header}.${string}.${string}`;
-
-/**
- * Generate a signed JWT
- * Provide `"sub_jwk": undefined` in payload to omit signer public key added by default.
- * @param originalPayload - Payload to sign
- * @param account - Account to sign by
- * @category JWT
- */
-export async function signJwt(originalPayload: any, account: AccountBase): Promise<Jwt> {
-  const payload = { ...originalPayload };
-  if (!('sub_jwk' in payload)) {
-    payload.sub_jwk = {
-      kty: 'OKP',
-      crv: 'Ed25519',
-      x: toBase64Url(decode(account.address)),
-    };
-  }
-  if (payload.sub_jwk === undefined) delete payload.sub_jwk;
-  const body = `${header}.${objectToBase64Url(payload)}` as const;
-  const signature = await account.sign(body);
-  return `${body}.${toBase64Url(signature)}`;
-}
-
-/**
- * Unpack JWT. It will check signature if address or "sub_jwk" provided.
- * @param jwt - JWT to unpack
- * @param address - Address to check signature
- * @category JWT
- */
-export function unpackJwt(jwt: Jwt, address?: Encoded.AccountAddress): {
-  /**
-   * JWT payload as object
-   */
-  payload: any;
-  /**
-   * Undefined returned in case signature is not checked
-   */
-  signer: Encoded.AccountAddress | undefined;
-} {
-  const components = jwt.split('.');
-  if (components.length !== 3) throw new ArgumentError('JWT components count', 3, components.length);
-  const [h, payloadEncoded, signature] = components;
-  if (h !== header) throw new ArgumentError('JWT header', header, h);
-  const payload = JSON.parse(fromBase64Url(payloadEncoded).toString());
-  const jwk = payload.sub_jwk ?? {};
-  const signer = jwk.x == null || jwk.kty !== 'OKP' || jwk.crv !== 'Ed25519'
-    ? address
-    : encode(fromBase64Url(jwk.x), Encoding.AccountAddress);
-  if (address != null && signer !== address) {
-    throw new ArgumentError('address', `${signer} ("sub_jwk")`, address);
-  }
-  if (
-    signer != null
-    && !verify(Buffer.from(`${h}.${payloadEncoded}`), fromBase64Url(signature), signer)
-  ) {
-    throw new InvalidSignatureError(`JWT is not signed by ${signer}`);
-  }
-  return { payload, signer };
-}
-
-/**
- * Check is string a JWT or not. Use to validate the user input.
- * @param maybeJwt - A string to check
- * @returns True if argument is a JWT
- * @category JWT
- */
-export function isJwt(maybeJwt: string): maybeJwt is Jwt {
-  try {
-    unpackJwt(maybeJwt as Jwt);
-    return true;
-  } catch (error) {
-    return false;
-  }
-}
-
-/**
- * Throws an error if argument is not JWT. Use to ensure that a value is JWT.
- * @param maybeJwt - A string to check
- * @category JWT
- */
-export function ensureJwt(maybeJwt: string): asserts maybeJwt is Jwt {
-  unpackJwt(maybeJwt as Jwt);
-}
-
-/**
- * Check is JWT signed by address from arguments or "sub_jwk"
- * @param jwt - JWT to check
- * @param address - Address to check signature
- * @category JWT
- */
-export function verifyJwt(jwt: Jwt, address?: Encoded.AccountAddress): boolean {
-  try {
-    const { signer } = unpackJwt(jwt, address);
-    return signer != null;
-  } catch (error) {
-    return false;
-  }
-}

package/src/utils/keystore.ts

@@ -1,189 +0,0 @@
-import nacl from 'tweetnacl';
-import { v4 as uuid } from '@aeternity/uuid';
-import { hash, argon2id } from '@aeternity/argon2';
-import { getAddressFromPriv } from './crypto';
-import { InvalidPasswordError } from './errors';
-
-const DERIVED_KEY_FUNCTIONS = {
-  async argon2id(
-    pass: string | Uint8Array,
-    salt: string | Uint8Array,
-    params: Partial<Keystore['crypto']['kdf_params']>,
-  ): Promise<Uint8Array> {
-    const { memlimit_kib: memoryCost, opslimit: timeCost } = params;
-
-    return hash(pass, {
-      hashLength: 32,
-      salt,
-      timeCost,
-      memoryCost,
-      type: argon2id,
-    });
-  },
-};
-
-const CRYPTO_FUNCTIONS = {
-  'xsalsa20-poly1305': {
-    encrypt: nacl.secretbox,
-    decrypt(...args: Parameters<typeof nacl.secretbox.open>): Uint8Array {
-      const res = nacl.secretbox.open(...args);
-      if (res == null) throw new InvalidPasswordError();
-      return res;
-    },
-  },
-};
-
-export interface Keystore {
-  name: string;
-  version: 1;
-  public_key: string;
-  id: string;
-  crypto: {
-    secret_type: 'ed25519';
-    symmetric_alg: keyof typeof CRYPTO_FUNCTIONS;
-    ciphertext: string;
-    cipher_params: {
-      nonce: string;
-    };
-    /**
-     * Key derivation function name.
-     */
-    kdf: keyof typeof DERIVED_KEY_FUNCTIONS;
-    /**
-     * Key derivation function parameters.
-     */
-    kdf_params: {
-      memlimit_kib: number;
-      opslimit: number;
-      parallelism: number;
-      salt: string;
-    };
-  };
-}
-
-const CRYPTO_DEFAULTS = {
-  secret_type: 'ed25519',
-  symmetric_alg: 'xsalsa20-poly1305',
-  kdf: 'argon2id',
-  kdf_params: {
-    memlimit_kib: 65536,
-    opslimit: 3,
-    parallelism: 1,
-  },
-} as const;
-
-/**
- * Symmetric private key encryption using secret (derived) key.
- * @category keystore
- * @param plaintext - Data to be encrypted.
- * @param key - Secret key.
- * @param nonce - Randomly generated nonce.
- * @param algo - Encryption algorithm.
- * @returns Encrypted data.
- */
-function encrypt(
-  plaintext: Uint8Array,
-  key: Uint8Array,
-  nonce: Uint8Array,
-  algo: keyof typeof CRYPTO_FUNCTIONS = CRYPTO_DEFAULTS.symmetric_alg,
-): Uint8Array {
-  return CRYPTO_FUNCTIONS[algo].encrypt(plaintext, nonce, key);
-}
-
-/**
- * Symmetric private key decryption using secret (derived) key.
- * @category keystore
- * @param ciphertext - Data to be decrypted.
- * @param key - Secret key.
- * @param nonce - Nonce from key-object.
- * @param algo - Encryption algorithm.
- * @returns Decrypted data.
- */
-function decrypt(
-  ciphertext: Uint8Array,
-  key: Uint8Array,
-  nonce: Uint8Array,
-  algo: keyof typeof CRYPTO_FUNCTIONS = CRYPTO_DEFAULTS.symmetric_alg,
-): Uint8Array {
-  return CRYPTO_FUNCTIONS[algo].decrypt(ciphertext, nonce, key);
-}
-
-/**
- * Derive secret key from password with key derivation function.
- * @category keystore
- * @param password - User-supplied password.
- * @param nonce - Randomly generated nonce.
- * @param kdf - Key derivation function.
- * @param kdfParams - KDF parameters.
- * @returns Secret key derived from password.
- */
-async function deriveKey(
-  password: string | Uint8Array,
-  nonce: string | Uint8Array,
-  kdf: Keystore['crypto']['kdf'],
-  kdfParams: Omit<Keystore['crypto']['kdf_params'], 'salt'>,
-): Promise<Uint8Array> {
-  return DERIVED_KEY_FUNCTIONS[kdf](password, nonce, kdfParams);
-}
-
-/**
- * Recover plaintext private key from secret-storage key object.
- * @category keystore
- * @param password - Keystore object password.
- * @param keystore - Keystore object.
- * @returns Plaintext private key.
- */
-export async function recover(
-  password: string | Uint8Array,
-  { crypto }: Keystore,
-): Promise<string> {
-  const salt = Buffer.from(crypto.kdf_params.salt, 'hex');
-  return Buffer.from(decrypt(
-    Buffer.from(crypto.ciphertext, 'hex'),
-    await deriveKey(password, salt, crypto.kdf, crypto.kdf_params),
-    Buffer.from(crypto.cipher_params.nonce, 'hex'),
-    crypto.symmetric_alg,
-  )).toString('hex');
-}
-
-/**
- * Export private key to keystore secret-storage format.
- * @category keystore
- * @param name - Key name.
- * @param password - User-supplied password.
- * @param privateKey - Private key as hex-string or a Buffer.
- * @param nonce - Randomly generated 24byte nonce.
- * @param salt - Randomly generated 16byte salt.
- * @param options - Encryption parameters.
- */
-export async function dump(
-  name: string,
-  password: string | Uint8Array,
-  privateKey: string | Uint8Array,
-  nonce: Uint8Array = nacl.randomBytes(24),
-  salt: Uint8Array = nacl.randomBytes(16),
-  options?: Partial<Keystore['crypto']>,
-): Promise<Keystore> {
-  const opt = { ...CRYPTO_DEFAULTS, ...options };
-  const derivedKey = await deriveKey(password, salt, opt.kdf, opt.kdf_params);
-  const payload = typeof privateKey === 'string' ? Buffer.from(privateKey, 'hex') : privateKey;
-  return {
-    name,
-    version: 1,
-    public_key: getAddressFromPriv(payload),
-    id: uuid(),
-    crypto: {
-      secret_type: opt.secret_type,
-      symmetric_alg: opt.symmetric_alg,
-      ciphertext: Buffer.from(
-        encrypt(payload, derivedKey, nonce, opt.symmetric_alg),
-      ).toString('hex'),
-      cipher_params: { nonce: Buffer.from(nonce).toString('hex') },
-      kdf: opt.kdf,
-      kdf_params: {
-        ...opt.kdf_params,
-        salt: Buffer.from(salt).toString('hex'),
-      },
-    },
-  };
-}

package/src/utils/other.ts

@@ -1,64 +0,0 @@
-import { RestError } from '@azure/core-rest-pipeline';
-
-export const pause = async (duration: number): Promise<void> => new Promise((resolve) => {
-  setTimeout(resolve, duration);
-});
-
-export const mapObject = <InputV, OutputV>(
-  object: { [k: string]: InputV },
-  fn: (
-    value: [string, InputV], index: number, array: Array<[string, InputV]>
-  ) => [number | string, OutputV],
-): { [k: string]: OutputV } => Object.fromEntries(Object.entries(object).map(fn));
-
-// remove after dropping webpack4 support
-const isWebpack4Buffer = (() => {
-  try {
-    Buffer.concat([Uint8Array.from([])]);
-    return false;
-  } catch (error) {
-    return true;
-  }
-})();
-
-export const concatBuffers = isWebpack4Buffer
-  ? (list: readonly Uint8Array[], totalLength?: number): Buffer => (
-    Buffer.concat(list.map((el) => Buffer.from(el)), totalLength)
-  )
-  : Buffer.concat;
-
-/**
- * Object key type guard
- * @param key - Maybe object key
- * @param object - Object
- */
-export function isKeyOfObject<T extends object>(
-  key: string | number | symbol,
-  object: T,
-): key is keyof T {
-  return key in object;
-}
-
-/**
- * Array item type guard
- * @param item - Maybe array item
- * @param array - Array
- */
-export function isItemOfArray<T>(item: any, array: readonly T[]): item is T {
-  return array.includes(item);
-}
-
-export function isAccountNotFoundError(error: Error): boolean {
-  return error instanceof RestError && error.statusCode === 404
-    && error.message.includes('Account not found');
-}
-
-// based on https://stackoverflow.com/a/50375286/6176994
-export type UnionToIntersection<Union> =
-  (Union extends any ? (k: Union) => void : never) extends ((k: infer Intersection) => void)
-    ? Intersection : never;
-
-export function ensureError(error: unknown): asserts error is Error {
-  if (error instanceof Error) return;
-  throw error;
-}

package/src/utils/semver-satisfies.ts

@@ -1,22 +0,0 @@
-function verCmp(a: string, b: string): number {
-  const getComponents = (v: string): number[] => v
-    .split(/[-+]/)[0].split('.').map((i) => +i);
-
-  const aComponents = getComponents(a);
-  const bComponents = getComponents(b);
-
-  const base = Math.max(...aComponents, ...bComponents) + 1;
-  const componentsToNumber = (components: number[]): number => components.reverse()
-    .reduce((acc, n, idx) => acc + n * base ** idx, 0);
-
-  return componentsToNumber(aComponents) - componentsToNumber(bComponents);
-}
-
-export default function semverSatisfies(
-  version: string,
-  geVersion: string,
-  ltVersion?: string,
-): boolean {
-  return verCmp(version, geVersion) >= 0
-    && (ltVersion == null || verCmp(version, ltVersion) < 0);
-}

package/src/utils/string.ts

@@ -1,17 +0,0 @@
-/**
- * Convert string from snake_case to PascalCase
- * @param s - String to convert
- * @returns Converted string
- */
-export function snakeToPascal(s: string): string {
-  return s.replace(/_./g, (match) => match[1].toUpperCase());
-}
-
-/**
- * Convert string from PascalCase to snake_case
- * @param s - String to convert
- * @returns Converted string
- */
-export function pascalToSnake(s: string): string {
-  return s.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`);
-}

package/src/utils/typed-data.ts

@@ -1,69 +0,0 @@
-import { TypeResolver, ContractByteArrayEncoder } from '@aeternity/aepp-calldata';
-import canonicalize from 'canonicalize';
-import { Encoded, decode } from './encoder';
-import { hash, messagePrefixLength } from './crypto';
-import { concatBuffers } from './other';
-
-/**
- * Hashes arbitrary object, can be used to inline the aci hash to contract source code
- */
-export function hashJson(data: unknown): Buffer {
-  return hash(canonicalize(data) ?? '');
-}
-
-// TODO: move this type to calldata library https://github.com/aeternity/aepp-calldata-js/issues/215
-// based on https://github.com/aeternity/aepp-calldata-js/blob/82b5a98f9b308482627da8d7484d213e9cf87151/src/AciTypeResolver.js#L129
-export type AciValue = 'void' | 'unit' | 'int' | 'bool' | 'string' | 'bits' | 'hash' | 'signature'
-| 'address' | 'contract_pubkey' | 'Chain.ttl' | 'Chain.ga_meta_tx' | 'Chain.paying_for_tx'
-| 'Chain.base_tx' | 'AENS.pointee' | 'AENS.name' | 'MCL_BLS12_381.fr' | 'MCL_BLS12_381.fp'
-| { 'Set.set': readonly [AciValue] }
-| { bytes: number }
-| { list: readonly [AciValue] }
-| { map: readonly [AciValue, AciValue] }
-| { tuple: readonly AciValue[] }
-| { record: ReadonlyArray<{ name: string; type: AciValue }> }
-| { variant: ReadonlyArray<{ [key: string]: readonly AciValue[] }> }
-| { option: readonly [AciValue] }
-| { oracle: readonly [AciValue, AciValue] }
-| { oracle_query: readonly [AciValue, AciValue] };
-
-export interface Domain {
-  name?: string;
-  version?: number;
-  networkId?: string;
-  contractAddress?: Encoded.ContractAddress;
-}
-
-/**
- * Hashes domain object, can be used to inline domain hash to contract source code
- */
-export function hashDomain(domain: Domain): Buffer {
-  const domainAci = {
-    record: [{
-      name: 'name',
-      type: { option: ['string'] },
-    }, {
-      name: 'version',
-      type: { option: ['int'] },
-    }, {
-      name: 'networkId',
-      type: { option: ['string'] },
-    }, {
-      name: 'contractAddress',
-      type: { option: ['contract_pubkey'] },
-    }],
-  } as const;
-  const domainType = new TypeResolver().resolveType(domainAci, {});
-  const fateValue = new ContractByteArrayEncoder().encodeWithType(domain, domainType);
-  return hash(decode(fateValue));
-}
-
-export function hashTypedData(
-  data: Encoded.ContractBytearray,
-  aci: AciValue,
-  domain: Domain,
-): Buffer {
-  return hash(concatBuffers([
-    messagePrefixLength, new Uint8Array([0]), hashDomain(domain), hashJson(aci), hash(decode(data)),
-  ]));
-}