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

package/src/tx/index.ts

@@ -22,115 +22,37 @@
  * the creation of transactions to {@link Node}.
  * These methods provide ability to create native transactions.
  */
-import BigNumber from 'bignumber.js';
-import {
-  ABI_VERSIONS, CtVersion, PROTOCOL_VM_ABI, TX_TTL, TxParamsCommon,
-} from './builder/schema';
-import { Tag } from './builder/constants';
-import {
-  ArgumentError, UnsupportedProtocolError, UnknownTxError, InvalidTxParamsError,
-} from '../utils/errors';
+import { TX_TTL, TxParamsCommon } from './builder/schema';
+import { ConsensusProtocolVersion, Tag } from './builder/constants';
+import { ArgumentError, InvalidTxParamsError } from '../utils/errors';
 import Node from '../Node';
 import { Encoded } from '../utils/encoder';
 import { buildTx as syncBuildTx, unpackTx } from './builder/index';
-import { isAccountNotFoundError, isKeyOfObject } from '../utils/other';
+import { isAccountNotFoundError } from '../utils/other';
 import { AE_AMOUNT_FORMATS } from '../utils/amount-formatter';
 
-type Int = number | string | BigNumber;
-
 export type BuildTxOptions <TxType extends Tag, OmitFields extends string> =
   Omit<Parameters<typeof _buildTx<TxType>>[1], OmitFields>;
 
