@aeternity/aepp-sdk 13.0.1 → 13.2.0

package/src/contract/compiler/HttpNode.ts

@@ -18,6 +18,12 @@ export default class CompilerHttpNode extends HttpBrowser {
     return this.compileBySourceCode(sourceCode, fileSystem);
   }
 
+  override async generateAci(path: string): Promise<Aci> {
+    const fileSystem = await getFileSystem(path);
+    const sourceCode = await readFile(path, 'utf8');
+    return this.generateAciBySourceCode(sourceCode, fileSystem);
+  }
+
   override async validate(bytecode: Encoded.ContractBytearray, path: string): Promise<boolean> {
     const fileSystem = await getFileSystem(path);
     const sourceCode = await readFile(path, 'utf8');

package/src/contract/delegation-signature.ts

@@ -1,10 +1,14 @@
 import { decode, Encoded } from '../utils/encoder';
+import { ArgumentError } from '../utils/errors';
 import { AensName } from '../tx/builder/constants';
 import AccountBase from '../account/Base';
-import { concatBuffers } from '../utils/other';
-import { isNameValid, produceNameId } from '../tx/builder/helpers';
+import { isNameValid } from '../tx/builder/helpers';
 import Node from '../Node';
 
+function ensureOracleQuery(oq: string): asserts oq is Encoded.OracleQueryId {
+  if (!oq.startsWith('oq_')) throw new ArgumentError('oq', 'oracle query', oq);
+}
+
 /**
  * Helper to generate a signature to delegate
  *  - pre-claim/claim/transfer/revoke of a name to a contract.
@@ -17,6 +21,7 @@ import Node from '../Node';
  * @param options.onAccount - Account to use
  * @param options.onNode - Node to use
  * @returns Signature
+ * @deprecated use methods `sign*DelegationToContract` of Account instance instead
  * @example
  * ```js
  * const aeSdk = new AeSdk({ ... })
@@ -42,15 +47,36 @@ import Node from '../Node';
 export default async function createDelegationSignature(
   contractAddress: Encoded.ContractAddress,
   ids: Array<Encoded.Any | AensName>,
-  options: { omitAddress?: boolean; onAccount: AccountBase; onNode: Node },
+  { onAccount, omitAddress, ...options }: {
+    omitAddress?: boolean;
+    onAccount: AccountBase;
+    onNode: Node;
+  },
 ): Promise<Uint8Array> {
-  return options.onAccount.sign(
-    concatBuffers([
-      Buffer.from(await options.onNode.getNetworkId()),
-      ...options.omitAddress === true ? [] : [decode(options.onAccount.address)],
-      ...ids.map((e) => (isNameValid(e) ? produceNameId(e) : e)).map((e) => decode(e)),
-      decode(contractAddress),
-    ]),
-    options,
+  if (ids.length > 1) throw new ArgumentError('ids', 'shorter than 2', ids);
+  const networkId = await options.onNode.getNetworkId();
+  if (ids.length === 0) {
+    if (omitAddress === true) {
+      throw new ArgumentError('omitAddress', 'equal false', omitAddress);
+    }
+    return decode(await onAccount.signDelegationToContract(contractAddress, { networkId }));
+  }
+
+  const [payload] = ids;
+  if (isNameValid(payload)) {
+    if (omitAddress === true) {
+      throw new ArgumentError('omitAddress', 'equal false', omitAddress);
+    }
+    return decode(
+      await onAccount.signNameDelegationToContract(contractAddress, payload, { networkId }),
+    );
+  }
+
+  ensureOracleQuery(payload);
+  if (omitAddress !== true) {
+    throw new ArgumentError('omitAddress', 'equal true', omitAddress);
+  }
+  return decode(
+    await onAccount.signOracleQueryDelegationToContract(contractAddress, payload, { networkId }),
   );
 }

package/src/deprecated.ts

@@ -0,0 +1,23 @@
+import { RpcError } from './aepp-wallet-communication/schema';
+
+/**
+ * @category exception
+ * @deprecated this exception is not thrown anymore
+ */
+// eslint-disable-next-line import/prefer-default-export
+export class RpcBroadcastError extends RpcError {
+  static override code = 3;
+
+  override code = 3;
+
+  constructor(data?: any) {
+    super('Broadcast failed');
+    this.data = data;
+    this.name = 'RpcBroadcastError';
+  }
+}
+
+/**
+ * @deprecated use isAuctionName instead
+ */
+export const NAME_BID_MAX_LENGTH = 12; // # this is the max length for a domain to be part of a bid

package/src/index-browser.ts

@@ -1,13 +1,30 @@
-// TODO: avoid `export * from`
-export * from './chain';
-export * from './utils/crypto';
-export * from './utils/keystore';
-export * from './utils/bytes';
+export {
+  _getPollInterval, InvalidTxError, getHeight, poll, awaitHeight, waitForTxConfirm, sendTransaction,
+  getAccount, getBalance, getCurrentGeneration, getGeneration, getMicroBlockTransactions,
+  getKeyBlock, getMicroBlockHeader, txDryRun, getContractByteCode, getContract, getName,
+  resolveName,
+} from './chain';
+export {
+  getAddressFromPriv, isAddressValid, genSalt, encodeUnsigned, hash, encodeContractAddress,
+  generateKeyPairFromSecret, generateKeyPair, sign, verify, messageToHash, signMessage,
+  verifyMessage, isValidKeypair,
+} from './utils/crypto';
+export { recover, dump } from './utils/keystore';
+export type { Keystore } from './utils/keystore';
+export { toBytes } from './utils/bytes';
 export {
   buildTx, buildTxAsync, buildTxHash, unpackTx, buildContractIdByContractTx,
 } from './tx/builder';
-export * from './tx/builder/helpers';
-export * from './tx/builder/constants';
+export {
+  buildContractId, oracleQueryId, produceNameId, commitmentHash, readInt, isNameValid, ensureName,
+  getDefaultPointerKey, getMinimumNameFee, computeBidFee, computeAuctionEndBlock, isAuctionName,
+} from './tx/builder/helpers';
+export {
+  MAX_AUTH_FUN_GAS, NAME_TTL, NAME_MAX_TTL, NAME_MAX_CLIENT_TTL, CLIENT_TTL, MIN_GAS_PRICE,
+  NAME_FEE_MULTIPLIER, NAME_FEE_BID_INCREMENT, NAME_BID_TIMEOUT_BLOCKS, NAME_MAX_LENGTH_FEE,
+  NAME_BID_RANGES, ConsensusProtocolVersion, VmVersion, AbiVersion, Tag,
+} from './tx/builder/constants';
+export type { Int, AensName } from './tx/builder/constants';
 // TODO: move to constants
 export {
   ORACLE_TTL_TYPES, ORACLE_TTL, QUERY_TTL, RESPONSE_TTL, DRY_RUN_ACCOUNT, CallReturnType,
@@ -16,17 +33,30 @@ export {
   getExecutionCost, getExecutionCostBySignedTx, getExecutionCostUsingNode,
 } from './tx/execution-cost';
 export { default as getTransactionSignerAddress } from './tx/transaction-signer';
-export * from './utils/amount-formatter';
-export * from './utils/hd-wallet';
+export {
+  AE_AMOUNT_FORMATS, formatAmount, toAe, toAettos, prefixedAmount,
+} from './utils/amount-formatter';
+export {
+  DerivationError, deriveChild, derivePathFromKey, getMasterKeyFromSeed, derivePathFromSeed,
+  getKeyPair, generateSaveHDWalletFromSeed, getSaveHDWalletAccounts, getHdWalletAccountFromSeed,
+} from './utils/hd-wallet';
 export {
   encode, decode, Encoding, Encoded,
 } from './utils/encoder';
-export * from './aens';
+export {
+  encodeFateValue, decodeFateValue, hashTypedData, hashDomain, hashJson,
+} from './utils/typed-data';
+export {
+  aensRevoke, aensUpdate, aensTransfer, aensQuery, aensClaim, aensPreclaim, aensBid,
+} from './aens';
 export { default as Contract } from './contract/Contract';
 export type { ContractMethodsBase } from './contract/Contract';
-export * from './oracle';
-export * from './spend';
-export * from './contract/ga';
+export {
+  pollForQueries, pollForQueryResponse, getQueryObject, postQueryToOracle, extendOracleTtl,
+  respondToQuery, getOracleObject, registerOracle,
+} from './oracle';
+export { spend, transferFunds, payForTransaction } from './spend';
+export { createGeneralizedAccount, buildAuthTxHash, buildAuthTxHashByGaMetaTx } from './contract/ga';
 
 export { default as AeSdkMethods } from './AeSdkMethods';
 export { default as AeSdkBase } from './AeSdkBase';
@@ -43,10 +73,42 @@ export { default as AccountLedgerFactory } from './account/LedgerFactory';
 export { default as CompilerBase } from './contract/compiler/Base';
 export { default as CompilerHttp } from './contract/compiler/Http';
 export { default as Channel } from './channel/Contract';
+export {
+  default as _MiddlewareSubscriber,
+  MiddlewareSubscriberError as _MiddlewareSubscriberError,
+  MiddlewareSubscriberDisconnected as _MiddlewareSubscriberDisconnected,
+} from './MiddlewareSubscriber';
+export { default as _Middleware } from './Middleware';
 
 export { default as connectionProxy } from './aepp-wallet-communication/connection-proxy';
-export * from './aepp-wallet-communication/schema';
+export {
+  MESSAGE_DIRECTION, WALLET_TYPE, SUBSCRIPTION_TYPES, METHODS, RPC_STATUS, RpcError,
+  RpcInvalidTransactionError, RpcRejectedByUserError, RpcUnsupportedProtocolError,
+  RpcConnectionDenyError, RpcNotAuthorizeError, RpcPermissionDenyError, RpcInternalError,
+  RpcMethodNotFoundError,
+} from './aepp-wallet-communication/schema';
 export { default as walletDetector } from './aepp-wallet-communication/wallet-detector';
 export { default as BrowserRuntimeConnection } from './aepp-wallet-communication/connection/BrowserRuntime';
 export { default as BrowserWindowMessageConnection } from './aepp-wallet-communication/connection/BrowserWindowMessage';
-export * from './utils/errors';
+export {
+  BaseError, AccountError, AensError, AeppError, ChannelError, CompilerError, ContractError,
+  CryptographyError, NodeError, TransactionError, WalletError, ArgumentError, IllegalArgumentError,
+  ArgumentCountMismatchError, InsufficientBalanceError, MissingParamError, NoSerializerFoundError,
+  RequestTimedOutError, TxTimedOutError, TypeError, UnsupportedPlatformError,
+  UnsupportedProtocolError, NotImplementedError, UnsupportedVersionError, InternalError,
+  UnexpectedTsError, UnavailableAccountError, AensPointerContextError, InsufficientNameFeeError,
+  InvalidAensNameError, InvalidRpcMessageError, MissingCallbackError, UnAuthorizedAccountError,
+  UnknownRpcClientError, UnsubscribedAccountError, ChannelCallError, ChannelConnectionError,
+  ChannelPingTimedOutError, UnexpectedChannelMessageError, ChannelIncomingMessageError,
+  UnknownChannelStateError, InvalidAuthDataError, BytecodeMismatchError, DuplicateContractError,
+  InactiveContractError, InvalidMethodInvocationError, MissingContractAddressError,
+  MissingContractDefError, MissingFunctionNameError, NodeInvocationError,
+  NoSuchContractFunctionError, NotPayableFunctionError, MissingEventDefinitionError,
+  AmbiguousEventDefinitionError, InvalidChecksumError, InvalidPasswordError,
+  MerkleTreeHashMismatchError, MissingNodeInTreeError, UnknownNodeLengthError,
+  UnknownPathNibbleError, DuplicateNodeError, NodeNotFoundError, DecodeError, PayloadLengthError,
+  DryRunError, IllegalBidFeeError, InvalidSignatureError, PrefixNotFoundError, SchemaNotFoundError,
+  TagNotFoundError, TxNotInChainError, AlreadyConnectedError, NoWalletConnectedError,
+  RpcConnectionError,
+} from './utils/errors';
+export { RpcBroadcastError, NAME_BID_MAX_LENGTH } from './deprecated';

package/src/spend.ts

@@ -60,11 +60,11 @@ interface SpendOptions extends SpendOptionsType {}
  * ```
  */
 export async function transferFunds(
-  fraction: number | string,
+  fraction: number | string, // TODO: accept only number
   recipientIdOrName: AensName | Encoded.AccountAddress,
   options: TransferFundsOptions,
 ): ReturnType<typeof sendTransaction> {
-  if (fraction < 0 || fraction > 1) {
+  if (+fraction < 0 || +fraction > 1) {
     throw new ArgumentError('fraction', 'a number between 0 and 1', fraction);
   }
   const recipientId = await resolveName<Encoding.AccountAddress>(

package/src/tx/builder/constants.ts

@@ -20,7 +20,6 @@ export const NAME_FEE_BID_INCREMENT = 0.05; // # the increment is in percentage
 export const NAME_BID_TIMEOUT_BLOCKS = 480; // # ~1 day
 // # this is the max length for a domain that requires a base fee to be paid
 export const NAME_MAX_LENGTH_FEE = 31;
-export const NAME_BID_MAX_LENGTH = 12; // # this is the max length for a domain to be part of a bid
 // # https://github.com/aeternity/aeternity/blob/72e440b8731422e335f879a31ecbbee7ac23a1cf/apps/aecore/src/aec_governance.erl#L290
 // # https://github.com/aeternity/protocol/blob/master/AENS.md#protocol-fees-and-protection-times
 // # bid ranges:

package/src/tx/builder/field-types/coin-amount.ts

@@ -5,7 +5,8 @@ import { AE_AMOUNT_FORMATS, formatAmount } from '../../../utils/amount-formatter
 export default {
   ...uInt,
 
-  serializeAettos(value: string | undefined): string {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  serializeAettos(value: string | undefined, params: {}): string {
     return value ?? '0';
   },
 

package/src/tx/builder/field-types/entry.ts

@@ -29,7 +29,7 @@ export default function genEntryField<T extends Tag = Tag>(tag?: T): {
 
     deserialize(buf, { unpackTx }) {
       const tx = unpackTx(encode(buf, Encoding.Transaction));
-      if (tag != null && tx.tag !== tag) throw new ArgumentError('Tag', tag, tx.tag);
+      if (tag != null && tx.tag !== tag) throw new ArgumentError('Tag', Tag[tag], Tag[tx.tag]);
       return tx;
     },
   };

package/src/tx/builder/field-types/index.ts

@@ -1,61 +1,31 @@
-import _abiVersion from './abi-version';
-import _address from './address';
-import _array from './array';
-import _boolean from './boolean';
-import _coinAmount from './coin-amount';
-import _ctVersion from './ct-version';
-import _deposit from './deposit';
-import _encoded from './encoded';
-import _entry from './entry';
-import _enumeration from './enumeration';
-import _fee from './fee';
-import _field from './field';
-import _gasLimit from './gas-limit';
-import _gasPrice from './gas-price';
-import _map from './map';
-import _mptree from './mptree';
-import _name from './name';
-import _nameFee from './name-fee';
-import _nameId from './name-id';
-import _nonce from './nonce';
-import _pointers from './pointers';
-import _raw from './raw';
-import _shortUInt from './short-u-int';
-import _shortUIntConst from './short-u-int-const';
-import _string from './string';
-import _ttl from './ttl';
-import _uInt from './u-int';
-import _wrapped from './wrapped';
-
-// TODO: remove after fixing https://github.com/Gerrit0/typedoc-plugin-missing-exports/issues/15
-const abiVersion = _abiVersion;
-const address = _address;
-const array = _array;
-const boolean = _boolean;
-const coinAmount = _coinAmount;
-const ctVersion = _ctVersion;
-const deposit = _deposit;
-const encoded = _encoded;
-const entry = _entry;
-const enumeration = _enumeration;
-const fee = _fee;
-const field = _field;
-const gasLimit = _gasLimit;
-const gasPrice = _gasPrice;
-const map = _map;
-const mptree = _mptree;
-const name = _name;
-const nameFee = _nameFee;
-const nameId = _nameId;
-const nonce = _nonce;
-const pointers = _pointers;
-const raw = _raw;
-const shortUInt = _shortUInt;
-const shortUIntConst = _shortUIntConst;
-const string = _string;
-const ttl = _ttl;
-const uInt = _uInt;
-const wrapped = _wrapped;
+import abiVersion from './abi-version';
+import address from './address';
+import array from './array';
+import boolean from './boolean';
+import coinAmount from './coin-amount';
+import ctVersion from './ct-version';
+import deposit from './deposit';
+import encoded from './encoded';
+import entry from './entry';
+import enumeration from './enumeration';
+import fee from './fee';
+import field from './field';
+import gasLimit from './gas-limit';
+import gasPrice from './gas-price';
+import map from './map';
+import mptree from './mptree';
+import name from './name';
+import nameFee from './name-fee';
+import nameId from './name-id';
+import nonce from './nonce';
+import pointers from './pointers';
+import raw from './raw';
+import shortUInt from './short-u-int';
+import shortUIntConst from './short-u-int-const';
+import string from './string';
+import ttl from './ttl';
+import uInt from './u-int';
+import wrapped from './wrapped';
 
 export type BinaryData = Buffer | Buffer[] | Buffer[][]
 | Array<[Buffer, Array<[Buffer, Buffer[]]>]>;

package/src/tx/builder/field-types/u-int.ts

@@ -5,7 +5,7 @@ import { toBytes } from '../../../utils/bytes';
 
 export default {
   serialize(value: Int): Buffer {
-    if (value < 0) throw new ArgumentError('value', 'greater or equal to 0', value);
+    if (+value < 0) throw new ArgumentError('value', 'greater or equal to 0', value);
     return toBytes(value, true);
   },
 

package/src/tx/builder/helpers.ts

@@ -59,6 +59,39 @@ export function oracleQueryId(
   return encode(b2bHash, Encoding.OracleQueryId);
 }
 
+const AENS_SUFFIX = '.chain';
+
+export function nameToPunycode(maybeName: string): AensName {
+  const [name, suffix, ...other] = maybeName.split('.');
+  if (other.length !== 0) throw new ArgumentError('aens name', 'including only one dot', maybeName);
+  if (suffix !== AENS_SUFFIX.slice(1)) {
+    throw new ArgumentError('aens name', `suffixed with ${AENS_SUFFIX}`, maybeName);
+  }
+  if (/\p{Emoji_Presentation}/u.test(name)) {
+    throw new ArgumentError('aens name', 'not containing emoji', maybeName);
+  }
+  let punycode;
+  try {
+    const u = new URL(`http://${name}.${suffix}`);
+    if (u.username + u.password + u.port + u.search + u.hash !== '' || u.pathname !== '/') {
+      throw new ArgumentError('aens name', 'valid', maybeName);
+    }
+    punycode = u.host;
+  } catch (error) {
+    if (error instanceof TypeError && error.message.includes('Invalid URL')) {
+      throw new ArgumentError('aens name', 'valid', maybeName);
+    }
+    throw error;
+  }
+  if (!/^[a-z0-9.-]+$/i.test(punycode)) {
+    throw new ArgumentError('aens name', 'without illegal chars', maybeName);
+  }
+  if (punycode.length > 63 + AENS_SUFFIX.length) {
+    throw new ArgumentError('aens name', 'not too long', maybeName);
+  }
+  return punycode as AensName;
+}
+
 /**
  * Encode an AENS name
  * @category AENS
@@ -66,7 +99,7 @@ export function oracleQueryId(
  * @returns `nm_` prefixed encoded AENS name
  */
 export function produceNameId(name: AensName): Encoded.Name {
-  return encode(hash(name.toLowerCase()), Encoding.Name);
+  return encode(hash(nameToPunycode(name)), Encoding.Name);
 }
 
 /**
@@ -83,7 +116,7 @@ export function commitmentHash(
 ): Encoded.Commitment {
   return encode(
     hash(concatBuffers([
-      Buffer.from(name.toLowerCase()),
+      Buffer.from(nameToPunycode(name)),
       Buffer.from(salt.toString(16).padStart(64, '0'), 'hex'),
     ])),
     Encoding.Commitment,
@@ -100,16 +133,28 @@ export function readInt(buf: Buffer = Buffer.from([])): string {
   return new BigNumber(Buffer.from(buf).toString('hex'), 16).toString(10);
 }
 
-const AENS_SUFFIX = '.chain';
+/**
+ * Ensure that name is valid AENS name, would throw an exception otherwise
+ * @category AENS
+ * @param name - AENS name
+ */
+export function ensureName(maybeName: string): asserts maybeName is AensName {
+  nameToPunycode(maybeName);
+}
 
 /**
  * Is AENS name valid
  * @category AENS
  * @param name - AENS name
  */
