@aeternity/aepp-sdk 13.0.0 → 13.1.0

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

@@ -0,0 +1,102 @@
+import * as coreClient from "@azure/core-client";
+export declare const Paths1I5J7OcV2AccountsIdActivitiesGetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const Activity: coreClient.CompositeMapper;
+export declare const PaginatedResponse: coreClient.CompositeMapper;
+export declare const ErrorResponse: coreClient.CompositeMapper;
+export declare const Paths17FlgdkV2Aex141GetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const Aex141Response: coreClient.CompositeMapper;
+export declare const PathsAxw0PwV2Aex141OwnedNftsAccountidGetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const Aex141OwnedTokenResponse: coreClient.CompositeMapper;
+export declare const PathsN3Ru7DV2Aex141ContractidOwnersGetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const PathsRa6Pv6V2Aex141ContractidTemplatesGetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const Aex141TemplatesResponse: coreClient.CompositeMapper;
+export declare const Paths19B9O7TV2Aex141ContractidTemplatesTemplateidTokensGetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const Aex141TemplateTokensResponse: coreClient.CompositeMapper;
+export declare const Paths1Fe570RV2Aex9GetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const Aex9Response: coreClient.CompositeMapper;
+export declare const PathsO9MbpkV2Aex9AccountBalancesAccountIdGetResponses200ContentApplicationJsonSchemaAllof1: coreClient.CompositeMapper;
+export declare const Aex9BalanceResponse: coreClient.CompositeMapper;
+export declare const PathsY2JwfkV2Aex9TransfersFromToSenderRecipientGetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const Aex9TransferResponse: coreClient.CompositeMapper;
+export declare const Paths5U7W2V2Aex9TransfersFromIdGetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const Paths12TleqhV2Aex9TransfersToIdGetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const Paths1C2B0UpV2Aex9ContractidBalancesGetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const Aex9ContractBalanceResponse: coreClient.CompositeMapper;
+export declare const PathsBelvp6V2Aex9ContractidBalancesAccountidGetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const Paths11X7LpcV2Aex9ContractidBalancesAccountidHistoryGetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const Paths5LeqfqV2BlocksGetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const Block: coreClient.CompositeMapper;
+export declare const NotFoundResponse: coreClient.CompositeMapper;
+export declare const PathsC25EgV2ChannelsGetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const Channel: coreClient.CompositeMapper;
+export declare const Paths1Csrt0IV2ContractsCallsGetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const ContractCall: coreClient.CompositeMapper;
+export declare const Paths9Ya94MV2ContractsLogsGetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const ContractLog: coreClient.CompositeMapper;
+export declare const PathsRzn6HzV2DeltastatsGetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const DeltaStat: coreClient.CompositeMapper;
+export declare const Paths10TrrshV2KeyBlocksGetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const KeyBlock: coreClient.CompositeMapper;
+export declare const Paths7Hfka2V2KeyBlocksHashOrKbiMicroBlocksGetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const MicroBlock: coreClient.CompositeMapper;
+export declare const Paths1RxrrvbV2MicroBlocksHashTxsGetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const Tx: coreClient.CompositeMapper;
+export declare const Paths16Srg6EV2NamesGetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const Name: coreClient.CompositeMapper;
+export declare const NameInfo: coreClient.CompositeMapper;
+export declare const NameInfoOwnership: coreClient.CompositeMapper;
+export declare const NameInfoPointers: coreClient.CompositeMapper;
+export declare const Auction: coreClient.CompositeMapper;
+export declare const AuctionInfo: coreClient.CompositeMapper;
+export declare const AuctionInfoLastBid: coreClient.CompositeMapper;
+export declare const Paths1I6PwfdV2NamesSearchGetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const Paths7P6Qc1V2NamesSearchGetResponses200ContentApplicationJsonSchemaAllof0PropertiesDataItemsAllof1: coreClient.CompositeMapper;
+export declare const NameClaim: coreClient.CompositeMapper;
+export declare const PathsDjelzuV2NamesIdPointeesGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const NameTransfer: coreClient.CompositeMapper;
+export declare const NameUpdate: coreClient.CompositeMapper;
+export declare const Oracle: coreClient.CompositeMapper;
+export declare const OracleExtendsItem: coreClient.CompositeMapper;
+export declare const PathsMherz6V2OraclesGetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const Status: coreClient.CompositeMapper;
+export declare const StatusMdwAsyncTasks: coreClient.CompositeMapper;
+export declare const PathsDpxn99V2TotalstatsGetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const TotalStat: coreClient.CompositeMapper;
+export declare const Paths17Cjtx5V2TransfersGetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const Transfer: coreClient.CompositeMapper;
+export declare const Paths1R74KpvV2TxsGetResponses200ContentApplicationJsonSchemaAllof0: coreClient.CompositeMapper;
+export declare const Paths16Tt677V2TxsCountIdGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const Aex141TransferEvent: coreClient.CompositeMapper;
+export declare const Aex9TransferEvent: coreClient.CompositeMapper;
+export declare const InternalContractCallEvent: coreClient.CompositeMapper;
+export declare const InternalTransferEvent: coreClient.CompositeMapper;
+export declare const NameClaimEvent: coreClient.CompositeMapper;
+export declare const PathsKlr2M2V2AccountsIdActivitiesGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const PathsFlc7UjV2Aex141GetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const PathsSs61ZgV2Aex141OwnedNftsAccountidGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const Paths1Ilysy5V2Aex141ContractidOwnersGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const Paths17O9Fn6V2Aex141ContractidTemplatesGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const PathsNuoourV2Aex141ContractidTemplatesTemplateidTokensGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const Paths1Wbogg8V2Aex9GetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const Paths1BsirxgV2Aex9AccountBalancesAccountIdGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const Paths1V0FiznV2Aex9TransfersFromToSenderRecipientGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const Paths1X48QgjV2Aex9TransfersFromIdGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const Paths1DkkopqV2Aex9TransfersToIdGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const PathsNi359V2Aex9ContractidBalancesGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const Paths15Ih6XV2BlocksGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const Paths1Txl2A9V2ChannelsGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const Paths187U0XzV2ContractsCallsGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const PathsB246H1V2ContractsLogsGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const Paths7Pbec0V2DeltastatsGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const Paths1Ulxr59V2KeyBlocksGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const PathsO99PhzV2KeyBlocksHashOrKbiMicroBlocksGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const PathsGuqvhdV2MicroBlocksHashTxsGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const PathsK9TkttV2NamesGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const Paths3Msq0DV2NamesSearchGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const PathsB0YvynV2OraclesGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const Paths15PsutbV2TotalstatsGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const PathsIgs9Z1V2TransfersGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const PathsFclv4TV2TxsGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const Paths1R02SlwV2Aex9ContractidBalancesAccountidGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const Paths1T9RwnyV2Aex9ContractidBalancesAccountidHistoryGetResponses200ContentApplicationJsonSchema: coreClient.CompositeMapper;
+export declare const Get200ApplicationJsonAllOfPropertiesItemsItem: coreClient.CompositeMapper;