-/**
- * Validated vm/abi version or get default based on transaction type and NODE version
- * @category transaction builder
- * @param txType - Type of transaction
- * @param ctVersion - Object with vm and abi version fields
- * @returns Object with vm/abi version
- */
-async function getVmVersion(
-  txType: Tag.ContractCreateTx, ctVersion: Partial<CtVersion> & { onNode: Node }
-): Promise<CtVersion>;
-async function getVmVersion(
-  txType: Tag, ctVersion: Partial<Pick<CtVersion, 'abiVersion'>> & { onNode: Node }
-): Promise<Pick<CtVersion, 'abiVersion'>>;
-async function getVmVersion(
-  txType: Tag,
-  { vmVersion, abiVersion, onNode }: Partial<CtVersion> & { onNode: Node },
-): Promise<Partial<CtVersion>> {
-  const { consensusProtocolVersion } = await onNode.getNodeInfo();
-  if (!isKeyOfObject(consensusProtocolVersion, PROTOCOL_VM_ABI)) {
-    throw new UnsupportedProtocolError('Not supported consensus protocol version');
-  }
-  const supportedProtocol = PROTOCOL_VM_ABI[consensusProtocolVersion];
-  if (!isKeyOfObject(txType, supportedProtocol)) {
-    throw new UnknownTxError('Not supported tx type');
-  }
-  const protocolForTX = supportedProtocol[txType];
-  abiVersion ??= protocolForTX.abiVersion[0];
-  vmVersion ??= protocolForTX.vmVersion[0];
-  return { vmVersion, abiVersion };
-}
-
-/**
- * Calculate fee, get absolute ttl (ttl + height), get account nonce
- * @category transaction builder
- * @param txType - Type of transaction
- * @param params - Object which contains all tx data
- * @returns Object with account nonce, absolute ttl and transaction fee
- */
-async function prepareTxParams(
-  txType: Tag,
-  {
-    senderId,
-    nonce,
-    ttl = TX_TTL,
-    absoluteTtl,
-    strategy,
-    onNode,
-  }: {
-    senderId: Encoded.AccountAddress;
-    absoluteTtl?: boolean;
-    strategy?: 'continuity' | 'max';
-    onNode: Node;
-  } & Pick<TxParamsCommon, 'nonce' | 'ttl'>,
-): Promise<{ ttl: number; nonce: number }> {
-  nonce ??= (
-    await onNode.getAccountNextNonce(senderId, { strategy }).catch((error) => {
-      if (!isAccountNotFoundError(error)) throw error;
-      return { nextNonce: 1 };
-    })
-  ).nextNonce;
-
-  if (ttl !== 0) {
-    if (ttl < 0) throw new ArgumentError('ttl', 'greater or equal to 0', ttl);
-    ttl += absoluteTtl === true ? 0 : (await onNode.getCurrentKeyBlock()).height;
-  }
-
-  return { ttl, nonce };
-}
-
 // TODO: find a better name or rearrange methods
 /**
  * @category transaction builder
  */
 export async function _buildTx<TxType extends Tag>(
   txType: TxType,
-  { denomination, absoluteTtl, ..._params }:
-  Omit<Parameters<typeof syncBuildTx<TxType, 'tx'>>[0], 'fee' | 'nonce' | 'ttl' | 'ctVersion' | 'abiVersion'>
+  {
+    denomination, absoluteTtl, strategy, onNode, ..._params
+  }: Omit<Parameters<typeof syncBuildTx<TxType>>[0], 'tag' | 'nonce' | 'ttl'>
   & {
-    onNode: Node;
-    fee?: Int;
-    nonce?: number;
-    ttl?: number;
     denomination?: AE_AMOUNT_FORMATS;
     absoluteTtl?: boolean;
+    strategy?: 'continuity' | 'max';
+    onNode: Node;
+    ttl?: number;
+    nonce?: number;
   }
   & (TxType extends Tag.OracleExtendTx | Tag.OracleResponseTx
-    ? { callerId: Encoded.AccountAddress } : {})
-  & (TxType extends Tag.ContractCreateTx | Tag.GaAttachTx ? { ctVersion?: CtVersion } : {})
-  & (TxType extends Tag.ContractCallTx | Tag.OracleRegisterTx
-    ? { abiVersion?: ABI_VERSIONS } : {}),
+    ? { callerId: Encoded.AccountAddress } : {}),
 ): Promise<Encoded.Transaction> {
   // TODO: avoid this assertion
   const params = _params as unknown as TxParamsCommon & { onNode: Node };
@@ -172,25 +94,36 @@ export async function _buildTx<TxType extends Tag>(
     default:
       throw new ArgumentError('txType', 'valid transaction type', txType);
   }
-  // TODO: move specific cases to field-types
-  if ([Tag.ContractCreateTx, Tag.GaAttachTx].includes(txType)) {
-    params.ctVersion = await getVmVersion(
-      Tag.ContractCreateTx,
-      { ...params, ...params.ctVersion },
-    );
-  }
-  if ([Tag.ContractCallTx, Tag.GaMetaTx].includes(txType)) {
-    params.abiVersion = (await getVmVersion(Tag.ContractCallTx, params)).abiVersion;
-  }
-  if (txType === Tag.OracleRegisterTx) {
-    params.abiVersion ??= ABI_VERSIONS.NO_ABI;
+
+  if (
+    Object.keys(ConsensusProtocolVersion).length !== 2
+    && (((Tag.ContractCreateTx === txType || Tag.GaAttachTx === txType) && params.ctVersion == null)
+    || ((Tag.ContractCallTx === txType || Tag.GaMetaTx === txType) && params.abiVersion == null))
+  ) {
+    const { consensusProtocolVersion } = await onNode.getNodeInfo();
+    // @ts-expect-error remove after fixing buildTx types
+    params.consensusProtocolVersion = consensusProtocolVersion;
   }
+
   if (txType === Tag.PayingForTx) {
     params.tx = unpackTx(params.tx);
   }
   const senderId = params[senderKey];
   // TODO: do this check on TypeScript level
   if (senderId == null) throw new InvalidTxParamsError(`Transaction field ${senderKey} is missed`);
-  const extraParams = await prepareTxParams(txType, { ...params, senderId, absoluteTtl });
-  return syncBuildTx({ ...params, ...extraParams } as any, txType, { denomination }).tx;
+
+  params.nonce ??= (
+    await onNode.getAccountNextNonce(senderId, { strategy }).catch((error) => {
+      if (!isAccountNotFoundError(error)) throw error;
+      return { nextNonce: 1 };
+    })
+  ).nextNonce;
+
+  params.ttl ??= TX_TTL;
+  if (params.ttl !== 0) {
+    if (params.ttl < 0) throw new ArgumentError('ttl', 'greater or equal to 0', params.ttl);
+    params.ttl += absoluteTtl === true ? 0 : (await onNode.getCurrentKeyBlock()).height;
+  }
+
+  return syncBuildTx({ ...params, tag: txType } as any, { denomination });
 }

package/src/tx/validator.ts

@@ -1,18 +1,11 @@
 import BigNumber from 'bignumber.js';
 import { hash, verify } from '../utils/crypto';
-import {
-  CtVersion,
-  PROTOCOL_VM_ABI,
-  RawTxObject,
-  TxParamsCommon,
-  TxSchema,
-  TxTypeSchemas,
-} from './builder/schema';
-import { Tag } from './builder/constants';
-import { TxUnpacked, unpackTx } from './builder';
-import { UnsupportedProtocolError } from '../utils/errors';
-import { concatBuffers, isAccountNotFoundError, isKeyOfObject } from '../utils/other';
-import { encode, Encoded, Encoding } from '../utils/encoder';
+import { RawTxObject, TxParamsCommon, TxSchema } from './builder/schema';
+import { ProtocolToVmAbi } from './builder/field-types/ct-version';
+import { Tag, ConsensusProtocolVersion } from './builder/constants';
+import { buildTx, unpackTx } from './builder';
+import { concatBuffers, isAccountNotFoundError } from '../utils/other';
+import { Encoded, decode } from '../utils/encoder';
 import Node, { TransformNodeType } from '../Node';
 import { Account } from '../apis/node';
 import { genAggressiveCacheGetResponsesPolicy } from '../utils/autorest';
@@ -23,31 +16,18 @@ export interface ValidatorResult {
   checkedKeys: string[];
 }
 
+type UnpackedTx = ReturnType<typeof unpackTx>['tx'];
+
 type Validator = (
-  tx: {
-    encodedTx: TxUnpacked<TxSchema>;
-    signatures: Buffer[];
-    tx: TxUnpacked<TxSchema> & {
-      tx: TxTypeSchemas[Tag.SignedTx];
-    };
-    nonce?: number;
-    ttl?: number;
-    amount?: number;
-    fee?: number;
-    nameFee?: number;
-    ctVersion?: Partial<CtVersion>;
-    abiVersion?: number;
-    contractId?: Encoded.ContractAddress;
-  },
+  tx: UnpackedTx,
   options: {
     // TODO: remove after fixing node types
     account?: TransformNodeType<Account> & { id: Encoded.AccountAddress };
     nodeNetworkId: string;
     parentTxTypes: Tag[];
     node: Node;
-    txType: Tag;
     height: number;
-    consensusProtocolVersion: number;
+    consensusProtocolVersion: ConsensusProtocolVersion;
   }
 ) => ValidatorResult[] | Promise<ValidatorResult[]>;
 
@@ -63,34 +43,13 @@ const getSenderAddress = (
   .filter((a) => a)
   .map((a) => a?.toString().replace(/^ok_/, 'ak_'))[0] as Encoded.AccountAddress | undefined;
 
-/**
- * Transaction Validator
- * This function validates some of transaction properties,
- * to make sure it can be posted it to the chain
- * @category transaction builder
- * @param transaction - Base64Check-encoded transaction
- * @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,
-  nodeNotCached: Node,
-  parentTxTypes: Tag[] = [],
+async function verifyTransactionInternal(
+  tx: UnpackedTx,
+  node: 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);
+    ?? (tx.tag === Tag.SignedTx ? getSenderAddress(tx.encodedTx) : undefined);
   const [account, { height }, { consensusProtocolVersion, nodeNetworkId }] = await Promise.all([
     address == null
       ? undefined
@@ -107,25 +66,45 @@ export default async function verifyTransaction(
 
   return (await Promise.all(
     validators.map((v) => v(
-      tx as any,
+      tx,
       {
-        txType, node, account, height, consensusProtocolVersion, nodeNetworkId, parentTxTypes,
+        node, account, height, consensusProtocolVersion, nodeNetworkId, parentTxTypes,
       },
     )),
   )).flat();
 }
 
+/**
+ * Transaction Validator
+ * This function validates some transaction properties,
+ * to make sure it can be posted it to the chain
+ * @category transaction builder
+ * @param transaction - Base64Check-encoded transaction
+ * @param nodeNotCached - Node to validate transaction against
+ * @returns Array with verification errors
+ * @example const errors = await verifyTransaction(transaction, node)
+ */
+export default async function verifyTransaction(
+  transaction: Parameters<typeof unpackTx>[0],
+  nodeNotCached: Node,
+): Promise<ValidatorResult[]> {
+  const node = new Node(nodeNotCached.$host, { ignoreVersion: true });
+  node.pipeline.addPolicy(genAggressiveCacheGetResponsesPolicy());
+  return verifyTransactionInternal(unpackTx(transaction), node, []);
+}
+
 validators.push(
   ({ encodedTx, signatures }, { account, nodeNetworkId, parentTxTypes }) => {
-    if ((encodedTx ?? signatures) === undefined) return [];
+    if ((encodedTx ?? signatures) == null) return [];
     if (account == null) return [];
-    if (signatures.length !== 1) return []; // TODO: Support multisignature?
+    if (signatures.length !== 1) return []; // TODO: Support multisignature like in state channels
     const prefix = Buffer.from([
       nodeNetworkId,
       ...parentTxTypes.includes(Tag.PayingForTx) ? ['inner_tx'] : [],
     ].join('-'));
-    const txWithNetworkId = concatBuffers([prefix, encodedTx.rlpEncoded]);
-    const txHashWithNetworkId = concatBuffers([prefix, hash(encodedTx.rlpEncoded)]);
+    const txBinary = decode(buildTx(encodedTx));
+    const txWithNetworkId = concatBuffers([prefix, txBinary]);
+    const txHashWithNetworkId = concatBuffers([prefix, hash(txBinary)]);
     if (verify(txWithNetworkId, signatures[0], account.id)
       || verify(txHashWithNetworkId, signatures[0], account.id)) return [];
     return [{
@@ -135,16 +114,12 @@ validators.push(
       checkedKeys: ['encodedTx', 'signatures'],
     }];
   },
-  async ({ encodedTx, tx }, { node, parentTxTypes, txType }) => {
-    if ((encodedTx ?? tx) === undefined) return [];
-    return verifyTransaction(
-      encode((encodedTx ?? tx).rlpEncoded, Encoding.Transaction),
-      node,
-      [...parentTxTypes, txType],
-    );
+  async ({ encodedTx, tx, tag }, { node, parentTxTypes }) => {
+    if ((encodedTx ?? tx) == null) return [];
+    return verifyTransactionInternal(encodedTx ?? tx, node, [...parentTxTypes, tag]);
   },
   ({ ttl }, { height }) => {
-    if (ttl === undefined) return [];
+    if (ttl == null) return [];
     ttl = +ttl;
     if (ttl === 0 || ttl >= height) return [];
     return [{
@@ -154,13 +129,13 @@ validators.push(
     }];
   },
   ({
-    amount, fee, nameFee, tx,
-  }, { account, parentTxTypes, txType }) => {
+    amount, fee, nameFee, tx, tag,
+  }, { account, parentTxTypes }) => {
     if (account == null) return [];
-    if ((amount ?? fee ?? nameFee) === undefined) return [];
+    if ((amount ?? fee ?? nameFee) == null) return [];
     fee ??= 0;
     const cost = new BigNumber(fee).plus(nameFee ?? 0).plus(amount ?? 0)
-      .plus(txType === Tag.PayingForTx ? (tx.tx.encodedTx.tx).fee : 0)
+      .plus(tag === Tag.PayingForTx ? tx.encodedTx.fee : 0)
       .minus(parentTxTypes.includes(Tag.PayingForTx) ? fee : 0);
     if (cost.lte(account.balance.toString())) return [];
     return [{
@@ -169,13 +144,13 @@ validators.push(
       checkedKeys: ['amount', 'fee', 'nameFee'],
     }];
   },
-  ({ signatures }, { account, txType }) => {
+  ({ signatures, tag }, { account }) => {
     if (account == null) return [];
     let message;
-    if (txType === Tag.SignedTx && account.kind === 'generalized' && signatures.length !== 0) {
+    if (tag === 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') {
+    if (tag === Tag.GaMetaTx && account.kind === 'basic') {
       message = 'Basic account can\'t be used to generate GaMetaTx';
     }
     if (message == null) return [];
@@ -199,34 +174,36 @@ validators.push(
       checkedKeys: ['nonce'],
     }];
   },
-  ({ ctVersion, abiVersion }, { txType, consensusProtocolVersion }) => {
-    if (!isKeyOfObject(consensusProtocolVersion, PROTOCOL_VM_ABI)) {
-      throw new UnsupportedProtocolError(`Unsupported protocol: ${consensusProtocolVersion}`);
-    }
-    const protocol = PROTOCOL_VM_ABI[consensusProtocolVersion];
+  ({ ctVersion, abiVersion, tag }, { consensusProtocolVersion }) => {
+    const oracleCall = Tag.Oracle === tag || Tag.OracleRegisterTx === tag;
+    const contractCreate = Tag.ContractCreateTx === tag || Tag.GaAttachTx === tag;
+    const contractCall = Tag.ContractCallTx === tag || Tag.GaMetaTx === tag;
+    const type = (oracleCall ? 'oracle-call' : null)
+      ?? (contractCreate ? 'contract-create' : null)
+      ?? (contractCall ? 'contract-call' : null);
+    if (type == null) return [];
+    // TODO: remove assertion after fixing buildTx types
+    const protocol = ProtocolToVmAbi[consensusProtocolVersion][type] as unknown as {
+      abiVersion: any[];
+      vmVersion: any[];
+    };
 
     // If not contract create tx
     if (ctVersion == null) ctVersion = { abiVersion };
-    const txProtocol = protocol[txType as keyof typeof protocol];
-    if (txProtocol == null) return [];
-    if (Object.entries(ctVersion).some(
-      ([
-        key,
-        value,
-      ]: [
-        key:keyof typeof txProtocol,
-        value:any]) => !(txProtocol[key].includes(+value as never)),
-    )) {
+    if (
+      !protocol.abiVersion.includes(ctVersion.abiVersion)
+      || (contractCreate && !protocol.vmVersion.includes(ctVersion.vmVersion))
+    ) {
       return [{
-        message: `ABI/VM version ${JSON.stringify(ctVersion)} is wrong, supported is: ${JSON.stringify(txProtocol)}`,
+        message: `ABI/VM version ${JSON.stringify(ctVersion)} is wrong, supported is: ${JSON.stringify(protocol)}`,
         key: 'VmAndAbiVersionMismatch',
         checkedKeys: ['ctVersion', 'abiVersion'],
       }];
     }
     return [];
   },
-  async ({ contractId }, { txType, node }) => {
-    if (Tag.ContractCallTx !== txType) return [];
+  async ({ contractId, tag }, { node }) => {
+    if (Tag.ContractCallTx !== tag) return [];
     contractId = contractId as Encoded.ContractAddress;
     try {
       const { active } = await node.getContract(contractId);

package/src/utils/bytes.ts

@@ -29,7 +29,7 @@ export function toBytes(val?: null | string | number | BigNumber, big = false):
   // If the value is an int it will be encoded as bytes big endian
   // Raises ValueError if the input is not an int or string
 
-  if (val === undefined || val === null) return Buffer.from([]);
+  if (val == null) return Buffer.from([]);
   if (Number.isInteger(val) || BigNumber.isBigNumber(val) || big) {
     if (!BigNumber.isBigNumber(val)) val = new BigNumber(val);
     if (!val.isInteger()) throw new TypeError(`Unexpected not integer value: ${val.toFixed()}`);

package/src/utils/errors.ts

@@ -1,5 +1,6 @@
 // eslint-disable-next-line max-classes-per-file
 import BigNumber from 'bignumber.js';
+import { Int } from '../tx/builder/constants';
 
 /**
  * aepp-sdk originated error
@@ -116,8 +117,8 @@ export class WalletError extends BaseError {
  * @category exception
  */
 export class ArgumentError extends BaseError {
-  constructor(argumentName: string, requirement: string, argumentValue: any) {
-    super(`${argumentName} should be ${requirement}, got ${String(argumentValue)} instead`);
+  constructor(argumentName: string, requirement: unknown, argumentValue: unknown) {
+    super(`${argumentName} should be ${requirement}, got ${argumentValue} instead`);
     this.name = 'ArgumentError';
   }
 }
@@ -528,7 +529,7 @@ export class NoSuchContractFunctionError extends ContractError {
  * @category exception
  */
 export class NotPayableFunctionError extends ContractError {
-  constructor(amount: string, fn: string) {
+  constructor(amount: Int, fn: string) {
     super(
       `You try to pay "${amount}" to function "${fn}" which is not payable. `
       + 'Only payable function can accept coins',
@@ -744,16 +745,6 @@ export class TxNotInChainError extends TransactionError {
   }
 }
 
-/**
- * @category exception
- */
-export class UnknownTxError extends TransactionError {
-  constructor(message: string) {
-    super(message);
-    this.name = 'UnknownTxError';
-  }
-}
-
 /**
  * @category exception
  */

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

@@ -1,7 +1,7 @@
 import Node from './Node';
 import AccountBase from './account/Base';
 import { Encoded } from './utils/encoder';
-import CompilerHttp from './contract/CompilerHttp';
+import CompilerBase from './contract/compiler/Base';
 import AeSdkMethods, { OnAccount } from './AeSdkMethods';
 type NodeInfo = Awaited<ReturnType<Node['getNodeInfo']>> & {
     name: string;
@@ -25,7 +25,7 @@ export default class AeSdkBase extends AeSdkMethods {
             instance: Node;
         }>;
     });
-    get compilerApi(): CompilerHttp;
+    get compilerApi(): CompilerBase;
     get api(): Node;
     /**
      * Add Node
@@ -85,7 +85,7 @@ export default class AeSdkBase extends AeSdkMethods {
     _getOptions(): {
         onNode: Node;
         onAccount: AccountBase;
-        onCompiler: CompilerHttp;
+        onCompiler: CompilerBase;
     };
 }
 export {};

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

@@ -10,7 +10,7 @@ import Node from './Node';
 import { Tag } from './tx/builder/constants';
 import AccountBase from './account/Base';
 import { Encoded } from './utils/encoder';
-import CompilerHttp from './contract/CompilerHttp';
+import CompilerBase from './contract/compiler/Base';
 export type OnAccount = Encoded.AccountAddress | AccountBase | undefined;
 export declare function getValueOrErrorProxy<Value extends object>(valueCb: () => Value): Value;
 declare const methods: {
@@ -105,9 +105,8 @@ declare class AeSdkMethods {
     buildTx<TxType extends Tag>(txType: TxType, options: Omit<Parameters<any>[1], 'onNode'> & {
         onNode?: Node;
     }): Promise<Encoded.Transaction>;
-    initializeContract<Methods extends ContractMethodsBase>(options?: Omit<Parameters<typeof Contract.initialize>[0], 'onNode' | 'onCompiler'> & {
+    initializeContract<Methods extends ContractMethodsBase>(options?: Omit<Parameters<typeof Contract.initialize>[0], 'onNode'> & {
         onNode?: Node;
-        onCompiler?: CompilerHttp;
     }): Promise<Contract<Methods>>;
 }
 type RequiredKeys<T> = {
@@ -120,7 +119,7 @@ type OptionalIfNotRequired<T extends [
 type MakeOptional<Options> = OptionalIfNotRequired<[
     Omit<Options, 'onNode' | 'onCompiler' | 'onAccount'> & {
         onNode?: Node;
-        onCompiler?: CompilerHttp;
+        onCompiler?: CompilerBase;
         onAccount?: OnAccount;
     }
 ]>;

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

@@ -1,5 +1,6 @@
 import { Node as NodeApi, NodeOptionalParams } from './apis/node';
 import { Encoded } from './utils/encoder';
+import { ConsensusProtocolVersion } from './tx/builder/constants';
 declare const bigIntPropertyNames: readonly [
     "balance",
     "queryFee",
@@ -24,7 +25,6 @@ declare const numberPropertyNames: readonly [
     "nextNonce",
     "height",
     "blockHeight",
-    "top",
     "topBlockHeight",
     "ttl",
     "nameTtl",
@@ -50,7 +50,7 @@ export type TransformNodeType<Type> = Type extends (...args: infer Args) => infe
 ] : Type extends Array<infer Item> ? Array<TransformNodeType<Item>> : Type extends Promise<infer T> ? Promise<TransformNodeType<T>> : Type extends {
     [P in any]: any;
 } ? {
-    [Property in keyof Type]: Property extends BigIntPropertyNames ? PreserveOptional<bigint, Type[Property]> : Property extends NumberPropertyNames ? PreserveOptional<number, Type[Property]> : Property extends 'txHash' ? PreserveOptional<Encoded.TxHash, Type[Property]> : TransformNodeType<Type[Property]>;
+    [Property in keyof Type]: Property extends BigIntPropertyNames ? PreserveOptional<bigint, Type[Property]> : Property extends NumberPropertyNames ? PreserveOptional<number, Type[Property]> : Property extends 'txHash' ? PreserveOptional<Encoded.TxHash, Type[Property]> : Property extends 'bytecode' ? PreserveOptional<Encoded.ContractBytearray, Type[Property]> : TransformNodeType<Type[Property]>;
 } : Type;
 type NodeTransformedApi = new (...args: ConstructorParameters<typeof NodeApi>) => {
     [Name in keyof InstanceType<typeof NodeApi>]: Name extends 'pipeline' | 'sendRequest' | 'sendOperationRequest' ? NodeApi[Name] : TransformNodeType<NodeApi[Name]>;
@@ -59,7 +59,7 @@ export interface NodeInfo {
     url: string;
     nodeNetworkId: string;
     version: string;
-    consensusProtocolVersion: number;
+    consensusProtocolVersion: ConsensusProtocolVersion;
 }
 declare const Node_base: NodeTransformedApi;
 export default class Node extends Node_base {

package/types-legacy/ts4.2/account/Base.d.ts

@@ -1,6 +1,6 @@
 import { Encoded } from '../utils/encoder';
 import Node from '../Node';
-import CompilerHttp from '../contract/CompilerHttp';
+import CompilerBase from '../contract/compiler/Base';
 /**
  * Account is one of the three basic building blocks of an
  * {@link AeSdk} and provides access to a signing key pair.
@@ -24,7 +24,7 @@ export default abstract class AccountBase {
             args?: any[];
         };
         onNode?: Node;
-        onCompiler?: CompilerHttp;
+        onCompiler?: CompilerBase;
         aeppOrigin?: string;
         aeppRpcClientId?: string;
     }): Promise<Encoded.Transaction>;

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

@@ -196,7 +196,7 @@ export declare function aensPreclaim(name: AensName, options: AensPreclaimOption
     commitmentId: string;
     claim: (opts?: Parameters<typeof aensClaim>[2]) => ReturnType<typeof aensClaim>;
 }>>;
-interface AensPreclaimOptions extends BuildTxOptions<Tag.NamePreclaimTx, 'accountId' | 'commitmentId'>, SendOptions, AensClaimOptions {
+interface AensPreclaimOptions extends BuildTxOptions<Tag.NamePreclaimTx, 'accountId' | 'commitmentId'>, SendOptions, Omit<AensClaimOptions, 'version'> {
 }
 /**
  * Bid to name auction

package/types-legacy/ts4.2/aepp-wallet-communication/connection/BrowserRuntime.d.ts

@@ -6,6 +6,7 @@ import BrowserConnection from './Browser';
  * @category aepp wallet communication
  */
 export default class BrowserRuntimeConnection extends BrowserConnection {
+    #private;
     port: Runtime.Port;
     constructor({ port, ...options }: {
         port: Runtime.Port;

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

@@ -179,6 +179,14 @@ export declare function getKeyBlock(hashOrHeight: Encoded.KeyBlockHash | number,
 export declare function getMicroBlockHeader(hash: Encoded.MicroBlockHash, { onNode }: {
     onNode: Node;
 }): Promise<TransformNodeType<MicroBlockHeader>>;
+interface TxDryRunArguments {
+    tx: Encoded.Transaction;
+    accountAddress: Encoded.AccountAddress;
+    top?: number | Encoded.KeyBlockHash | Encoded.MicroBlockHash;
+    txEvents?: any;
+    resolve: Function;
+    reject: Function;
+}
 /**
  * Transaction dry-run
  * @category chain
@@ -191,7 +199,7 @@ export declare function getMicroBlockHeader(hash: Encoded.MicroBlockHash, { onNo
  * @param options.onNode - Node to use
  */
 export declare function txDryRun(tx: Encoded.Transaction, accountAddress: Encoded.AccountAddress, { top, txEvents, combine, onNode, }: {
-    top?: number;
+    top?: TxDryRunArguments['top'];
     txEvents?: boolean;
     combine?: boolean;
     onNode: Node;

package/types-legacy/ts4.2/channel/Base.d.ts

@@ -128,7 +128,12 @@ export default class Channel {
     /**
      * Get current state
      */
-    state(): Promise<ChannelState>;
+    state(): Promise<{
+        calls: Encoded.CallStateTree;
+        halfSignedTx: Encoded.Transaction | '';
+        signedTx: Encoded.Transaction;
+        trees: Encoded.StateTrees;
+    }>;
     /**
      * Get current round
      *