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

package/types-legacy/ts4.2/tx/execution-cost.d.ts

@@ -0,0 +1,35 @@
+import { Encoded } from '../utils/encoder';
+import Node from '../Node';
+/**
+ * Calculates the cost of transaction execution
+ * Provides an upper cost of contract-call-related transactions because of `gasLimit`.
+ * Also assumes that oracle query fee is 0 unless it is provided in options.
+ * @param transaction - Transaction to calculate the cost of
+ * @param innerTx - Should be provided if transaction wrapped with Tag.PayingForTx
+ * @param gasUsed - Amount of gas actually used to make calculation more accurate
+ * @param queryFee - Oracle query fee
+ * @param isInitiator - Is transaction signer an initiator of state channel
+ */
+export declare function getExecutionCost(transaction: Encoded.Transaction, { innerTx, gasUsed, queryFee, isInitiator, }?: {
+    innerTx?: 'fee-payer' | 'freeloader';
+    gasUsed?: number;
+    queryFee?: string;
+    isInitiator?: boolean;
+}): bigint;
+/**
+ * Calculates the cost of signed transaction execution
+ * @param transaction - Transaction to calculate the cost of
+ * @param networkId - Network id used to sign the transaction
+ * @param options - Options
+ */
+export declare function getExecutionCostBySignedTx(transaction: Encoded.Transaction, networkId: string, options?: Omit<Parameters<typeof getExecutionCost>[1], 'innerTx'>): bigint;
+/**
+ * Calculates the cost of signed and not signed transaction execution using node
+ * @param transaction - Transaction to calculate the cost of
+ * @param node - Node to use
+ * @param isMined - Is transaction already mined or not
+ * @param options - Options
+ */
+export declare function getExecutionCostUsingNode(transaction: Encoded.Transaction, node: Node, { isMined, ...options }?: {
+    isMined?: boolean;
+} & Parameters<typeof getExecutionCost>[1]): Promise<bigint>;

package/types-legacy/ts4.2/tx/transaction-signer.d.ts

@@ -0,0 +1,6 @@
+import { Encoded } from '../utils/encoder';
+/**
+ * Returns account address that signed a transaction
+ * @param transaction - transaction to get a signer of
+ */
+export default function getTransactionSignerAddress(transaction: Encoded.Transaction): Encoded.AccountAddress;

package/types-legacy/ts4.2/tx/validator.d.ts

