@aeternity/aepp-sdk 13.0.1 → 13.2.0

package/types-legacy/ts4.5/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.5/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.5/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.5/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.5/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.5/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.5/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.5/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.5/contract/delegation-signature.d.ts

@@ -14,6 +14,7 @@ import Node from '../Node';
  * @param options.onAccount - Account to use
  * @param options.onNode - Node to use
  * @returns Signature
+ * @deprecated use methods `sign*DelegationToContract` of Account instance instead
  * @example
  * ```js
  * const aeSdk = new AeSdk({ ... })
@@ -36,7 +37,7 @@ import Node from '../Node';
  *   .createDelegationSignature(contractAddress, [oracleQueryId], { onAccount, omitAddress: true })
  * ```
  */
-export default function createDelegationSignature(contractAddress: Encoded.ContractAddress, ids: Array<Encoded.Any | AensName>, options: {
+export default function createDelegationSignature(contractAddress: Encoded.ContractAddress, ids: Array<Encoded.Any | AensName>, { onAccount, omitAddress, ...options }: {
     omitAddress?: boolean;
     onAccount: AccountBase;
     onNode: Node;

package/types-legacy/ts4.5/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.5/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.5/spend.d.ts

@@ -34,7 +34,8 @@ interface SpendOptions extends SpendOptionsType {
  * console.log('Transaction mined at', blockHeight);
  * ```
  */
-export declare function transferFunds(fraction: number | string, recipientIdOrName: AensName | Encoded.AccountAddress, options: TransferFundsOptions): ReturnType<typeof sendTransaction>;
+export declare function transferFunds(fraction: number | string, // TODO: accept only number
+recipientIdOrName: AensName | Encoded.AccountAddress, options: TransferFundsOptions): ReturnType<typeof sendTransaction>;
 type TransferFundsOptionsType = BuildTxOptions<Tag.SpendTx, 'senderId' | 'recipientId' | 'amount'> & Parameters<typeof resolveName>[2] & {
     onAccount: AccountBase;
 } & SendTransactionOptions;

package/types-legacy/ts4.5/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.5/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.5/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.5/tx/builder/field-types/index.d.ts

@@ -1,157 +1,32 @@
 /// <reference types="node" />
-import _address from './address';
-import _array from './array';
-import _encoded from './encoded';
-import _entry from './entry';
-import _enumeration from './enumeration';
-import _map from './map';
-import _mptree from './mptree';
-import _nonce from './nonce';
-import _shortUIntConst from './short-u-int-const';
-import _wrapped from './wrapped';
-declare const abiVersion: {
-    _getProtocolDetails(c: import("../constants").ConsensusProtocolVersion, tag: import("../constants").Tag): import("../constants").AbiVersion;
-    serialize(value: import("../constants").AbiVersion | undefined, { tag }: {
-        tag: import("../constants").Tag;
-    }, { consensusProtocolVersion }: {
-        consensusProtocolVersion?: import("../constants").ConsensusProtocolVersion | undefined;
-    }): Buffer;
-    prepare(value: import("../constants").AbiVersion | undefined, { tag }: {
-        tag: import("../constants").Tag;
-    }, options: {
-        consensusProtocolVersion?: import("../constants").ConsensusProtocolVersion | undefined;
-        onNode?: import("../../..").Node | undefined;
-    }): Promise<import("../constants").AbiVersion | undefined>;
-    deserialize(buffer: Buffer): import("../constants").AbiVersion;
-};
-declare const address: typeof _address;
-declare const array: typeof _array;
-declare const boolean: {
-    serialize(value: boolean): Buffer;
-    deserialize(buffer: Buffer): boolean;
-};
-declare const coinAmount: {
-    serializeAettos(value: string | undefined): string;
-    serialize(value: import("../constants").Int | undefined, params: {}, { denomination }: {
-        denomination?: import("../../..").AE_AMOUNT_FORMATS | undefined;
-    }): Buffer;
-    deserialize(value: Buffer): string;
-};
-declare const ctVersion: {
-    serialize(value: import("./ct-version").CtVersion | undefined, params: {}, { consensusProtocolVersion }: {
-        consensusProtocolVersion?: import("../constants").ConsensusProtocolVersion | undefined;
-    }): Buffer;
-    prepare(value: import("./ct-version").CtVersion | undefined, params: {}, options: {
-        consensusProtocolVersion?: import("../constants").ConsensusProtocolVersion | undefined;
-        onNode?: import("../../..").Node | undefined;
-    }): Promise<import("./ct-version").CtVersion | undefined>;
-    deserialize(buffer: Buffer): import("./ct-version").CtVersion;
-};
-declare const deposit: {
-    serialize(value: import("../constants").Int | undefined, options: {}, parameters: {
-        denomination?: import("../../..").AE_AMOUNT_FORMATS | undefined;
-    }): Buffer;
-    serializeAettos(value: string | undefined): string;
-    deserialize(value: Buffer): string;
-};
-declare const encoded: typeof _encoded;
-declare const entry: typeof _entry;
-declare const enumeration: typeof _enumeration;
-declare const fee: {
-    serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
-        rebuildTx: (params: any) => `tx_${string}`;
-        unpackTx: typeof import("..").unpackTx;
-        buildTx: typeof import("..").buildTx;
-        _computingMinFee?: import("bignumber.js").BigNumber | undefined;
-        _pickBiggerFee?: boolean | undefined;
-    }): string;
-    serialize(value: import("../constants").Int | undefined, params: {}, { denomination }: {
-        denomination?: import("../../..").AE_AMOUNT_FORMATS | undefined;
-    }): Buffer;
-    deserialize(value: Buffer): string;
-};
-declare const field: {
-    serialize(value: string): Buffer;
-    deserialize(value: Buffer): string;
-};
-declare const gasLimit: {
-    serialize(_value: number | undefined, { tag, rebuildTx, unpackTx, buildTx, _computingGasLimit, }: {
-        tag: import("../constants").Tag;
-        rebuildTx: (params: any) => any;
-        unpackTx: typeof import("..").unpackTx;
-        buildTx: typeof import("..").buildTx;
-        _computingGasLimit?: number | undefined;
-    }, { gasMax }: {
-        gasMax?: number | undefined;
-    }): Buffer;
-    deserialize(value: Buffer): number;
-};
-declare const gasPrice: {
-    serializeAettos(value?: string | undefined): string;
-    serialize(value: import("../constants").Int | undefined, params: {}, { denomination }: {
-        denomination?: import("../../..").AE_AMOUNT_FORMATS | undefined;
-    }): Buffer;
-    deserialize(value: Buffer): string;
-};
-declare const map: typeof _map;
-declare const mptree: typeof _mptree;
-declare const name: {
-    serialize(value: `${string}.chain`): Buffer;
-    deserialize(value: Buffer): `${string}.chain`;
-};
-declare const nameFee: {
-    serializeAettos(_value: string | undefined, txFields: {
-        name: `${string}.chain`;
-    }): string;
-    serialize(value: import("../constants").Int | undefined, txFields: {
-        name: `${string}.chain`;
-    }, parameters: {
-        denomination?: import("../../..").AE_AMOUNT_FORMATS | undefined;
-    }): Buffer;
-    deserialize(value: Buffer): string;
-};
-declare const nameId: {
-    serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
-    deserialize: (value: Buffer) => `nm_${string}`;
-};
-declare const nonce: typeof _nonce;
-declare const pointers: {
-    serialize(pointers: (import("../../../apis/node").NamePointer & {
-        id: `ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`;
-    })[]): Buffer[][];
-    deserialize(pointers: [
-        key: Buffer,
-        id: Buffer
-    ][]): (import("../../../apis/node").NamePointer & {
-        id: `ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`;
-    })[];
-};
-declare const raw: {
-    serialize(buffer: Uint8Array): Buffer;
-    deserialize(buffer: Buffer): Buffer;
-};
-declare const shortUInt: {
-    serialize(value: number): Buffer;
-    deserialize(value: Buffer): number;
-};
-declare const shortUIntConst: typeof _shortUIntConst;
-declare const string: {
-    serialize(string: string): Buffer;
-    deserialize(buffer: Buffer): string;
-};
-declare const ttl: {
-    serialize(value: number | undefined): Buffer;
-    prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
-        onNode?: import("../../..").Node | undefined;
-        absoluteTtl?: boolean | undefined;
-    }): Promise<number | undefined>;
-    deserialize(value: Buffer): number;
-};
-declare const uInt: {
-    serialize(value: import("../constants").Int): Buffer;
-    deserialize(value: Buffer): string;
-};
-declare const wrapped: typeof _wrapped;
+import abiVersion from './abi-version';
+import address from './address';
+import array from './array';
+import boolean from './boolean';
+import coinAmount from './coin-amount';
+import ctVersion from './ct-version';
+import deposit from './deposit';
+import encoded from './encoded';
+import entry from './entry';
+import enumeration from './enumeration';
+import fee from './fee';
+import field from './field';
+import gasLimit from './gas-limit';
+import gasPrice from './gas-price';
+import map from './map';
+import mptree from './mptree';
+import name from './name';
+import nameFee from './name-fee';
+import nameId from './name-id';
+import nonce from './nonce';
+import pointers from './pointers';
+import raw from './raw';
+import shortUInt from './short-u-int';
+import shortUIntConst from './short-u-int-const';
+import string from './string';
+import ttl from './ttl';
+import uInt from './u-int';
+import wrapped from './wrapped';
 export type BinaryData = Buffer | Buffer[] | Buffer[][] | Array<[
     Buffer,
     Array<[

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