package/types-legacy/ts4.2/apis/middleware/models/parameters.d.ts

@@ -0,0 +1,43 @@
+import { OperationParameter, OperationURLParameter, OperationQueryParameter } from "@azure/core-client";
+export declare const accept: OperationParameter;
+export declare const $host: OperationURLParameter;
+export declare const id: OperationURLParameter;
+export declare const ownedOnly: OperationQueryParameter;
+export declare const type: OperationQueryParameter;
+export declare const limit: OperationQueryParameter;
+export declare const scope: OperationQueryParameter;
+export declare const direction: OperationQueryParameter;
+export declare const by: OperationQueryParameter;
+export declare const prefix: OperationQueryParameter;
+export declare const accountId: OperationURLParameter;
+export declare const contractId: OperationURLParameter;
+export declare const tokenId: OperationURLParameter;
+export declare const templateId: OperationURLParameter;
+export declare const accountId1: OperationURLParameter;
+export declare const sender: OperationURLParameter;
+export declare const recipient: OperationURLParameter;
+export declare const hash: OperationQueryParameter;
+export declare const hashOrKbi: OperationURLParameter;
+export declare const kbi: OperationURLParameter;
+export declare const mbi: OperationURLParameter;
+export declare const state: OperationQueryParameter;
+export declare const contractId1: OperationQueryParameter;
+export declare const event: OperationQueryParameter;
+export declare const functionPrefix: OperationQueryParameter;
+export declare const data: OperationQueryParameter;
+export declare const aexnArgs: OperationQueryParameter;
+export declare const hash1: OperationURLParameter;
+export declare const ownedBy: OperationQueryParameter;
+export declare const state1: OperationQueryParameter;
+export declare const type1: OperationQueryParameter;
+export declare const typeGroup: OperationQueryParameter;
+export declare const account: OperationQueryParameter;
+export declare const contract: OperationQueryParameter;
+export declare const channel: OperationQueryParameter;
+export declare const oracle: OperationQueryParameter;
+export declare const senderId: OperationQueryParameter;
+export declare const recipientId: OperationQueryParameter;
+export declare const entrypoint: OperationQueryParameter;
+export declare const txType: OperationQueryParameter;
+export declare const id1: OperationQueryParameter;
+export declare const hashOrIndex: OperationURLParameter;

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