@@ -1,5 +1,4 @@
-import { Tag } from './builder/constants';
-import { Encoded } from '../utils/encoder';
+import { unpackTx } from './builder';
 import Node from '../Node';
 export interface ValidatorResult {
     message: string;
@@ -8,13 +7,12 @@ export interface ValidatorResult {
 }
 /**
  * Transaction Validator
- * This function validates some of transaction properties,
+ * 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
- * @param parentTxTypes - Types of parent transactions
  * @returns Array with verification errors
  * @example const errors = await verifyTransaction(transaction, node)
  */
-export default function verifyTransaction(transaction: Encoded.Transaction | Encoded.Poi, nodeNotCached: Node, parentTxTypes?: Tag[]): Promise<ValidatorResult[]>;
+export default function verifyTransaction(transaction: Parameters<typeof unpackTx>[0], nodeNotCached: Node): Promise<ValidatorResult[]>;

package/types-legacy/ts4.2/utils/autorest.d.ts

@@ -2,6 +2,7 @@ import { PipelinePolicy } from '@azure/core-rest-pipeline';
 import { AdditionalPolicyConfig } from '@azure/core-client';
 export declare const genRequestQueuesPolicy: () => AdditionalPolicyConfig;
 export declare const genCombineGetRequestsPolicy: () => AdditionalPolicyConfig;
-export declare const genAggressiveCacheGetResponsesPolicy: () => PipelinePolicy;
+export declare const genAggressiveCacheGetResponsesPolicy: () => AdditionalPolicyConfig;
 export declare const genErrorFormatterPolicy: (getMessage: (b: any) => string) => AdditionalPolicyConfig;
-export declare const genVersionCheckPolicy: (name: string, ignorePath: string, versionPromise: Promise<string>, geVersion: string, ltVersion: string) => PipelinePolicy;
+export declare const genVersionCheckPolicy: (name: string, ignorePath: string, versionPromise: Promise<string | Error>, geVersion: string, ltVersion: string) => PipelinePolicy;
+export declare const genRetryOnFailurePolicy: (retryCount: number, retryOverallDelay: number) => AdditionalPolicyConfig;

package/types-legacy/ts4.2/utils/errors.d.ts

@@ -1,4 +1,6 @@
 import BigNumber from 'bignumber.js';
+import { AensName, Int } from '../tx/builder/constants';
+import * as Encoded from './encoder-types';
 /**
  * aepp-sdk originated error
  * @category exception
@@ -70,7 +72,7 @@ export declare class WalletError extends BaseError {
  * @category exception
  */
 export declare class ArgumentError extends BaseError {
-    constructor(argumentName: string, requirement: string, argumentValue: any);
+    constructor(argumentName: string, requirement: unknown, argumentValue: unknown);
 }
 /**
  * @category exception
@@ -112,7 +114,7 @@ export declare class RequestTimedOutError extends BaseError {
  * @category exception
  */
 export declare class TxTimedOutError extends BaseError {
-    constructor(blocks: number, th: string);
+    constructor(blocks: number, th: Encoded.TxHash);
 }
 /**
  * @category exception
@@ -160,13 +162,13 @@ export declare class UnexpectedTsError extends InternalError {
  * @category exception
  */
 export declare class UnavailableAccountError extends AccountError {
-    constructor(address: string);
+    constructor(address: Encoded.AccountAddress);
 }
 /**
  * @category exception
  */
 export declare class AensPointerContextError extends AensError {
-    constructor(nameOrId: string, prefix: string);
+    constructor(nameOrId: AensName | Encoded.Name, prefix: string);
 }
 /**
  * @category exception
@@ -196,7 +198,7 @@ export declare class MissingCallbackError extends AeppError {
  * @category exception
  */
 export declare class UnAuthorizedAccountError extends AeppError {
-    constructor(onAccount: string);
+    constructor(onAccount: Encoded.AccountAddress);
 }
 /**
  * @category exception
@@ -262,7 +264,7 @@ export declare class InvalidAuthDataError extends CompilerError {
  * @category exception
  */
 export declare class BytecodeMismatchError extends ContractError {
-    constructor(source: string);
+    constructor(source: 'source code' | 'bytecode');
 }
 /**
  * @category exception
@@ -274,7 +276,7 @@ export declare class DuplicateContractError extends ContractError {
  * @category exception
  */
 export declare class InactiveContractError extends ContractError {
-    constructor(contractAddress: string);
+    constructor(contractAddress: Encoded.ContractAddress);
 }
 /**
  * @category exception
@@ -304,8 +306,8 @@ export declare class MissingFunctionNameError extends ContractError {
  * @category exception
  */
 export declare class NodeInvocationError extends ContractError {
-    transaction: string;
-    constructor(message: string, transaction: string);
+    transaction?: Encoded.Transaction;
+    constructor(message: string, transaction?: Encoded.Transaction);
 }
 /**
  * @category exception
@@ -317,19 +319,19 @@ export declare class NoSuchContractFunctionError extends ContractError {
  * @category exception
  */
 export declare class NotPayableFunctionError extends ContractError {
-    constructor(amount: string, fn: string);
+    constructor(amount: Int, fn: string);
 }
 /**
  * @category exception
  */
 export declare class MissingEventDefinitionError extends ContractError {
-    constructor(eventNameHash: string, eventAddress: string);
+    constructor(eventNameHash: string, eventAddress: Encoded.ContractAddress);
 }
 /**
  * @category exception
  */
 export declare class AmbiguousEventDefinitionError extends ContractError {
-    constructor(eventAddress: string, matchedEvents: Array<[
+    constructor(eventAddress: Encoded.ContractAddress, matchedEvents: Array<[
         string,
         string
     ]>);
@@ -412,12 +414,6 @@ export declare class IllegalBidFeeError extends TransactionError {
 export declare class InvalidSignatureError extends TransactionError {
     constructor(message: string);
 }
-/**
- * @category exception
- */
-export declare class InvalidTxParamsError extends TransactionError {
-    constructor(message: string);
-}
 /**
  * @category exception
  */
@@ -428,7 +424,7 @@ export declare class PrefixNotFoundError extends TransactionError {
  * @category exception
  */
 export declare class SchemaNotFoundError extends TransactionError {
-    constructor(schemaName: string, key: string, version: number);
+    constructor(key: string, version: number);
 }
 /**
  * @category exception
@@ -440,25 +436,7 @@ export declare class TagNotFoundError extends TransactionError {
  * @category exception
  */
 export declare class TxNotInChainError extends TransactionError {
-    constructor(txHash: string);
-}
-/**
- * @category exception
- */
-export declare class UnknownTxError extends TransactionError {
-    constructor(message: string);
-}
-/**
- * @category exception
- */
-export declare class UnsupportedABIversionError extends TransactionError {
-    constructor(message: string);
-}
-/**
- * @category exception
- */
-export declare class UnsupportedVMversionError extends TransactionError {
-    constructor(message: string);
+    constructor(txHash: Encoded.TxHash);
 }
 /**
  * @category exception

package/types-legacy/ts4.5/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.5/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.5/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.5/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.5/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.5/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.5/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.5/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.5/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.5/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.5/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.5/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;