@aeternity/aepp-sdk 13.0.1 → 13.1.0

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/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/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;
+}

package/src/utils/typed-data.ts

@@ -0,0 +1,95 @@
+// js extension is required for mjs build
+// @ts-expect-error see https://github.com/aeternity/aepp-calldata-js/issues/216
+// eslint-disable-next-line import/extensions
+import ContractByteArrayEncoder from '@aeternity/aepp-calldata/src/ContractByteArrayEncoder.js';
+// @ts-expect-error see https://github.com/aeternity/aepp-calldata-js/issues/216
+// eslint-disable-next-line import/extensions
+import AciTypeResolver from '@aeternity/aepp-calldata/src/AciTypeResolver.js';
+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;
+}
+
+// TODO: replace with api on calldata side https://github.com/aeternity/aepp-calldata-js/issues/216
+export function encodeFateValue(
+  value: unknown,
+  aci: AciValue,
+): Encoded.ContractBytearray {
+  const contractByteArrayEncoder = new ContractByteArrayEncoder();
+  const aciTypeResolver = new AciTypeResolver([]);
+  aciTypeResolver.isCustomType = () => false;
+  return contractByteArrayEncoder.encode(aciTypeResolver.resolveType(aci), value);
+}
+
+// TODO: replace with api on calldata side https://github.com/aeternity/aepp-calldata-js/issues/216
+export function decodeFateValue(
+  value: Encoded.ContractBytearray,
+  aci: AciValue,
+): Encoded.ContractBytearray {
+  const contractByteArrayEncoder = new ContractByteArrayEncoder();
+  const aciTypeResolver = new AciTypeResolver([]);
+  aciTypeResolver.isCustomType = () => false;
+  return contractByteArrayEncoder.decodeWithType(value, aciTypeResolver.resolveType(aci));
+}
+
+/**
+ * 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;
+  return hash(decode(encodeFateValue(domain, domainAci)));
+}
+
+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)),
+  ]));
+}

package/types-legacy/ts4.2/AeSdkBase.d.ts

@@ -2,7 +2,7 @@ import Node from './Node';
 import AccountBase from './account/Base';
 import { Encoded } from './utils/encoder';
 import CompilerBase from './contract/compiler/Base';
-import AeSdkMethods, { OnAccount } from './AeSdkMethods';
+import AeSdkMethods, { OnAccount, AeSdkMethodsOptions } from './AeSdkMethods';
 type NodeInfo = Awaited<ReturnType<Node['getNodeInfo']>> & {
     name: string;
 };
@@ -19,7 +19,7 @@ export default class AeSdkBase extends AeSdkMethods {
      * @param options - Options
      * @param options.nodes - Array of nodes
      */
-    constructor({ nodes, ...options }?: ConstructorParameters<typeof AeSdkMethods>[0] & {
+    constructor({ nodes, ...options }?: AeSdkMethodsOptions & {
         nodes?: Array<{
             name: string;
             instance: Node;
@@ -72,6 +72,11 @@ export default class AeSdkBase extends AeSdkMethods {
      */
     getNodesInPool(): Promise<NodeInfo[]>;
     addresses(): Encoded.AccountAddress[];
+    /**
+     * Resolves an account
+     * @param account - ak-address, instance of AccountBase, or keypair
+     */
+    _resolveAccount(account?: OnAccount): AccountBase;
     get address(): Encoded.AccountAddress;
     sign(data: string | Uint8Array, { onAccount, ...options }?: {
         onAccount?: OnAccount;
@@ -82,7 +87,10 @@ export default class AeSdkBase extends AeSdkMethods {
     signMessage(message: string, { onAccount, ...options }?: {
         onAccount?: OnAccount;
     } & Parameters<AccountBase['signMessage']>[1]): Promise<Uint8Array>;
-    _getOptions(): {
+    signTypedData(data: Encoded.ContractBytearray, aci: Parameters<AccountBase['signTypedData']>[1], { onAccount, ...options }?: {
+        onAccount?: OnAccount;
+    } & Parameters<AccountBase['signTypedData']>[2]): Promise<Encoded.Signature>;
+    _getOptions(callOptions?: AeSdkMethodsOptions): {
         onNode: Node;
         onAccount: AccountBase;
         onCompiler: CompilerBase;

package/types-legacy/ts4.2/AeSdkMethods.d.ts

@@ -10,8 +10,9 @@ import Node from './Node';
 import { TxParamsAsync } from './tx/builder/schema.generated';
 import AccountBase from './account/Base';
 import { Encoded } from './utils/encoder';
+import CompilerBase from './contract/compiler/Base';
 export type OnAccount = Encoded.AccountAddress | AccountBase | undefined;
-export declare function getValueOrErrorProxy<Value extends object>(valueCb: () => Value): Value;
+export declare function getValueOrErrorProxy<Value extends object | undefined>(valueCb: () => Value): NonNullable<Value>;
 declare const methods: {
     readonly createGeneralizedAccount: typeof contractGaMethods.createGeneralizedAccount;
     readonly buildAuthTxHash: typeof contractGaMethods.buildAuthTxHash;
@@ -69,11 +70,7 @@ type GetMethodsOptions<Methods extends {
     [Name in keyof Methods]: Methods[Name] extends (...args: infer Args) => any ? Args[Decrement<Args['length']>] : never;
 };
 type MethodsOptions = GetMethodsOptions<typeof methods>;
-interface AeSdkMethodsOptions extends Partial<UnionToIntersection<MethodsOptions[keyof MethodsOptions]>> {
-    nodes?: Array<{
-        name: string;
-        instance: Node;
-    }>;
+export interface AeSdkMethodsOptions extends Partial<UnionToIntersection<MethodsOptions[keyof MethodsOptions]>> {
 }
 /**
  * AeSdkMethods is the composition of:
@@ -94,13 +91,10 @@ declare class AeSdkMethods {
      * @param options - Options
      */
     constructor(options?: AeSdkMethodsOptions);
-    /**
-     * Resolves an account
-     * @param account - ak-address, instance of AccountBase, or keypair
-     */
-    _resolveAccount(account?: OnAccount): AccountBase;
-    _getOptions(): AeSdkMethodsOptions & {
+    _getOptions(callOptions?: AeSdkMethodsOptions): AeSdkMethodsOptions & {
         onAccount: AccountBase;
+        onCompiler: CompilerBase;
+        onNode: Node;
     };
     buildTx(options: TxParamsAsync): Promise<Encoded.Transaction>;
     initializeContract<Methods extends ContractMethodsBase>(options?: Omit<Parameters<typeof Contract.initialize>[0], 'onNode'> & {
@@ -135,5 +129,6 @@ type TransformMethods<Methods extends {
 };
 interface AeSdkMethodsTransformed extends TransformMethods<typeof methods> {
 }
-declare const _default: new (options?: ConstructorParameters<typeof AeSdkMethods>[0]) => AeSdkMethods & AeSdkMethodsTransformed;
-export default _default;
+type AeSdkMethodsTyped = AeSdkMethods & AeSdkMethodsTransformed;
+declare const AeSdkMethodsTyped: new (options?: AeSdkMethodsOptions) => AeSdkMethodsTyped;
+export default AeSdkMethodsTyped;