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

package/src/utils/crypto.ts

@@ -1,19 +1,3 @@
-/*
- * ISC License (ISC)
- * Copyright 2018 aeternity developers
- *
- *  Permission to use, copy, modify, and/or distribute this software for any
- *  purpose with or without fee is hereby granted, provided that the above
- *  copyright notice and this permission notice appear in all copies.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
- *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
- *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
- *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
- *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
- *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- *  PERFORMANCE OF THIS SOFTWARE.
- */
 import nacl, { SignKeyPair } from 'tweetnacl';
 // js extension is required for mjs build, not importing the whole package to reduce bundle size
 // eslint-disable-next-line import/extensions

package/src/utils/errors.ts

@@ -1,5 +1,7 @@
 // eslint-disable-next-line max-classes-per-file
 import BigNumber from 'bignumber.js';
+import { AensName, Int } from '../tx/builder/constants';
+import * as Encoded from './encoder-types';
 
 /**
  * aepp-sdk originated error
@@ -116,8 +118,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';
   }
 }
@@ -186,7 +188,7 @@ export class RequestTimedOutError extends BaseError {
  * @category exception
  */
 export class TxTimedOutError extends BaseError {
-  constructor(blocks: number, th: string) {
+  constructor(blocks: number, th: Encoded.TxHash) {
     super([
       `Giving up after ${blocks} blocks mined`,
       `transaction hash: ${th}`,
@@ -269,7 +271,7 @@ export class UnexpectedTsError extends InternalError {
  * @category exception
  */
 export class UnavailableAccountError extends AccountError {
-  constructor(address: string) {
+  constructor(address: Encoded.AccountAddress) {
     super(`Account for ${address} not available`);
     this.name = 'UnavailableAccountError';
   }
@@ -279,7 +281,7 @@ export class UnavailableAccountError extends AccountError {
  * @category exception
  */
 export class AensPointerContextError extends AensError {
-  constructor(nameOrId: string, prefix: string) {
+  constructor(nameOrId: AensName | Encoded.Name, prefix: string) {
     super(`Name ${nameOrId} don't have pointers for ${prefix}`);
     this.name = 'AensPointerContextError';
   }
@@ -329,7 +331,7 @@ export class MissingCallbackError extends AeppError {
  * @category exception
  */
 export class UnAuthorizedAccountError extends AeppError {
-  constructor(onAccount: string) {
+  constructor(onAccount: Encoded.AccountAddress) {
     super(`You do not have access to account ${onAccount}`);
     this.name = 'UnAuthorizedAccountError';
   }
@@ -435,7 +437,7 @@ export class InvalidAuthDataError extends CompilerError {
  * @category exception
  */
 export class BytecodeMismatchError extends ContractError {
-  constructor(source: string) {
+  constructor(source: 'source code' | 'bytecode') {
     super(`Contract ${source} do not correspond to the bytecode deployed on the chain`);
     this.name = 'BytecodeMismatchError';
   }
@@ -455,7 +457,7 @@ export class DuplicateContractError extends ContractError {
  * @category exception
  */
 export class InactiveContractError extends ContractError {
-  constructor(contractAddress: string) {
+  constructor(contractAddress: Encoded.ContractAddress) {
     super(`Contract with address ${contractAddress} not active`);
     this.name = 'InactiveContractError';
   }
@@ -505,9 +507,9 @@ export class MissingFunctionNameError extends ContractError {
  * @category exception
  */
 export class NodeInvocationError extends ContractError {
-  transaction: string;
+  transaction?: Encoded.Transaction;
 
-  constructor(message: string, transaction: string) {
+  constructor(message: string, transaction?: Encoded.Transaction) {
     super(`Invocation failed${message == null ? '' : `: "${message}"`}`);
     this.name = 'NodeInvocationError';
     this.transaction = transaction;
@@ -528,7 +530,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',
@@ -541,7 +543,7 @@ export class NotPayableFunctionError extends ContractError {
  * @category exception
  */
 export class MissingEventDefinitionError extends ContractError {
-  constructor(eventNameHash: string, eventAddress: string) {
+  constructor(eventNameHash: string, eventAddress: Encoded.ContractAddress) {
     super(
       `Can't find definition of ${eventNameHash} event emitted by ${eventAddress}`
       + ' (use omitUnknown option to ignore events like this)',
@@ -554,7 +556,7 @@ export class MissingEventDefinitionError extends ContractError {
  * @category exception
  */
 export class AmbiguousEventDefinitionError extends ContractError {
-  constructor(eventAddress: string, matchedEvents: Array<[string, string]>) {
+  constructor(eventAddress: Encoded.ContractAddress, matchedEvents: Array<[string, string]>) {
     super(
       `Found multiple definitions of "${matchedEvents[0][1]}" event with different types emitted by`
       + ` ${eventAddress} in ${matchedEvents.map(([name]) => `"${name}"`).join(', ')} contracts`
@@ -694,16 +696,6 @@ export class InvalidSignatureError extends TransactionError {
   }
 }
 
-/**
- * @category exception
- */
-export class InvalidTxParamsError extends TransactionError {
-  constructor(message: string) {
-    super(message);
-    this.name = 'InvalidTxParamsError';
-  }
-}
-
 /**
  * @category exception
  */
@@ -718,8 +710,8 @@ export class PrefixNotFoundError extends TransactionError {
  * @category exception
  */
 export class SchemaNotFoundError extends TransactionError {
-  constructor(schemaName: string, key: string, version: number) {
-    super(`Transaction ${schemaName} not implemented for ${key} version ${version}`);
+  constructor(key: string, version: number) {
+    super(`Transaction schema not implemented for tag ${key} version ${version}`);
     this.name = 'SchemaNotFoundError';
   }
 }
@@ -738,42 +730,12 @@ export class TagNotFoundError extends TransactionError {
  * @category exception
  */
 export class TxNotInChainError extends TransactionError {
-  constructor(txHash: string) {
+  constructor(txHash: Encoded.TxHash) {
     super(`Transaction ${txHash} is removed from chain`);
     this.name = 'TxNotInChainError';
   }
 }
 
-/**
- * @category exception
- */
-export class UnknownTxError extends TransactionError {
-  constructor(message: string) {
-    super(message);
-    this.name = 'UnknownTxError';
-  }
-}
-
-/**
- * @category exception
- */
-export class UnsupportedABIversionError extends TransactionError {
-  constructor(message: string) {
-    super(message);
-    this.name = 'UnsupportedABIversionError';
-  }
-}
-
-/**
- * @category exception
- */
-export class UnsupportedVMversionError extends TransactionError {
-  constructor(message: string) {
-    super(message);
-    this.name = 'UnsupportedVMversionError';
-  }
-}
-
 /**
  * @category exception
  */

package/src/utils/string.ts

@@ -1,20 +1,3 @@
-/*
- * ISC License (ISC)
- * Copyright 2018 aeternity developers
- *
- *  Permission to use, copy, modify, and/or distribute this software for any
- *  purpose with or without fee is hereby granted, provided that the above
- *  copyright notice and this permission notice appear in all copies.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
- *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
- *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
- *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
- *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
- *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- *  PERFORMANCE OF THIS SOFTWARE.
- */
-
 /**
  * Convert string from snake_case to PascalCase
  * @param s - String to convert

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

@@ -3,19 +3,20 @@ import * as aensMethods from './aens';
 import * as spendMethods from './spend';
 import * as oracleMethods from './oracle';
 import Contract, { ContractMethodsBase } from './contract/Contract';
+import createDelegationSignature from './contract/delegation-signature';
 import * as contractGaMethods from './contract/ga';
-import { _buildTx } from './tx';
 import { UnionToIntersection } from './utils/other';
 import Node from './Node';
-import { Tag } from './tx/builder/constants';
+import { TxParamsAsync } from './tx/builder/schema.generated';
 import AccountBase from './account/Base';
 import { Encoded } from './utils/encoder';
-import CompilerHttp from './contract/CompilerHttp';
 export type OnAccount = Encoded.AccountAddress | AccountBase | undefined;
 export declare function getValueOrErrorProxy<Value extends object>(valueCb: () => Value): Value;
 declare const methods: {
     readonly createGeneralizedAccount: typeof contractGaMethods.createGeneralizedAccount;
     readonly buildAuthTxHash: typeof contractGaMethods.buildAuthTxHash;
+    readonly buildAuthTxHashByGaMetaTx: typeof contractGaMethods.buildAuthTxHashByGaMetaTx;
+    readonly createDelegationSignature: typeof createDelegationSignature;
     readonly pollForQueries: typeof oracleMethods.pollForQueries;
     readonly pollForQueryResponse: typeof oracleMethods.pollForQueryResponse;
     readonly getQueryObject: typeof oracleMethods.getQueryObject;
@@ -24,7 +25,6 @@ declare const methods: {
     readonly respondToQuery: typeof oracleMethods.respondToQuery;
     readonly getOracleObject: typeof oracleMethods.getOracleObject;
     readonly registerOracle: typeof oracleMethods.registerOracle;
-    readonly send: typeof spendMethods.send;
     readonly spend: typeof spendMethods.spend;
     readonly transferFunds: typeof spendMethods.transferFunds;
     readonly payForTransaction: typeof spendMethods.payForTransaction;
@@ -102,12 +102,9 @@ declare class AeSdkMethods {
     _getOptions(): AeSdkMethodsOptions & {
         onAccount: AccountBase;
     };
-    buildTx<TxType extends Tag>(txType: TxType, options: Omit<Parameters<any>[1], 'onNode'> & {
+    buildTx(options: TxParamsAsync): Promise<Encoded.Transaction>;
+    initializeContract<Methods extends ContractMethodsBase>(options?: Omit<Parameters<typeof Contract.initialize>[0], 'onNode'> & {
         onNode?: Node;
-    }): Promise<Encoded.Transaction>;
-    initializeContract<Methods extends ContractMethodsBase>(options?: Omit<Parameters<typeof Contract.initialize>[0], 'onNode' | 'onCompiler'> & {
-        onNode?: Node;
-        onCompiler?: CompilerHttp;
     }): Promise<Contract<Methods>>;
 }
 type RequiredKeys<T> = {
@@ -117,12 +114,13 @@ type OptionalIfNotRequired<T extends [
     any
 ]> = RequiredKeys<T[0]> extends never ? T | [
 ] : T;
+type ReplaceOnAccount<Options> = Options extends {
+    onAccount: any;
+} ? Omit<Options, 'onAccount'> & {
+    onAccount: OnAccount;
+} : Options;
 type MakeOptional<Options> = OptionalIfNotRequired<[
-    Omit<Options, 'onNode' | 'onCompiler' | 'onAccount'> & {
-        onNode?: Node;
-        onCompiler?: CompilerHttp;
-        onAccount?: OnAccount;
-    }
+    Omit<Options, 'onNode' | 'onCompiler' | 'onAccount'> & Partial<ReplaceOnAccount<Options>>
 ]>;
 type TransformMethods<Methods extends {
     [key: string]: Function;

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 {
@@ -68,9 +68,13 @@ export default class Node extends Node_base {
      * @param url - Url for node API
      * @param options - Options
      * @param options.ignoreVersion - Don't check node version
+     * @param options.retryCount - Amount of extra requests to do in case of failure
+     * @param options.retryOverallDelay - Time in ms to wait between all retries
      */
-    constructor(url: string, { ignoreVersion, ...options }?: NodeOptionalParams & {
+    constructor(url: string, { ignoreVersion, retryCount, retryOverallDelay, ...options }?: NodeOptionalParams & {
         ignoreVersion?: boolean;
+        retryCount?: number;
+        retryOverallDelay?: number;
     });
     getNetworkId(): Promise<string>;
     getNodeInfo(): Promise<NodeInfo>;

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

@@ -1,6 +1,15 @@
 import { Encoded } from '../utils/encoder';
 import Node from '../Node';
-import CompilerHttp from '../contract/CompilerHttp';
+import CompilerBase from '../contract/compiler/Base';
+import { Int } from '../tx/builder/constants';
+interface AuthData {
+    fee?: Int;
+    gasLimit?: number;
+    gasPrice?: Int;
+    callData?: Encoded.ContractBytearray;
+    sourceCode?: string;
+    args?: any[];
+}
 /**
  * Account is one of the three basic building blocks of an
  * {@link AeSdk} and provides access to a signing key pair.
@@ -17,14 +26,9 @@ export default abstract class AccountBase {
     abstract signTransaction(tx: Encoded.Transaction, options: {
         innerTx?: boolean;
         networkId?: string;
-        authData?: {
-            gasLimit?: number;
-            callData?: Encoded.ContractBytearray;
-            sourceCode?: string;
-            args?: any[];
-        };
+        authData?: AuthData | ((tx: Encoded.Transaction) => Promise<AuthData>);
         onNode?: Node;
-        onCompiler?: CompilerHttp;
+        onCompiler?: CompilerBase;
         aeppOrigin?: string;
         aeppRpcClientId?: string;
     }): Promise<Encoded.Transaction>;
@@ -50,3 +54,4 @@ export default abstract class AccountBase {
      */
     readonly address: Encoded.AccountAddress;
 }
+export {};

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

@@ -1,5 +1,6 @@
 import AccountBase from './Base';
 import { Encoded } from '../utils/encoder';
+export declare function getBufferToSign(transaction: Encoded.Transaction, networkId: string, innerTx: boolean): Uint8Array;
 /**
  * In-memory account class
  */
@@ -14,7 +15,7 @@ export default class AccountMemory extends AccountBase {
      */
     static generate(): AccountMemory;
     sign(data: string | Uint8Array, options?: any): Promise<Uint8Array>;
-    signTransaction(tx: Encoded.Transaction, { innerTx, networkId, ...options }?: {
+    signTransaction(transaction: Encoded.Transaction, { innerTx, networkId, ...options }?: {
         innerTx?: boolean;
         networkId?: string;
     }): Promise<Encoded.Transaction>;

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

@@ -8,9 +8,8 @@
 import BigNumber from 'bignumber.js';
 import { Tag, AensName } from './tx/builder/constants';
 import { Encoded } from './utils/encoder';
-import { send, SendOptions } from './spend';
-import { getName } from './chain';
-import { BuildTxOptions } from './tx';
+import { sendTransaction, SendTransactionOptions, getName } from './chain';
+import { BuildTxOptions } from './tx/builder';
 import { TransformNodeType } from './Node';
 import { NameEntry, NamePointer } from './apis/node';
 import AccountBase from './account/Base';
@@ -39,8 +38,8 @@ interface KeyPointers {
  * await nameObject.revoke({ fee, ttl, nonce })
  * ```
  */
-export declare function aensRevoke(name: AensName, options: AensRevokeOptions): ReturnType<typeof send>;
-interface AensRevokeOptions extends BuildTxOptions<Tag.NameRevokeTx, 'nameId' | 'accountId'>, SendOptions {
+export declare function aensRevoke(name: AensName, options: AensRevokeOptions): ReturnType<typeof sendTransaction>;
+interface AensRevokeOptions extends BuildTxOptions<Tag.NameRevokeTx, 'nameId' | 'accountId' | 'onNode'>, SendTransactionOptions {
 }
 /**
  * Update a name
@@ -71,8 +70,8 @@ interface AensRevokeOptions extends BuildTxOptions<Tag.NameRevokeTx, 'nameId' |
  * await nameObject.update(pointers, { nameTtl, ttl, fee, nonce, clientTtl })
  * ```
  */
-export declare function aensUpdate(name: AensName, pointers: KeyPointers, { extendPointers, ...options }: AensUpdateOptions): ReturnType<typeof send>;
-interface AensUpdateOptions extends BuildTxOptions<Tag.NameUpdateTx, 'nameId' | 'accountId' | 'pointers' | 'clientTtl' | 'nameTtl'>, SendOptions {
+export declare function aensUpdate(name: AensName, pointers: KeyPointers, { extendPointers, ...options }: AensUpdateOptions): ReturnType<typeof sendTransaction>;
+interface AensUpdateOptions extends BuildTxOptions<Tag.NameUpdateTx, 'nameId' | 'accountId' | 'pointers' | 'clientTtl' | 'nameTtl' | 'onNode'>, SendTransactionOptions {
     extendPointers?: boolean;
     clientTtl?: number;
     nameTtl?: number;
@@ -100,8 +99,8 @@ interface AensUpdateOptions extends BuildTxOptions<Tag.NameUpdateTx, 'nameId' |
  * await nameObject.transfer(recipientPub, { ttl, fee, nonce })
  * ```
  */
-export declare function aensTransfer(name: AensName, account: Encoded.AccountAddress, options: AensTransferOptions): ReturnType<typeof send>;
-interface AensTransferOptions extends BuildTxOptions<Tag.NameTransferTx, 'nameId' | 'accountId' | 'recipientId'>, SendOptions {
+export declare function aensTransfer(name: AensName, account: Encoded.AccountAddress, options: AensTransferOptions): ReturnType<typeof sendTransaction>;
+interface AensTransferOptions extends BuildTxOptions<Tag.NameTransferTx, 'nameId' | 'accountId' | 'recipientId' | 'onNode'>, SendTransactionOptions {
 }
 /**
  * Query the AENS name info from the node
@@ -161,10 +160,10 @@ export declare function aensQuery(name: AensName, opt: Parameters<typeof getName
  * ```
  */
 export declare function aensClaim(name: AensName, salt: number, options: AensClaimOptions): Promise<AensClaimReturnType>;
-type AensClaimOptionsType = BuildTxOptions<Tag.NameClaimTx, 'accountId' | 'nameSalt' | 'name'> & SendOptions & Parameters<typeof aensQuery>[1];
+type AensClaimOptionsType = BuildTxOptions<Tag.NameClaimTx, 'accountId' | 'nameSalt' | 'name'> & SendTransactionOptions & Parameters<typeof aensQuery>[1];
 interface AensClaimOptions extends AensClaimOptionsType {
 }
-interface AensClaimReturnType extends Awaited<ReturnType<typeof send>>, Partial<Awaited<ReturnType<typeof aensQuery>>> {
+interface AensClaimReturnType extends Awaited<ReturnType<typeof sendTransaction>>, Partial<Awaited<ReturnType<typeof aensQuery>>> {
 }
 /**
  * Preclaim a name. Sends a hash of the name and a random salt to the node
@@ -190,13 +189,12 @@ interface AensClaimReturnType extends Awaited<ReturnType<typeof send>>, Partial<
  * }
  * ```
  */
-export declare function aensPreclaim(name: AensName, options: AensPreclaimOptions): Promise<Readonly<Awaited<ReturnType<typeof send>> & {
-    height: number;
+export declare function aensPreclaim(name: AensName, options: AensPreclaimOptions): Promise<Readonly<Awaited<ReturnType<typeof sendTransaction>> & {
     salt: number;
     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' | 'onNode'>, SendTransactionOptions, 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/aepp-wallet-communication/rpc/types.d.ts

@@ -1,6 +1,7 @@
-import { send } from '../../spend';
 import { Encoded } from '../../utils/encoder';
 import { METHODS, SUBSCRIPTION_TYPES, WALLET_TYPE } from '../schema';
+import { TransformNodeType } from '../../Node';
+import { SignedTx } from '../../apis/node';
 export interface WalletInfo {
     id: string;
     name: string;
@@ -64,7 +65,10 @@ export interface WalletApi {
          * @deprecated this is not a hash at all, will be removed later at the same time
          * as dropping ability to broadcast transaction by wallet
          */
-        transactionHash?: Awaited<ReturnType<typeof send>>;
+        transactionHash?: Partial<TransformNodeType<SignedTx>> & {
+            hash: Encoded.TxHash;
+            rawTx: Encoded.Transaction;
+        };
         signedTransaction?: Encoded.Transaction;
     }>);
     [METHODS.signMessage]: (p: {

package/types-legacy/ts4.2/apis/compiler/compiler.d.ts

@@ -15,7 +15,7 @@ export declare class Compiler extends coreClient.ServiceClient {
      */
     generateACI(body: Contract, options?: GenerateACIOptionalParams): Promise<GenerateACIResponse>;
     /**
-     * Compile a sophia contract from source and return byte code
+     * Compile a sophia contract from source and return byte code and ACI
      * @param body contract code
      * @param options The options parameters.
      */

package/types-legacy/ts4.2/apis/compiler/models/index.d.ts

@@ -26,9 +26,10 @@ export interface ErrorPos {
     line: number;
     col: number;
 }
-export interface ByteCode {
+export interface CompileResult {
     /** Prefixed (cb_) Base64Check encoded byte array */
     bytecode: string;
+    aci: Record<string, unknown>[];
 }
 export interface SophiaCallResultInput {
     /** (Possibly partial) Sophia contract code/interface */
@@ -131,7 +132,7 @@ export type GenerateACIResponse = Aci;
 export interface CompileContractOptionalParams extends coreClient.OperationOptions {
 }
 /** Contains response data for the compileContract operation. */
-export type CompileContractResponse = ByteCode;
+export type CompileContractResponse = CompileResult;
 /** Optional parameters. */
 export interface DecodeCallResultOptionalParams extends coreClient.OperationOptions {
 }

package/types-legacy/ts4.2/apis/compiler/models/mappers.d.ts

@@ -4,7 +4,7 @@ export declare const CompileOpts: coreClient.CompositeMapper;
 export declare const Aci: coreClient.CompositeMapper;
 export declare const CompilerError: coreClient.CompositeMapper;
 export declare const ErrorPos: coreClient.CompositeMapper;
-export declare const ByteCode: coreClient.CompositeMapper;
+export declare const CompileResult: coreClient.CompositeMapper;
 export declare const SophiaCallResultInput: coreClient.CompositeMapper;
 export declare const BytecodeCallResultInput: coreClient.CompositeMapper;
 export declare const DecodedCallresult: coreClient.CompositeMapper;

package/types-legacy/ts4.2/apis/node/models/index.d.ts

@@ -96,7 +96,7 @@ export interface SignedTx {
 /** A mix of all transaction types. */
 export interface Tx {
     /** Polymorphic discriminator, which specifies the different types this object can be */
-    type: "undefined";
+    type: "Tx";
     /** Base58Check encoded tagged pubkey */
     recipientId?: string;
     amount?: string;
@@ -808,7 +808,7 @@ export interface PayingForTx {
 export interface CheckTxInPoolResponse {
     status: string;
 }
-export type OffChainTransfer = OffChainUpdate & {
+export interface OffChainTransfer extends OffChainUpdate {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     op: "OffChainTransfer";
     /** Base58Check encoded tagged pubkey */
@@ -816,22 +816,22 @@ export type OffChainTransfer = OffChainUpdate & {
     /** Base58Check encoded tagged pubkey */
     to: string;
     amount: string;
-};
-export type OffChainWithdrawal = OffChainUpdate & {
+}
+export interface OffChainWithdrawal extends OffChainUpdate {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     op: "OffChainWithdrawal";
     /** Base58Check encoded tagged pubkey */
     to: string;
     amount: string;
-};
-export type OffChainDeposit = OffChainUpdate & {
+}
+export interface OffChainDeposit extends OffChainUpdate {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     op: "OffChainDeposit";
     /** Base58Check encoded tagged pubkey */
     from: string;
     amount: string;
-};
-export type OffChainNewContract = OffChainUpdate & {
+}
+export interface OffChainNewContract extends OffChainUpdate {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     op: "OffChainNewContract";
     /** Base58Check encoded tagged pubkey */
@@ -842,8 +842,8 @@ export type OffChainNewContract = OffChainUpdate & {
     deposit: string;
     /** Base64Check encoded tagged byte array */
     callData: string;
-};
-export type OffChainCallContract = OffChainUpdate & {
+}
+export interface OffChainCallContract extends OffChainUpdate {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     op: "OffChainCallContract";
     /** Base58Check encoded tagged pubkey */
@@ -856,11 +856,11 @@ export type OffChainCallContract = OffChainUpdate & {
     gasPrice: string;
     /** Base64Check encoded tagged byte array */
     callData: string;
-};
-export type CreateContractUnsignedTx = UnsignedTx & {
+}
+export interface CreateContractUnsignedTx extends UnsignedTx {
     /** Base58Check encoded tagged pubkey */
     contractId: string;
-};
+}
 /** Defines values for TTLType. */
 export type TTLType = "delta" | "block";
 /** Defines values for TxType. */
@@ -1015,11 +1015,11 @@ export type GetOracleByPubkeyResponse = RegisteredOracle;
 /** Optional parameters. */
 export interface GetOracleQueriesByPubkeyOptionalParams extends coreClient.OperationOptions {
     /** Last query id in previous page */
-    fromParam?: string;
+    from?: string;
     /** Max number of oracle queries */
     limit?: number;
     /** The type of a query: open, closed or all */
-    typeParam?: OracleQueryType;
+    type?: OracleQueryType;
 }
 /** Contains response data for the getOracleQueriesByPubkey operation. */
 export type GetOracleQueriesByPubkeyResponse = OracleQueries;

package/types-legacy/ts4.2/apis/node/models/mappers.d.ts

@@ -85,7 +85,7 @@ export declare const OffChainNewContract: coreClient.CompositeMapper;
 export declare const OffChainCallContract: coreClient.CompositeMapper;
 export declare const CreateContractUnsignedTx: coreClient.CompositeMapper;
 export declare let discriminators: {
-    "Tx.undefined": coreClient.CompositeMapper;
+    "Tx.Tx": coreClient.CompositeMapper;
     OffChainUpdate: coreClient.CompositeMapper;
     "OffChainUpdate.OffChainTransfer": coreClient.CompositeMapper;
     "OffChainUpdate.OffChainWithdrawal": coreClient.CompositeMapper;