@@ -9,7 +9,8 @@ import AccountBase from './account/Base';
 /**
  * @category chain
  */
-export declare function _getPollInterval(type: 'block' | 'microblock', { _expectedMineRate, _microBlockCycle, _maxPollInterval }: {
+export declare function _getPollInterval(type: 'block' | 'microblock', // TODO: rename to 'key-block' | 'micro-block'
+{ _expectedMineRate, _microBlockCycle, _maxPollInterval }: {
     _expectedMineRate?: number;
     _microBlockCycle?: number;
     _maxPollInterval?: number;

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

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { EventEmitter } from 'events';
+import EventEmitter from 'events';
 import { w3cwebsocket as W3CWebSocket } from 'websocket';
 import { Tag } from '../tx/builder/constants';
 import { SignTx, ChannelOptions, ChannelState, ChannelHandler, ChannelAction, ChannelStatus, ChannelFsm, ChannelMessage, ChannelEvents } from './internal';

package/types-legacy/ts4.2/contract/Contract.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="@aeternity__aepp-calldata" />
 /**
  * Contract module - routines to interact with the æternity contract
  *
@@ -36,7 +35,7 @@ interface SendAndProcessReturnType {
     result?: ContractCallObject;
     hash: TxData['hash'];
     tx: TxUnpacked & {
-        tag: Tag.ContractCallTx | Tag.ContractCreateTx;
+        tag: Tag.SignedTx | Tag.ContractCallTx | Tag.ContractCreateTx;
     };
     txData: TxData;
     rawTx: Encoded.Transaction;

package/types-legacy/ts4.2/contract/compiler/Base.d.ts

@@ -47,6 +47,27 @@ export default abstract class CompilerBase {
         bytecode: Encoded.ContractBytearray;
         aci: Aci;
     }>;
+    /**
+     * Generate contract's ACI by contract's path
+     * Available only in Node.js
+     * @param path - Path to contract source code
+     * @returns ACI
+     */
+    abstract generateAci(path: string): Promise<Aci>;
+    /**
+     * Generate contract's ACI by contract's source code
+     * @param sourceCode - Contract source code as string
+     * @param fileSystem - A map of contract filename to the corresponding contract source code to
+     * include into the main contract
+     * @example
+     * ```js
+     * {
+     *   'library.aes': 'namespace TestLib =\n  function sum(x: int, y: int) : int = x + y'
+     * }
+     * ```
+     * @returns ACI
+     */
+    abstract generateAciBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): Promise<Aci>;
     /**
      * Verify that a contract bytecode is the result of compiling the given source code
      * Available only in Node.js

package/types-legacy/ts4.2/contract/compiler/Cli.d.ts

@@ -17,6 +17,8 @@ export default class CompilerCli extends CompilerBase {
         bytecode: Encoded.ContractBytearray;
         aci: Aci;
     }>;
+    generateAci(path: string): Promise<Aci>;
+    generateAciBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): Promise<Aci>;
     validate(bytecode: Encoded.ContractBytearray, path: string): Promise<boolean>;
     validateBySourceCode(bytecode: Encoded.ContractBytearray, sourceCode: string, fileSystem?: Record<string, string>): Promise<boolean>;
     version(): Promise<string>;

package/types-legacy/ts4.2/contract/compiler/Http.d.ts

@@ -26,6 +26,8 @@ export default class CompilerHttp extends CompilerBase {
         bytecode: Encoded.ContractBytearray;
         aci: Aci;
     }>;
+    generateAciBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): Promise<Aci>;
+    generateAci(path: string): Promise<Aci>;
     validateBySourceCode(bytecode: Encoded.ContractBytearray, sourceCode: string, fileSystem?: Record<string, string>): Promise<boolean>;
     validate(bytecode: Encoded.ContractBytearray, path: string): Promise<boolean>;
     version(): Promise<string>;

package/types-legacy/ts4.2/contract/compiler/HttpNode.d.ts

@@ -13,5 +13,6 @@ export default class CompilerHttpNode extends HttpBrowser {
         bytecode: Encoded.ContractBytearray;
         aci: Aci;
     }>;
+    generateAci(path: string): Promise<Aci>;
     validate(bytecode: Encoded.ContractBytearray, path: string): Promise<boolean>;
 }

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

@@ -0,0 +1,14 @@
+import { RpcError } from './aepp-wallet-communication/schema';
+/**
+ * @category exception
+ * @deprecated this exception is not thrown anymore
+ */
+export declare class RpcBroadcastError extends RpcError {
+    static code: number;
+    code: number;
+    constructor(data?: any);
+}
+/**
+ * @deprecated use isAuctionName instead
+ */
+export declare const NAME_BID_MAX_LENGTH = 12;

package/types-legacy/ts4.2/index-browser.d.ts

@@ -1,22 +1,25 @@
-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';
 export { ORACLE_TTL_TYPES, ORACLE_TTL, QUERY_TTL, RESPONSE_TTL, DRY_RUN_ACCOUNT, CallReturnType, } from './tx/builder/schema';
 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';
 export { default as AeSdk } from './AeSdk';
@@ -32,9 +35,12 @@ 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/types-legacy/ts4.2/tx/builder/constants.d.ts

@@ -11,7 +11,6 @@ export declare const NAME_FEE_MULTIPLIER = 100000000000000;
 export declare const NAME_FEE_BID_INCREMENT = 0.05;
 export declare const NAME_BID_TIMEOUT_BLOCKS = 480;
 export declare const NAME_MAX_LENGTH_FEE = 31;
-export declare const NAME_BID_MAX_LENGTH = 12;
 export declare const NAME_BID_RANGES: {
     [k: string]: BigNumber;
 };

package/types-legacy/ts4.2/tx/builder/field-types/coin-amount.d.ts

@@ -2,7 +2,7 @@
 import { Int } from '../constants';
 import { AE_AMOUNT_FORMATS } from '../../../utils/amount-formatter';
 declare const _default: {
-    serializeAettos(value: string | undefined): string;
+    serializeAettos(value: string | undefined, params: {}): string;
     serialize(value: Int | undefined, params: {}, { denomination }: {
         denomination?: AE_AMOUNT_FORMATS | undefined;
     }): Buffer;

package/types-legacy/ts4.2/tx/builder/field-types/deposit.d.ts

@@ -9,7 +9,7 @@ declare const _default: {
      * @returns Deposit value Buffer.
      */
     serialize(value: Int | undefined, options: Parameters<(typeof coinAmount)['serialize']>[1], parameters: Parameters<(typeof coinAmount)['serialize']>[2]): Buffer;
-    serializeAettos(value: string | undefined): string;
+    serializeAettos(value: string | undefined, params: {}): string;
     deserialize(value: Buffer): string;
 };
 export default _default;

package/types-legacy/ts4.2/tx/builder/field-types/index.d.ts

@@ -31,7 +31,7 @@ declare const boolean: {
     deserialize(buffer: Buffer): boolean;
 };
 declare const coinAmount: {
-    serializeAettos(value: string | undefined): string;
+    serializeAettos(value: string | undefined, params: {}): string;
     serialize(value: import("../constants").Int | undefined, params: {}, { denomination }: {
         denomination?: import("../../..").AE_AMOUNT_FORMATS | undefined;
     }): Buffer;
@@ -51,7 +51,7 @@ declare const deposit: {
     serialize(value: import("../constants").Int | undefined, options: {}, parameters: {
         denomination?: import("../../..").AE_AMOUNT_FORMATS | undefined;
     }): Buffer;
-    serializeAettos(value: string | undefined): string;
+    serializeAettos(value: string | undefined, params: {}): string;
     deserialize(value: Buffer): string;
 };
 declare const encoded: typeof _encoded;

package/types-legacy/ts4.2/tx/builder/helpers.d.ts

@@ -22,6 +22,7 @@ export declare function buildContractId(ownerId: Encoded.AccountAddress, nonce:
  * @returns Contract public key
  */
 export declare function oracleQueryId(senderId: Encoded.AccountAddress, nonce: number | BigNumber | string, oracleId: Encoded.OracleAddress): Encoded.OracleQueryId;
+export declare function nameToPunycode(maybeName: string): AensName;
 /**
  * Encode an AENS name
  * @category AENS
@@ -45,12 +46,18 @@ export declare function commitmentHash(name: AensName, salt?: number): Encoded.C
  * @returns Buffer Buffer from number(BigEndian)
  */
 export declare function readInt(buf?: Buffer): string;
+/**
+ * Ensure that name is valid AENS name, would throw an exception otherwise
+ * @category AENS
+ * @param name - AENS name
+ */
+export declare function ensureName(maybeName: string): asserts maybeName is AensName;
 /**
  * Is AENS name valid
  * @category AENS
  * @param name - AENS name
  */
-export declare function isNameValid(name: string): name is AensName;
+export declare function isNameValid(maybeName: string): maybeName is AensName;
 declare const encodingToPointerKey: readonly [
     readonly [
         Encoded.Encoding.AccountAddress,

package/types-legacy/ts4.2/tx/builder/index.d.ts

@@ -9,6 +9,7 @@ export declare function getSchema(tag: Tag, version?: number): Array<[
     string,
     Field
 ]>;
+type TxEncoding = Encoding.Transaction | Encoding.Poi | Encoding.StateTrees | Encoding.CallStateTree;
 /**
  * Build transaction hash
  * @category transaction builder
@@ -17,7 +18,7 @@ export declare function getSchema(tag: Tag, version?: number): Array<[
  * @param options.prefix - Prefix of transaction
  * @returns object Base64Check transaction hash with 'tx_' prefix
  */
-export declare function buildTx<E extends Encoding = Encoding.Transaction>(params: TxParams, { prefix, }?: {
+export declare function buildTx<E extends TxEncoding = Encoding.Transaction>(params: TxParams, { prefix }?: {
     prefix?: E;
 }): Encoded.Generic<E>;
 export type BuildTxOptions<TxType extends Tag, OmitFields extends string> = Omit<TxParamsAsync & {
@@ -34,7 +35,7 @@ export declare function buildTxAsync(params: TxParamsAsync): Promise<Encoded.Tra
  * @param txType - Expected transaction type
  * @returns Object with transaction param's
  */
-export declare function unpackTx<TxType extends Tag>(encodedTx: Encoded.Transaction | Encoded.Poi | Encoded.StateTrees | Encoded.CallStateTree, txType?: TxType): TxUnpacked & {
+export declare function unpackTx<TxType extends Tag>(encodedTx: Encoded.Generic<TxEncoding>, txType?: TxType): TxUnpacked & {
     tag: TxType;
 };
 /**
@@ -51,3 +52,4 @@ export declare function buildTxHash(rawTx: Encoded.Transaction | Uint8Array): En
  * @returns Contract public key
  */
 export declare function buildContractIdByContractTx(contractTx: Encoded.Transaction): Encoded.ContractAddress;
+export {};

package/types-legacy/ts4.2/tx/builder/schema.d.ts

@@ -217,7 +217,7 @@ export declare const txSchema: readonly [
             deserialize: (value: Buffer) => `ak_${string}` | `nm_${string}`;
         };
         readonly amount: {
-            serializeAettos(value: string | undefined): string;
+            serializeAettos(value: string | undefined, params: {}): string;
             serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
                 denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
             }): Buffer;
@@ -656,7 +656,7 @@ export declare const txSchema: readonly [
             serialize(value: import("./constants").Int | undefined, options: {}, parameters: {
                 denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
             }): Buffer;
-            serializeAettos(value: string | undefined): string;
+            serializeAettos(value: string | undefined, params: {}): string;
             deserialize(value: Buffer): string;
         };
     },
@@ -727,11 +727,11 @@ export declare const txSchema: readonly [
             serialize(value: import("./constants").Int | undefined, options: {}, parameters: {
                 denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
             }): Buffer;
-            serializeAettos(value: string | undefined): string;
+            serializeAettos(value: string | undefined, params: {}): string;
             deserialize(value: Buffer): string;
         };
         readonly amount: {
-            serializeAettos(value: string | undefined): string;
+            serializeAettos(value: string | undefined, params: {}): string;
             serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
                 denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
             }): Buffer;
@@ -830,7 +830,7 @@ export declare const txSchema: readonly [
             deserialize(value: Buffer): number;
         };
         readonly amount: {
-            serializeAettos(value: string | undefined): string;
+            serializeAettos(value: string | undefined, params: {}): string;
             serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
                 denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
             }): Buffer;
@@ -936,7 +936,7 @@ export declare const txSchema: readonly [
             deserialize(buffer: Buffer): string;
         };
         readonly queryFee: {
-            serializeAettos(value: string | undefined): string;
+            serializeAettos(value: string | undefined, params: {}): string;
             serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
                 denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
             }): Buffer;
@@ -999,7 +999,7 @@ export declare const txSchema: readonly [
             deserialize(buffer: Buffer): string;
         };
         readonly queryFee: {
-            serializeAettos(value: string | undefined): string;
+            serializeAettos(value: string | undefined, params: {}): string;
             serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
                 denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
             }): Buffer;
@@ -1145,7 +1145,7 @@ export declare const txSchema: readonly [
             deserialize(buffer: Buffer): string;
         };
         readonly queryFee: {
-            serializeAettos(value: string | undefined): string;
+            serializeAettos(value: string | undefined, params: {}): string;
             serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
                 denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
             }): Buffer;
@@ -2982,7 +2982,7 @@ export declare const txSchema: readonly [
             constValueOptional: boolean;
         };
         readonly fee: {
-            serializeAettos(value: string | undefined): string;
+            serializeAettos(value: string | undefined, params: {}): string;
             serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
                 denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
             }): Buffer;

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

@@ -4,6 +4,23 @@ 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.
+ *
+ * The idea is that if you need to show transaction details with some accuracy you can define
+ * expense fields that you want to show separately. And to show `getExecutionCost` result as a fee,
+ * subtracting all fields shown separately.
+ *
+ * @example
+ * ```vue
+ * <template>
+ * Amount: {{ txUnpacked.amount }}
+ * Name fee: {{ txUnpacked.nameFee }}
+ * Other fees: {{ getExecutionCost(txEncoded) - txUnpacked.amount - txUnpacked.nameFee }}
+ * </template>
+ * ```
+ *
+ * Doing this way you won't worry to show wrong fee for a transaction you may not support. Because
+ * the SDK calculates the overall price of any transaction on its side.
+ *
  * @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

package/types-legacy/ts4.2/utils/amount-formatter.d.ts

@@ -38,5 +38,4 @@ export declare const toAe: (value: string | number | BigNumber, { denomination }
 export declare const toAettos: (value: string | number | BigNumber, { denomination }?: {
     denomination?: AE_AMOUNT_FORMATS | undefined;
 }) => string;
-declare const _default: (rawValue: string | number | BigNumber) => string;
-export default _default;
+export declare const prefixedAmount: (rawValue: string | number | BigNumber) => string;

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

@@ -74,6 +74,7 @@ export declare function sign(data: string | Uint8Array, privateKey: string | Uin
  * @returns is data was signed by address
  */
 export declare function verify(data: Uint8Array, signature: Uint8Array, address: Encoded.AccountAddress): boolean;
+export declare const messagePrefixLength: Buffer;
 export declare function messageToHash(message: string): Buffer;
 export declare function signMessage(message: string, privateKey: string | Buffer): Uint8Array;
 /**

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

@@ -240,11 +240,11 @@ export declare class UnexpectedChannelMessageError extends ChannelError {
  * @category exception
  */
 export declare class ChannelIncomingMessageError extends ChannelError {
-    handlerError: BaseError;
+    handlerError: Error;
     incomingMessage: {
         [key: string]: any;
     };
-    constructor(handlerError: BaseError, incomingMessage: {
+    constructor(handlerError: Error, incomingMessage: {
         [key: string]: any;
     });
 }

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

@@ -29,3 +29,4 @@ export declare function isKeyOfObject<T extends object>(key: string | number | s
 export declare function isItemOfArray<T>(item: any, array: readonly T[]): item is T;
 export declare function isAccountNotFoundError(error: Error): boolean;
 export type UnionToIntersection<Union> = (Union extends any ? (k: Union) => void : never) extends ((k: infer Intersection) => void) ? Intersection : never;
+export declare function ensureError(error: unknown): asserts error is Error;

package/types-legacy/ts4.2/utils/typed-data.d.ts

@@ -0,0 +1,60 @@
+/// <reference types="node" />
+import { Encoded } from './encoder';
+/**
+ * Hashes arbitrary object, can be used to inline the aci hash to contract source code
+ */
+export declare function hashJson(data: unknown): Buffer;
+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;
+}
+export declare function encodeFateValue(value: unknown, aci: AciValue): Encoded.ContractBytearray;
+export declare function decodeFateValue(value: Encoded.ContractBytearray, aci: AciValue): Encoded.ContractBytearray;
+/**
+ * Hashes domain object, can be used to inline domain hash to contract source code
+ */
+export declare function hashDomain(domain: Domain): Buffer;
+export declare function hashTypedData(data: Encoded.ContractBytearray, aci: AciValue, domain: Domain): Buffer;