-export function isNameValid(name: string): name is AensName {
-  // TODO: probably there are stronger requirements
-  return name.endsWith(AENS_SUFFIX);
+// TODO: consider renaming to isName
+export function isNameValid(maybeName: string): maybeName is AensName {
+  try {
+    ensureName(maybeName);
+    return true;
+  } catch (error) {
+    return false;
+  }
 }
 
 const encodingToPointerKey = [
@@ -145,7 +190,7 @@ export function getDefaultPointerKey(
  * @returns the minimum fee for the AENS name auction
  */
 export function getMinimumNameFee(name: AensName): BigNumber {
-  const nameLength = name.length - AENS_SUFFIX.length;
+  const nameLength = nameToPunycode(name).length - AENS_SUFFIX.length;
   return NAME_BID_RANGES[Math.min(nameLength, NAME_MAX_LENGTH_FEE)];
 }
 
@@ -181,7 +226,7 @@ export function computeBidFee(
  * @returns Auction end height
  */
 export function computeAuctionEndBlock(name: AensName, claimHeight: number): number {
-  const length = name.length - AENS_SUFFIX.length;
+  const length = nameToPunycode(name).length - AENS_SUFFIX.length;
   const h = (length <= 4 ? 62 * NAME_BID_TIMEOUT_BLOCKS : null)
     ?? (length <= 8 ? 31 * NAME_BID_TIMEOUT_BLOCKS : null)
     ?? (length <= 12 ? NAME_BID_TIMEOUT_BLOCKS : null)
@@ -194,5 +239,5 @@ export function computeAuctionEndBlock(name: AensName, claimHeight: number): num
  * @category AENS
  */
 export function isAuctionName(name: AensName): boolean {
-  return name.length < 13 + AENS_SUFFIX.length;
+  return nameToPunycode(name).length < 13 + AENS_SUFFIX.length;
 }

package/src/tx/builder/index.ts

@@ -23,6 +23,9 @@ export function getSchema(tag: Tag, version?: number): Array<[string, Field]> {
   return Object.entries(schema);
 }
 
+type TxEncoding = Encoding.Transaction | Encoding.Poi | Encoding.StateTrees
+| Encoding.CallStateTree;
+
 /**
  * Build transaction hash
  * @category transaction builder
@@ -31,15 +34,9 @@ export function getSchema(tag: Tag, version?: number): Array<[string, Field]> {
  * @param options.prefix - Prefix of transaction
  * @returns object Base64Check transaction hash with 'tx_' prefix
  */
-export function buildTx<
-  E extends Encoding = Encoding.Transaction,
->(
+export function buildTx<E extends TxEncoding = Encoding.Transaction>(
   params: TxParams,
-  {
-    prefix,
-  }: {
-    prefix?: E;
-  } = {},
+  { prefix }: { prefix?: E } = {},
 ): Encoded.Generic<E> {
   const schema = getSchema(params.tag, params.version);
 
@@ -92,7 +89,7 @@ export async function buildTxAsync(params: TxParamsAsync): Promise<Encoded.Trans
  * @returns Object with transaction param's
  */
 export function unpackTx<TxType extends Tag>(
-  encodedTx: Encoded.Transaction | Encoded.Poi | Encoded.StateTrees | Encoded.CallStateTree,
+  encodedTx: Encoded.Generic<TxEncoding>,
   txType?: TxType,
 ): TxUnpacked & { tag: TxType } {
   const binary = rlpDecode(decode(encodedTx));

package/src/tx/validator.ts

@@ -1,3 +1,4 @@
+import { RestError } from '@azure/core-rest-pipeline';
 import { hash, verify } from '../utils/crypto';
 import { TxUnpacked } from './builder/schema.generated';
 import { CtVersion, ProtocolToVmAbi } from './builder/field-types/ct-version';
@@ -143,6 +144,7 @@ validators.push(
     return [{ message, key: 'InvalidAccountType', checkedKeys: ['tag'] }];
   },
   // TODO: revert nonce check
+  // TODO: ensure nonce valid when paying for own tx
   (tx, { consensusProtocolVersion }) => {
     const oracleCall = Tag.Oracle === tx.tag || Tag.OracleRegisterTx === tx.tag;
     const contractCreate = Tag.ContractCreateTx === tx.tag || Tag.GaAttachTx === tx.tag;
@@ -183,9 +185,9 @@ validators.push(
         checkedKeys: ['contractId'],
       }];
     } catch (error) {
-      if (error.response?.parsedBody?.reason == null) throw error;
+      if (!(error instanceof RestError) || error.response?.bodyAsText == null) throw error;
       return [{
-        message: error.response.parsedBody.reason,
+        message: JSON.parse(error.response.bodyAsText).reason, // TODO: use parsedBody instead
         key: 'ContractNotFound',
         checkedKeys: ['contractId'],
       }];

package/src/utils/autorest.ts

@@ -2,7 +2,7 @@ import { RestError, PipelineResponse, PipelinePolicy } from '@azure/core-rest-pi
 import { AdditionalPolicyConfig } from '@azure/core-client';
 import { pause } from './other';
 import semverSatisfies from './semver-satisfies';
-import { UnexpectedTsError, UnsupportedVersionError } from './errors';
+import { UnsupportedVersionError } from './errors';
 
 export const genRequestQueuesPolicy = (): AdditionalPolicyConfig => {
   const requestQueues = new Map<string, Promise<unknown>>();
@@ -126,22 +126,17 @@ export const genRetryOnFailurePolicy = (
       const intervalSum = intervals.reduce((a, b) => a + b);
       const intervalsInMs = intervals.map((el) => (el / intervalSum) * retryOverallDelay);
 
-      let error: Error | undefined;
+      let error = new RestError('Not expected to be thrown');
       for (let attempt = 0; attempt <= retryCount; attempt += 1) {
-        if (error != null) {
-          if (
-            !(error instanceof RestError)
-            || statusesToNotRetry.includes(error.response?.status ?? 0)
-          ) throw error;
-          await pause(intervalsInMs[attempt - 1]);
-        }
+        if (attempt !== 0) await pause(intervalsInMs[attempt - 1]);
         try {
           return await next(request);
         } catch (e) {
+          if (!(e instanceof RestError)) throw e;
+          if (statusesToNotRetry.includes(e.response?.status ?? 0)) throw e;
           error = e;
         }
       }
-      if (error == null) throw new UnexpectedTsError();
       throw error;
     },
   },

package/src/utils/crypto.ts

@@ -8,6 +8,7 @@ import { concatBuffers } from './other';
 import {
   decode, encode, Encoded, Encoding,
 } from './encoder';
+import { ArgumentError } from './errors';
 
 /**
  * Generate address from secret key
@@ -32,6 +33,10 @@ export function isAddressValid(
 ): boolean {
   try {
     decode(address as Encoded.Generic<typeof prefix>);
+    const actualPrefix = address.split('_')[0];
+    if (actualPrefix !== prefix) {
+      throw new ArgumentError('Encoded string type', prefix, actualPrefix);
+    }
     return true;
   } catch (e) {
     return false;
@@ -152,10 +157,13 @@ export function verify(
   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 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]));
+  return hash(concatBuffers([messagePrefixLength, messagePrefix, varuintEncode(msg.length), msg]));
 }
 
 export function signMessage(message: string, privateKey: string | Buffer): Uint8Array {
@@ -169,6 +177,8 @@ export function signMessage(message: string, privateKey: string | Buffer): Uint8
  * @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,

package/src/utils/errors.ts

@@ -401,11 +401,11 @@ export class UnexpectedChannelMessageError extends ChannelError {
  * @category exception
  */
 export class ChannelIncomingMessageError extends ChannelError {
-  handlerError: BaseError;
+  handlerError: Error;
 
   incomingMessage: { [key: string]: any };
 
-  constructor(handlerError: BaseError, incomingMessage: { [key: string]: any }) {
+  constructor(handlerError: Error, incomingMessage: { [key: string]: any }) {
     super(handlerError.message);
     this.handlerError = handlerError;
     this.incomingMessage = incomingMessage;

package/src/utils/other.ts

@@ -57,3 +57,8 @@ export function isAccountNotFoundError(error: Error): boolean {
 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;
+}