@aeternity/aepp-sdk 12.1.2 → 13.0.0-alpha.0

package/src/tx/validator.ts

@@ -11,17 +11,11 @@ import {
 import { Tag } from './builder/constants';
 import { TxUnpacked, unpackTx } from './builder';
 import { UnsupportedProtocolError } from '../utils/errors';
-import { concatBuffers, isKeyOfObject } from '../utils/other';
-import {
-  decode, encode, Encoded, Encoding,
-} from '../utils/encoder';
-import Node from '../Node';
-
-interface Account {
-  balance: bigint;
-  id: Encoded.AccountAddress;
-  nonce: number;
-}
+import { concatBuffers, isAccountNotFoundError, isKeyOfObject } from '../utils/other';
+import { encode, Encoded, Encoding } from '../utils/encoder';
+import Node, { TransformNodeType } from '../Node';
+import { Account } from '../apis/node';
+import { genAggressiveCacheGetResponsesPolicy } from '../utils/autorest';
 
 export interface ValidatorResult {
   message: string;
@@ -46,7 +40,8 @@ type Validator = (
     contractId?: Encoded.ContractAddress;
   },
   options: {
-    account?: Account;
+    // TODO: remove after fixing node types
+    account?: TransformNodeType<Account> & { id: Encoded.AccountAddress };
     nodeNetworkId: string;
     parentTxTypes: Tag[];
     node: Node;
@@ -74,16 +69,25 @@ const getSenderAddress = (
  * to make sure it can be posted it to the chain
  * @category transaction builder
  * @param transaction - Base64Check-encoded transaction
- * @param node - Node to validate transaction against
+ * @param nodeNotCached - Node to validate transaction against
  * @param parentTxTypes - Types of parent transactions
  * @returns Array with verification errors
  * @example const errors = await verifyTransaction(transaction, node)
  */
 export default async function verifyTransaction(
   transaction: Encoded.Transaction | Encoded.Poi,
-  node: Node,
+  nodeNotCached: Node,
   parentTxTypes: Tag[] = [],
 ): Promise<ValidatorResult[]> {
+  let node = nodeNotCached;
+  if (
+    !node.pipeline.getOrderedPolicies()
+      .some(({ name }) => name === 'aggressive-cache-get-responses')
+  ) {
+    node = new Node(nodeNotCached.$host, { ignoreVersion: true });
+    node.pipeline.addPolicy(genAggressiveCacheGetResponsesPolicy());
+  }
+
   const { tx, txType } = unpackTx<Tag.SignedTx>(transaction);
   const address = getSenderAddress(tx)
     ?? (txType === Tag.SignedTx ? getSenderAddress(tx.encodedTx.tx) : undefined);
@@ -91,7 +95,10 @@ export default async function verifyTransaction(
     address == null
       ? undefined
       : node.getAccountByPubkey(address)
-        .catch(() => ({ id: address, balance: 0n, nonce: 0 }))
+        .catch((error) => {
+          if (!isAccountNotFoundError(error)) throw error;
+          return { id: address, balance: 0n, nonce: 0 };
+        })
         // TODO: remove after fixing https://github.com/aeternity/aepp-sdk-js/issues/1537
         .then((acc) => ({ ...acc, id: acc.id as Encoded.AccountAddress })),
     node.getCurrentKeyBlockHeight(),
@@ -119,9 +126,8 @@ validators.push(
     ].join('-'));
     const txWithNetworkId = concatBuffers([prefix, encodedTx.rlpEncoded]);
     const txHashWithNetworkId = concatBuffers([prefix, hash(encodedTx.rlpEncoded)]);
-    const decodedPub = decode(account.id);
-    if (verify(txWithNetworkId, signatures[0], decodedPub)
-      || verify(txHashWithNetworkId, signatures[0], decodedPub)) return [];
+    if (verify(txWithNetworkId, signatures[0], account.id)
+      || verify(txHashWithNetworkId, signatures[0], account.id)) return [];
     return [{
       message: 'Signature cannot be verified, please ensure that you transaction have'
         + ' the correct prefix and the correct private key for the sender address',
@@ -163,6 +169,18 @@ validators.push(
       checkedKeys: ['amount', 'fee', 'nameFee'],
     }];
   },
+  ({ signatures }, { account, txType }) => {
+    if (account == null) return [];
+    let message;
+    if (txType === Tag.SignedTx && account.kind === 'generalized' && signatures.length !== 0) {
+      message = 'Generalized account can\'t be used to generate SignedTx with signatures';
+    }
+    if (txType === Tag.GaMetaTx && account.kind === 'basic') {
+      message = 'Basic account can\'t be used to generate GaMetaTx';
+    }
+    if (message == null) return [];
+    return [{ message, key: 'InvalidAccountType', checkedKeys: ['tag'] }];
+  },
   ({ nonce }, { account, parentTxTypes }) => {
     if (nonce == null || account == null || parentTxTypes.includes(Tag.GaMetaTx)) return [];
     nonce = +nonce;

package/src/typings/@aeternity__aepp-calldata/index.d.ts

@@ -0,0 +1,20 @@
+declare module '@aeternity/aepp-calldata' {
+  // eslint-disable-next-line import/prefer-default-export
+  export class Encoder {
+    constructor(aci: object);
+
+    encode(contract: string, funName: string, args: any[]): `cb_${string}`;
+
+    decode(contract: string, funName: string, data: `cb_${string}`): any;
+
+    decodeString(data: `cb_${string}`): Uint8Array;
+
+    decodeFateString(data: `cb_${string}`): string;
+
+    decodeEvent(
+      contract: string,
+      encodedData: `cb_${string}`,
+      topics: BigInt[],
+    ): { [key: string]: any[] };
+  }
+}

package/src/utils/autorest.ts

@@ -31,7 +31,7 @@ export const genCombineGetRequestsPolicy = (): AdditionalPolicyConfig => {
 
   return {
     policy: {
-      name: 'combine-requests',
+      name: 'combine-get-requests',
       async sendRequest(request, next) {
         if (request.method !== 'GET') return next(request);
         const key = JSON.stringify([request.url, request.body]);
@@ -48,6 +48,21 @@ export const genCombineGetRequestsPolicy = (): AdditionalPolicyConfig => {
   };
 };
 
+export const genAggressiveCacheGetResponsesPolicy = (): PipelinePolicy => {
+  const getRequests = new Map<string, Promise<PipelineResponse>>();
+
+  return {
+    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;
+    },
+  };
+};
+
 export const genErrorFormatterPolicy = (
   getMessage: (b: any) => string,
 ): AdditionalPolicyConfig => ({

package/src/utils/bytes.ts

@@ -16,19 +16,6 @@
  */
 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');
-}
 
 /**
  * Convert string, number, or BigNumber to byte array
@@ -36,6 +23,7 @@ export function bigNumberToByteArray(x: BigNumber): Buffer {
  * @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
@@ -44,29 +32,13 @@ export function toBytes(val?: null | string | number | BigNumber, big = false):
   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 (!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();
 }
-
-/**
- * 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 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 {
-  return Buffer.from(
-    str,
-    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

@@ -20,7 +20,6 @@ import nacl, { SignKeyPair } from 'tweetnacl';
 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,
@@ -28,11 +27,11 @@ import {
 
 /**
  * Generate address from secret key
- * @param secret - Private 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' ? str2buf(secret) : secret;
+  const secretBuffer = typeof secret === 'string' ? Buffer.from(secret, 'hex') : secret;
   const keys = nacl.sign.keyPair.fromSecretKey(secretBuffer);
   return encode(keys.publicKey, Encoding.AccountAddress);
 }
@@ -60,7 +59,8 @@ export function isAddressValid(
  * @returns random salt
  */
 export function genSalt(): number {
-  return Math.floor(Math.random() * Math.floor(Number.MAX_SAFE_INTEGER));
+  const [random] = new BigUint64Array(nacl.randomBytes(8).buffer);
+  return Number(random % BigInt(Number.MAX_SAFE_INTEGER));
 }
 
 /**
@@ -155,18 +155,17 @@ export function sign(data: string | Uint8Array, privateKey: string | Uint8Array)
 
 /**
  * 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?
+ * @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,
-  publicKey: string | Uint8Array,
+  address: Encoded.AccountAddress,
 ): boolean {
-  const publicKeyBuffer = typeof publicKey === 'string' ? str2buf(publicKey) : publicKey;
-  return nacl.sign.detached.verify(data, signature, publicKeyBuffer);
+  return nacl.sign.detached.verify(data, signature, decode(address));
 }
 
 export function messageToHash(message: string): Buffer {
@@ -179,12 +178,19 @@ export function signMessage(message: string, privateKey: string | Buffer): Uint8
   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
+ */
 export function verifyMessage(
-  str: string,
+  message: string,
   signature: Uint8Array,
-  publicKey: string | Uint8Array,
+  address: Encoded.AccountAddress,
 ): boolean {
-  return verify(messageToHash(str), signature, publicKey);
+  return verify(messageToHash(message), signature, address);
 }
 
 /**
@@ -192,7 +198,7 @@ export function verifyMessage(
  *
  * Sign a message, and then verifying that signature
  * @param privateKey - Private key to verify
- * @param publicKey - Public key to verify
+ * @param publicKey - Public key to verify as hex string
  * @returns Valid?
  */
 export function isValidKeypair(
@@ -201,5 +207,6 @@ export function isValidKeypair(
 ): boolean {
   const message = Buffer.from('TheMessage');
   const signature = sign(message, privateKey);
-  return verify(message, signature, publicKey);
+  const publicKeyBuffer = typeof publicKey === 'string' ? Buffer.from(publicKey, 'hex') : publicKey;
+  return verify(message, signature, encode(publicKeyBuffer, Encoding.AccountAddress));
 }

package/src/utils/encoder.ts

@@ -18,7 +18,6 @@ export { Encoded, Encoding };
  * Calculate SHA256 hash of `input`
  * @param input - Data to hash
  * @returns Hash
- * @deprecated use `SubtleCrypto.digest` or `sha.js` package instead
  */
 export function sha256hash(input: Uint8Array | string): Buffer {
   return new Sha256().update(input).digest();

package/src/utils/errors.ts

@@ -265,16 +265,6 @@ export class UnexpectedTsError extends InternalError {
   }
 }
 
-/**
- * @category exception
- */
-export class InvalidKeypairError extends AccountError {
-  constructor(message: string) {
-    super(message);
-    this.name = 'InvalidKeypairError';
-  }
-}
-
 /**
  * @category exception
  */
@@ -405,6 +395,22 @@ export class UnexpectedChannelMessageError extends ChannelError {
   }
 }
 
+/**
+ * @category exception
+ */
+export class ChannelIncomingMessageError extends ChannelError {
+  handlerError: BaseError;
+
+  incomingMessage: { [key: string]: any };
+
+  constructor(handlerError: BaseError, incomingMessage: { [key: string]: any }) {
+    super(handlerError.message);
+    this.handlerError = handlerError;
+    this.incomingMessage = incomingMessage;
+    this.name = 'ChannelIncomingMessageError';
+  }
+}
+
 /**
  * @category exception
  */
@@ -550,8 +556,8 @@ export class MissingEventDefinitionError extends ContractError {
 export class AmbiguousEventDefinitionError extends ContractError {
   constructor(eventAddress: string, matchedEvents: Array<[string, string]>) {
     super(
-      `Found multiple definitions of "${matchedEvents[0][1]}" event emitted by ${eventAddress}`
-      + ` in ${matchedEvents.map(([name]) => `"${name}"`).join(', ')} contracts`
+      `Found multiple definitions of "${matchedEvents[0][1]}" event with different types emitted by`
+      + ` ${eventAddress} in ${matchedEvents.map(([name]) => `"${name}"`).join(', ')} contracts`
       + ' (use contractAddressToName option to specify contract name corresponding to address)',
     );
     this.name = 'AmbiguousEventDefinitionError';

package/src/utils/hd-wallet.ts

@@ -4,20 +4,18 @@ import { fromString } from 'bip32-path';
 import aesjs from 'aes-js';
 import { sha256hash, encode, Encoding } from './encoder';
 import { CryptographyError } from './errors';
-import { bytesToHex } from './bytes';
 import { concatBuffers } from './other';
 
 const Ecb = aesjs.ModeOfOperation.ecb;
 
-// TODO: at least don't export `encryptKey` and `decryptKey`
+// 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
- * @deprecated use 'sha.js' and 'aes-js' packages directly instead
  */
-export function encryptKey(password: string, binaryData: Uint8Array): Uint8Array {
+function encryptKey(password: string, binaryData: Uint8Array): Uint8Array {
   const hashedPasswordBytes = sha256hash(password);
   const aesEcb = new Ecb(hashedPasswordBytes);
   return aesEcb.encrypt(binaryData);
@@ -28,9 +26,8 @@ export function encryptKey(password: string, binaryData: Uint8Array): Uint8Array
  * @param password - Password to decrypt with
  * @param encrypted - Data to decrypt
  * @returns Decrypted data
- * @deprecated use 'sha.js' and 'aes-js' packages directly instead
  */
-export function decryptKey(password: string, encrypted: Uint8Array): Uint8Array {
+function decryptKey(password: string, encrypted: Uint8Array): Uint8Array {
   const encryptedBytes = Buffer.from(encrypted);
   const hashedPasswordBytes = sha256hash(password);
   const aesEcb = new Ecb(hashedPasswordBytes);
@@ -72,6 +69,9 @@ type Bip32PathT<MaxLen extends number, H extends 'H' | 'h' | '\''> = MaxLen exte
 type Bip32Path<MaxLen extends number> =
   '' | Bip32PathT<MaxLen, 'H'> | Bip32PathT<MaxLen, 'h'> | Bip32PathT<MaxLen, '\''>;
 
+/**
+ * @category hd-wallet
+ */
 export function deriveChild({ secretKey, chainCode }: KeyTreeNode, index: number): KeyTreeNode {
   if (index < HARDENED_OFFSET) {
     throw new DerivationError(`Segment ${index} is not hardened`);
@@ -90,6 +90,9 @@ export function deriveChild({ secretKey, chainCode }: KeyTreeNode, index: number
   };
 }
 
+/**
+ * @category hd-wallet
+ */
 export function derivePathFromKey(path: Bip32Path<5>, key: KeyTreeNode): KeyTreeNode {
   const segments = path === '' ? [] : fromString(path).toPathArray();
   segments.forEach((segment, i) => {
@@ -101,6 +104,9 @@ export function derivePathFromKey(path: Bip32Path<5>, key: KeyTreeNode): KeyTree
   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);
@@ -111,6 +117,9 @@ export function getMasterKeyFromSeed(seed: Uint8Array): KeyTreeNode {
   };
 }
 
+/**
+ * @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');
@@ -122,23 +131,32 @@ export function derivePathFromSeed(path: 'm' | `m/${Bip32Path<5>}`, seed: Uint8A
 function formatAccount(keys: nacl.SignKeyPair): Account {
   const { secretKey, publicKey } = keys;
   return {
-    secretKey: bytesToHex(secretKey),
+    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: bytesToHex(encryptKey(password, walletKey.secretKey)),
-    chainCode: bytesToHex(encryptKey(password, walletKey.chainCode)),
+    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,
@@ -152,6 +170,9 @@ export function getSaveHDWalletAccounts(
     .map((_, idx) => formatAccount(getKeyPair(derivePathFromKey(`${idx}h/0h/0h`, walletKey).secretKey)));
 }
 
+/**
+ * @category hd-wallet
+ */
 export const getHdWalletAccountFromSeed = (
   seed: Uint8Array,
   accountIdx: number,

package/src/utils/keystore.ts

@@ -1,10 +1,7 @@
 import nacl from 'tweetnacl';
 import { v4 as uuid } from '@aeternity/uuid';
-// js extension is required for mjs build
-// eslint-disable-next-line import/extensions
-import { ArgonType, hash } from '@aeternity/argon2-browser/dist/argon2-bundled.min.js';
+import { hash, argon2id } from '@aeternity/argon2';
 import { getAddressFromPriv } from './crypto';
-import { bytesToHex, hexToBytes } from './bytes';
 import { InvalidPasswordError } from './errors';
 
 const DERIVED_KEY_FUNCTIONS = {
@@ -13,16 +10,15 @@ const DERIVED_KEY_FUNCTIONS = {
     salt: string | Uint8Array,
     params: Partial<Keystore['crypto']['kdf_params']>,
   ): Promise<Uint8Array> {
-    const { memlimit_kib: mem, opslimit: time } = params;
+    const { memlimit_kib: memoryCost, opslimit: timeCost } = params;
 
-    return (await hash({
-      hashLen: 32,
-      pass,
+    return hash(pass, {
+      hashLength: 32,
       salt,
-      time,
-      mem,
-      type: ArgonType.Argon2id,
-    })).hash;
+      timeCost,
+      memoryCost,
+      type: argon2id,
+    });
   },
 };
 
@@ -72,6 +68,7 @@ const CRYPTO_DEFAULTS = {
 
 /**
  * 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.
@@ -89,6 +86,7 @@ function encrypt(
 
 /**
  * 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.
@@ -106,6 +104,7 @@ function decrypt(
 
 /**
  * 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.
@@ -123,6 +122,7 @@ async function deriveKey(
 
 /**
  * Recover plaintext private key from secret-storage key object.
+ * @category keystore
  * @param password - Keystore object password.
  * @param keystore - Keystore object.
  * @returns Plaintext private key.
@@ -131,17 +131,18 @@ export async function recover(
   password: string | Uint8Array,
   { crypto }: Keystore,
 ): Promise<string> {
-  const salt = hexToBytes(crypto.kdf_params.salt);
-  return bytesToHex(decrypt(
-    hexToBytes(crypto.ciphertext),
+  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),
-    hexToBytes(crypto.cipher_params.nonce),
+    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.
@@ -161,7 +162,7 @@ export async function dump(
 ): Promise<Keystore> {
   const opt = { ...CRYPTO_DEFAULTS, ...options };
   const derivedKey = await deriveKey(password, salt, opt.kdf, opt.kdf_params);
-  const payload = typeof privateKey === 'string' ? hexToBytes(privateKey) : privateKey;
+  const payload = typeof privateKey === 'string' ? Buffer.from(privateKey, 'hex') : privateKey;
   return {
     name,
     version: 1,
@@ -170,12 +171,14 @@ export async function dump(
     crypto: {
       secret_type: opt.secret_type,
       symmetric_alg: opt.symmetric_alg,
-      ciphertext: bytesToHex(encrypt(payload, derivedKey, nonce, opt.symmetric_alg)),
-      cipher_params: { nonce: bytesToHex(nonce) },
+      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: bytesToHex(salt),
+        salt: Buffer.from(salt).toString('hex'),
       },
     },
   };

package/src/utils/other.ts

@@ -1,3 +1,5 @@
+import { RestError } from '@azure/core-rest-pipeline';
+
 export const pause = async (duration: number): Promise<void> => new Promise((resolve) => {
   setTimeout(resolve, duration);
 });
@@ -30,7 +32,10 @@ export const concatBuffers = isWebpack4Buffer
  * @param key - Maybe object key
  * @param object - Object
  */
-export function isKeyOfObject<T>(key: string | number | symbol, object: T): key is keyof T {
+export function isKeyOfObject<T extends object>(
+  key: string | number | symbol,
+  object: T,
+): key is keyof T {
   return key in object;
 }
 
@@ -42,3 +47,13 @@ export function isKeyOfObject<T>(key: string | number | symbol, object: T): key
 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;

package/src/utils/string.ts

@@ -32,23 +32,3 @@ export function snakeToPascal(s: string): string {
 export function pascalToSnake(s: string): string {
   return s.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`);
 }
-
-/**
- * Check whether a string is valid hex.
- * @param str - String to validate.
- * @returns True if the string is valid hex, false otherwise.
- */
-export function isHex(str: string): boolean {
-  return str.length % 2 === 0 && /^[0-9a-f]+$/i.test(str);
-}
-
-/**
- * Check whether a string is valid base-64.
- * @param str - String to validate.
- * @returns True if the string is valid base-64, false otherwise.
- */
-export function isBase64(str: string): boolean {
-  if (str.length % 4 > 0 || /[^0-9a-z+/=]/i.test(str)) return false;
-  const index = str.indexOf('=');
-  return index === -1 || /={1,2}/.test(str.slice(index));
-}