@aeternity/aepp-sdk 13.3.3 → 14.0.0

package/types-legacy/ts4.5/contract/ga.d.ts

@@ -1,59 +0,0 @@
-/// <reference types="node" />
-/**
- * Generalized Account module - routines to use generalized account
- */
-import { Int, Tag } from '../tx/builder/constants';
-import { BuildTxOptions } from '../tx/builder';
-import { Encoded } from '../utils/encoder';
-import AccountBase from '../account/Base';
-import Contract from './Contract';
-import Node from '../Node';
-import { SendTransactionOptions } from '../send-transaction';
-import CompilerBase from './compiler/Base';
-/**
- * Convert current account to GA
- * @category contract
- * @param authFnName - Authorization function name
- * @param args - init arguments
- * @param options - Options
- * @returns General Account Object
- */
-export declare function createGeneralizedAccount(authFnName: string, args: any[], { onAccount, onCompiler, onNode, bytecode, aci, sourceCodePath, sourceCode, fileSystem, ...options }: CreateGeneralizedAccountOptions): Promise<Readonly<{
-    owner: Encoded.AccountAddress;
-    transaction: Encoded.TxHash;
-    rawTx: Encoded.Transaction;
-    gaContractId: Encoded.ContractAddress;
-}>>;
-interface CreateGeneralizedAccountOptions extends BuildTxOptions<Tag.GaAttachTx, 'authFun' | 'callData' | 'code' | 'ownerId' | 'gasLimit'>, SendTransactionOptions, Pick<Parameters<typeof Contract.initialize>[0], 'bytecode' | 'aci' | 'sourceCodePath' | 'sourceCode' | 'fileSystem'> {
-    onAccount: AccountBase;
-    onCompiler: CompilerBase;
-    onNode: Node;
-    gasLimit?: number;
-}
-/**
- * Build a transaction hash the same as `Auth.tx_hash` by GaMetaTx payload
- * @category contract
- * @param transaction - tx-encoded transaction
- * @param options - Options
- * @param options.fee - GaMetaTx fee, required in Ceres
- * @param options.gasPrice - GaMetaTx gasPrice, required in Ceres
- * @param options.onNode - Node to use
- * @returns Transaction hash
- */
-export declare function buildAuthTxHash(transaction: Encoded.Transaction, { fee, gasPrice, onNode }: {
-    fee?: Int;
-    gasPrice?: Int;
-    onNode: Node;
-}): Promise<Buffer>;
-/**
- * Build a transaction hash the same as `Auth.tx_hash` by GaMetaTx
- * @category contract
- * @param transaction - tx-encoded signed GaMeta transaction
- * @param options - Options
- * @param options.onNode - Node to use
- * @returns Transaction hash
- */
-export declare function buildAuthTxHashByGaMetaTx(transaction: Encoded.Transaction, { onNode }: {
-    onNode: Node;
-}): Promise<Buffer>;
-export {};

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

@@ -1,62 +0,0 @@
-import { AciValue } from './utils/typed-data';
-import { Encoded } from './utils/encoder';
-import { RpcError } from './aepp-wallet-communication/schema';
-import { ORACLE_TTL_TYPES } from './tx/builder/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;
-/**
- * @deprecated use ContractByteArrayEncoder:encodeWithType from \@aeternity/aepp-calldata
- */
-export declare function encodeFateValue(value: unknown, aci: AciValue): Encoded.ContractBytearray;
-/**
- * @deprecated use ContractByteArrayEncoder:decodeWithType from \@aeternity/aepp-calldata
- */
-export declare function decodeFateValue(value: Encoded.ContractBytearray, aci: AciValue): any;
-/**
- * @deprecated inlined in buildTx or use `180000`
- */
-export declare const NAME_TTL = 180000;
-/**
- * @deprecated inlined in buildTx or use `36000`
- */
-export declare const NAME_MAX_TTL = 36000;
-/**
- * @deprecated inlined in buildTx or use `60 * 60`
- */
-export declare const NAME_MAX_CLIENT_TTL: number;
-/**
- * @deprecated inlined in buildTx or use `60 * 60`
- */
-export declare const CLIENT_TTL: number;
-/**
- * @deprecated inlined in buildTx or use `{ type: ORACLE_TTL_TYPES.delta, value: 500 }`
- */
-export declare const ORACLE_TTL: {
-    type: ORACLE_TTL_TYPES;
-    value: number;
-};
-/**
- * @deprecated inlined in buildTx or use `{ type: ORACLE_TTL_TYPES.delta, value: 10 }`
- */
-export declare const QUERY_TTL: {
-    type: ORACLE_TTL_TYPES;
-    value: number;
-};
-/**
- * @deprecated inlined in buildTx or use `{ type: ORACLE_TTL_TYPES.delta, value: 10 }`
- */
-export declare const RESPONSE_TTL: {
-    type: ORACLE_TTL_TYPES;
-    value: number;
-};

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

@@ -1,51 +0,0 @@
-export { _getPollInterval, getHeight, poll, awaitHeight, waitForTxConfirm, getAccount, getBalance, getCurrentGeneration, getGeneration, getMicroBlockTransactions, getKeyBlock, getMicroBlockHeader, txDryRun, getContractByteCode, getContract, getName, resolveName, } from './chain';
-export { InvalidTxError, sendTransaction } from './send-transaction';
-export { getAddressFromPriv, isAddressValid, genSalt, encodeUnsigned, hash, encodeContractAddress, generateKeyPairFromSecret, generateKeyPair, sign, verify, messageToHash, signMessage, verifyMessage, isValidKeypair, } from './utils/crypto';
-export { signJwt, unpackJwt, verifyJwt, isJwt, ensureJwt, } from './utils/jwt';
-export type { Jwt } from './utils/jwt';
-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 { buildContractId, oracleQueryId, produceNameId, commitmentHash, readInt, isNameValid, ensureName, getDefaultPointerKey, getMinimumNameFee, computeBidFee, computeAuctionEndBlock, isAuctionName, } from './tx/builder/helpers';
-export { MAX_AUTH_FUN_GAS, 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, DRY_RUN_ACCOUNT, } from './tx/builder/constants';
-export type { Int, AensName } from './tx/builder/constants';
-export { ORACLE_TTL_TYPES, CallReturnType } from './tx/builder/schema';
-export { DelegationTag } from './tx/builder/delegation/schema';
-export { packDelegation, unpackDelegation } from './tx/builder/delegation';
-export { getExecutionCost, getExecutionCostBySignedTx, getExecutionCostUsingNode, } from './tx/execution-cost';
-export { default as getTransactionSignerAddress } from './tx/transaction-signer';
-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 { 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 { 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';
-export { default as AeSdkAepp } from './AeSdkAepp';
-export { default as AeSdkWallet } from './AeSdkWallet';
-export { default as Node } from './Node';
-export { default as verifyTransaction } from './tx/validator';
-export { default as AccountBase } from './account/Base';
-export { default as MemoryAccount } from './account/Memory';
-export { default as AccountGeneralized } from './account/Generalized';
-export { default as AccountLedger } from './account/Ledger';
-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 { 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 { BaseError, AccountError, AensError, AeppError, ChannelError, CompilerError, ContractError, CryptographyError, NodeError, TransactionError, WalletError, ArgumentError, IllegalArgumentError, ArgumentCountMismatchError, InsufficientBalanceError, MissingParamError, NoSerializerFoundError, RequestTimedOutError, TxTimedOutError, TypeError, UnsupportedPlatformError, UnsupportedProtocolError, NotImplementedError, UnsupportedVersionError, LogicError, 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, encodeFateValue, decodeFateValue, NAME_TTL, NAME_MAX_TTL, NAME_MAX_CLIENT_TTL, CLIENT_TTL, ORACLE_TTL, QUERY_TTL, RESPONSE_TTL, } from './deprecated';

package/types-legacy/ts4.5/index.d.ts

@@ -1,5 +0,0 @@
-export * from './index-browser';
-export { default as CompilerCli } from './contract/compiler/Cli';
-export { default as CompilerCli8 } from './contract/compiler/Cli8';
-export { default as getFileSystem } from './contract/compiler/getFileSystem';
-export { default as CompilerHttpNode } from './contract/compiler/HttpNode';

package/types-legacy/ts4.5/oracle.d.ts

@@ -1,125 +0,0 @@
-/**
- * Oracle methods - routines to interact with the æternity oracle system
- *
- * The high-level description of the oracle system is
- * https://github.com/aeternity/protocol/blob/master/ORACLE.md in the protocol
- * repository.
- */
-import { BuildTxOptions } from './tx/builder';
-import { Tag } from './tx/builder/constants';
-import { Encoded } from './utils/encoder';
-import { _getPollInterval } from './chain';
-import { sendTransaction, SendTransactionOptions } from './send-transaction';
-import Node from './Node';
-import AccountBase from './account/Base';
-type OracleQueries = Awaited<ReturnType<Node['getOracleQueriesByPubkey']>>['oracleQueries'];
-/**
- * Poll for oracle queries
- * @category oracle
- * @param oracleId - Oracle public key
- * @param onQuery - OnQuery callback
- * @param options - Options object
- * @param options.interval - Poll interval(default: 5000)
- * @param options.onNode - Node to use
- * @returns Callback to stop polling function
- */
-export declare function pollForQueries(oracleId: Encoded.OracleAddress, onQuery: (query: OracleQueries[number]) => void, { interval, ...options }: {
-    interval?: number;
-    onNode: Node;
-} & Parameters<typeof _getPollInterval>[1]): () => void;
-/**
- * Poll for oracle query response
- * @category oracle
- * @param oracleId - Oracle public key
- * @param queryId - Oracle Query id
- * @param options - Options object
- * @param options.interval - Poll interval
- * @param options.onNode - Node to use
- * @returns OracleQuery object
- */
-export declare function pollForQueryResponse(oracleId: Encoded.OracleAddress, queryId: Encoded.OracleQueryId, { interval, ...options }: {
-    interval?: number;
-    onNode: Node;
-} & Parameters<typeof _getPollInterval>[1]): Promise<string>;
-/**
- * Constructor for OracleQuery Object (helper object for using OracleQuery)
- * @category oracle
- * @param oracleId - Oracle public key
- * @param queryId - Oracle Query id
- * @param options - Options
- * @returns OracleQuery object
- */
-export declare function getQueryObject(oracleId: Encoded.OracleAddress, queryId: Encoded.OracleQueryId, options: RespondToQueryOptions & Parameters<typeof pollForQueryResponse>[2]): Promise<GetQueryObjectReturnType>;
-interface GetQueryObjectReturnType extends Awaited<ReturnType<Node['getOracleQueryByPubkeyAndQueryId']>> {
-    decodedQuery: string;
-    decodedResponse: string;
-    respond: (response: string, options?: Parameters<typeof respondToQuery>[2]) => ReturnType<typeof respondToQuery>;
-    pollForResponse: (options?: Parameters<typeof pollForQueryResponse>[2]) => ReturnType<typeof pollForQueryResponse>;
-}
-/**
- * Post query to oracle
- * @category oracle
- * @param oracleId - Oracle public key
- * @param query - Oracle query object
- * @param options - Options object
- * @returns Query object
- */
-export declare function postQueryToOracle(oracleId: Encoded.OracleAddress, query: string, options: PostQueryToOracleOptions): Promise<Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getQueryObject>>>;
-type PostQueryToOracleOptionsType = Parameters<typeof sendTransaction>[1] & Parameters<typeof getQueryObject>[2] & BuildTxOptions<Tag.OracleQueryTx, 'oracleId' | 'senderId' | 'query'>;
-interface PostQueryToOracleOptions extends PostQueryToOracleOptionsType {
-}
-/**
- * Extend oracle ttl
- * @category oracle
- * @param options - Options object
- * @returns Oracle object
- */
-export declare function extendOracleTtl(options: ExtendOracleTtlOptions): Promise<Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getOracleObject>>>;
-type ExtendOracleTtlOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleExtendTx, 'callerId' | 'oracleId'>;
-interface ExtendOracleTtlOptions extends ExtendOracleTtlOptionsType {
-}
-/**
- * Extend oracle ttl
- * @category oracle
- * @param queryId - Oracle query id
- * @param response - Oracle query response
- * @param options - Options object
- * @returns Oracle object
- */
-export declare function respondToQuery(queryId: Encoded.OracleQueryId, response: string, options: RespondToQueryOptions): Promise<Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getOracleObject>>>;
-type RespondToQueryOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleResponseTx, 'callerId' | 'oracleId' | 'queryId' | 'response'>;
-interface RespondToQueryOptions extends RespondToQueryOptionsType {
-}
-/**
- * Constructor for Oracle Object (helper object for using Oracle)
- * @category oracle
- * @param oracleId - Oracle public key
- * @param options - Options
- * @returns Oracle object
- */
-export declare function getOracleObject(oracleId: Encoded.OracleAddress, options: {
-    onNode: Node;
-    onAccount: AccountBase;
-}): Promise<GetOracleObjectReturnType>;
-interface GetOracleObjectReturnType extends Awaited<ReturnType<Node['getOracleByPubkey']>> {
-    id: Encoded.OracleAddress;
-    queries: OracleQueries;
-    pollQueries: (cb: Parameters<typeof pollForQueries>[1]) => ReturnType<typeof pollForQueries>;
-    postQuery: Function;
-    respondToQuery: Function;
-    extendOracle: Function;
-    getQuery: Function;
-}
-/**
- * Register oracle
- * @category oracle
- * @param queryFormat - Format of query
- * @param responseFormat - Format of query response
- * @param options - Options
- * @returns Oracle object
- */
-export declare function registerOracle(queryFormat: string, responseFormat: string, options: RegisterOracleOptions): Promise<Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getOracleObject>>>;
-type RegisterOracleOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleRegisterTx, 'accountId' | 'queryFormat' | 'responseFormat'>;
-interface RegisterOracleOptions extends RegisterOracleOptionsType {
-}
-export {};

package/types-legacy/ts4.5/send-transaction.d.ts

@@ -1,53 +0,0 @@
-import { ValidatorResult } from './tx/validator';
-import { TransactionError } from './utils/errors';
-import Node, { TransformNodeType } from './Node';
-import { SignedTx } from './apis/node';
-import { Encoded } from './utils/encoder';
-import AccountBase from './account/Base';
-import { poll, waitForTxConfirm } from './chain';
-/**
- * @category exception
- */
-export declare class InvalidTxError extends TransactionError {
-    validation: ValidatorResult[];
-    transaction: Encoded.Transaction;
-    constructor(message: string, validation: ValidatorResult[], transaction: Encoded.Transaction);
-}
-/**
- * Signs and submits transaction for mining
- * @category chain
- * @param txUnsigned - Transaction to sign and submit
- * @param options - Options
- * @returns Transaction details
- */
-export declare function sendTransaction(txUnsigned: Encoded.Transaction, { onNode, onAccount, verify, waitMined, confirm, innerTx, ...options }: SendTransactionOptions): Promise<SendTransactionReturnType>;
-type SendTransactionOptionsType = {
-    /**
-     * Node to use
-     */
-    onNode: Node;
-    /**
-     * Account to use
-     */
-    onAccount: AccountBase;
-    /**
-     * Verify transaction before broadcast, throw error if not
-     */
-    verify?: boolean;
-    /**
-     * Ensure that transaction get into block
-     */
-    waitMined?: boolean;
-    /**
-     * Number of micro blocks that should be mined after tx get included
-     */
-    confirm?: boolean | number;
-} & Parameters<typeof poll>[1] & Omit<Parameters<typeof waitForTxConfirm>[1], 'confirm'> & Parameters<AccountBase['signTransaction']>[1];
-export interface SendTransactionOptions extends SendTransactionOptionsType {
-}
-interface SendTransactionReturnType extends Partial<TransformNodeType<SignedTx>> {
-    hash: Encoded.TxHash;
-    rawTx: Encoded.Transaction;
-    confirmationHeight?: number;
-}
-export {};

package/types-legacy/ts4.5/spend.d.ts

@@ -1,56 +0,0 @@
-import { resolveName } from './chain';
-import { sendTransaction, SendTransactionOptions } from './send-transaction';
-import { BuildTxOptions } from './tx/builder';
-import { Encoded } from './utils/encoder';
-import { Tag, AensName } from './tx/builder/constants';
-import AccountBase from './account/Base';
-/**
- * Send coins to another account
- * @category chain
- * @param amount - Amount to spend
- * @param recipientIdOrName - Address or name of recipient account
- * @param options - Options
- * @returns Transaction
- */
-export declare function spend(amount: number | string, recipientIdOrName: Encoded.AccountAddress | Encoded.ContractAddress | AensName, options: SpendOptions): ReturnType<typeof sendTransaction>;
-type SpendOptionsType = BuildTxOptions<Tag.SpendTx, 'senderId' | 'recipientId' | 'amount'> & Parameters<typeof resolveName>[2] & {
-    onAccount: AccountBase;
-} & SendTransactionOptions;
-interface SpendOptions extends SpendOptionsType {
-}
-/**
- * Spend a fraction of coin balance to another account. Useful if needed to drain account balance
- * completely, sending funds to another account (with fraction set to 1).
- * @category chain
- * @param fraction - Fraction of balance to spend (between 0 and 1)
- * @param recipientIdOrName - Address or name of recipient account
- * @param options - Options
- * @example
- * ```js
- * // `fraction` * 100 = % of AE to be transferred (e.g. `0.42` for 42% or `1` for 100%)
- * const { blockHeight } = await aeSdk.transferFunds(
- *   0.42,
- *   'ak_21A27UVVt3hDkBE5J7rhhqnH5YNb4Y1dqo4PnSybrH85pnWo7E',
- * );
- * console.log('Transaction mined at', blockHeight);
- * ```
- */
-export declare function transferFunds(fraction: number | string, // TODO: accept only number
-recipientIdOrName: AensName | Encoded.AccountAddress | Encoded.ContractAddress, options: TransferFundsOptions): ReturnType<typeof sendTransaction>;
-type TransferFundsOptionsType = BuildTxOptions<Tag.SpendTx, 'senderId' | 'recipientId' | 'amount'> & Parameters<typeof resolveName>[2] & {
-    onAccount: AccountBase;
-} & SendTransactionOptions;
-interface TransferFundsOptions extends TransferFundsOptionsType {
-}
-/**
- * Submit transaction of another account paying for it (fee and gas)
- * @category chain
- * @param transaction - tx_<base64>-encoded transaction
- * @param options - Options
- * @returns Object Transaction
- */
-export declare function payForTransaction(transaction: Encoded.Transaction, options: PayForTransactionOptions): ReturnType<typeof sendTransaction>;
-interface PayForTransactionOptions extends BuildTxOptions<Tag.PayingForTx, 'payerId' | 'tx' | 'onNode'>, SendTransactionOptions {
-    onAccount: AccountBase;
-}
-export {};

package/types-legacy/ts4.5/tx/builder/SchemaTypes.d.ts

@@ -1,37 +0,0 @@
-import { Field as OriginalField } from './field-types';
-import { UnionToIntersection } from '../../utils/other';
-export interface Field extends OriginalField {
-    serialize: (...args: any[]) => any;
-}
-type NullablePartial<T, NK extends keyof T = {
-    [K in keyof T]: undefined extends T[K] ? K : never;
-}[keyof T]> = Partial<Pick<T, NK>> & Omit<T, NK>;
-type Or<A, B> = A extends undefined ? B : A;
-type TxParamsBySchemaInternal<SchemaItem> = {
-    -readonly [key in keyof SchemaItem]: SchemaItem[key] extends Field ? Parameters<SchemaItem[key]['serialize']>[0] : never;
-};
-type TxParamsBySchemaInternalParams<SchemaItem, SchemaItemValues = SchemaItem[keyof SchemaItem]> = UnionToIntersection<SchemaItemValues extends Field ? Or<Parameters<SchemaItemValues['serialize']>[2], {}> : never>;
-type PickIsRec<SchemaItem, Recursive extends boolean> = {
-    [Key in keyof SchemaItem as SchemaItem[Key] extends Field & {
-        recursiveType: true;
-    } ? (Recursive extends true ? Key : never) : (Recursive extends true ? never : Key)]: SchemaItem[Key];
-};
-type TxParamsBySchema<SchemaItem> = SchemaItem extends Object ? TxParamsBySchemaInternal<PickIsRec<SchemaItem, true>> & NullablePartial<TxParamsBySchemaInternal<PickIsRec<SchemaItem, false>>> & TxParamsBySchemaInternalParams<PickIsRec<SchemaItem, false>> : never;
-type TxParamsAsyncBySchemaInternal<SchemaItem> = {
-    -readonly [key in keyof SchemaItem]: SchemaItem[key] extends Field & {
-        prepare: Function;
-    } ? Parameters<SchemaItem[key]['prepare']>[0] : SchemaItem[key] extends Field ? Parameters<SchemaItem[key]['serialize']>[0] : never;
-};
-type TxParamsAsyncBySchemaInternalParams<SchemaItem, SchemaItemValues = SchemaItem[keyof SchemaItem]> = UnionToIntersection<SchemaItemValues extends Field & {
-    prepare: Function;
-} ? Or<Parameters<SchemaItemValues['prepare']>[2], {}> : {}>;
-type TxParamsAsyncBySchema<SchemaItem> = SchemaItem extends Object ? TxParamsAsyncBySchemaInternal<PickIsRec<SchemaItem, true>> & NullablePartial<TxParamsAsyncBySchemaInternal<PickIsRec<SchemaItem, false>>> & TxParamsAsyncBySchemaInternalParams<PickIsRec<SchemaItem, false>> & TxParamsBySchemaInternalParams<PickIsRec<SchemaItem, false>> : never;
-type TxUnpackedBySchema<SchemaItem> = {
-    -readonly [key in keyof SchemaItem]: SchemaItem[key] extends Field ? ReturnType<SchemaItem[key]['deserialize']> : never;
-};
-export default interface SchemaTypes<Schema extends readonly any[], SchemaItems = Schema[number]> {
-    TxParams: TxParamsBySchema<SchemaItems>;
-    TxParamsAsync: TxParamsAsyncBySchema<SchemaItems>;
-    TxUnpacked: TxUnpackedBySchema<SchemaItems>;
-}
-export {};

package/types-legacy/ts4.5/tx/builder/common.d.ts

@@ -1,32 +0,0 @@
-import { Field } from './field-types';
-import { Encoding, Encoded } from '../../utils/encoder';
-type Schemas = ReadonlyArray<{
-    tag: {
-        constValue: number;
-    } & Field;
-    version: {
-        constValue: number;
-        constValueOptional: boolean;
-    } & Field;
-}>;
-export declare function getSchema(schemas: Schemas, Tag: {
-    [key: number]: string;
-}, tag: number, version: number | undefined): Array<[
-    string,
-    Field
-]>;
-export declare function packRecord<E extends Encoding>(schemas: Schemas, Tag: {
-    [key: number]: string;
-}, params: {
-    tag: number;
-    version?: number;
-    [k: string]: unknown;
-}, extraParams: {
-    [k: string]: unknown;
-}, encoding: E): Encoded.Generic<E>;
-export declare function unpackRecord(schemas: Schemas, Tag: {
-    [key: number]: string;
-}, encodedRecord: Encoded.Any, expectedTag: number | undefined, extraParams: {
-    [k: string]: unknown;
-}): unknown;
-export {};

package/types-legacy/ts4.5/tx/builder/constants.d.ts

@@ -1,100 +0,0 @@
-import BigNumber from 'bignumber.js';
-export declare const DRY_RUN_ACCOUNT: {
-    readonly pub: "ak_11111111111111111111111111111111273Yts";
-    readonly amount: 100000000000000000000000000000000000n;
-};
-export declare const MAX_AUTH_FUN_GAS = 50000;
-export type Int = number | string | BigNumber;
-export type AensName = `${string}.chain`;
-export declare const MIN_GAS_PRICE = 1000000000;
-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_RANGES: {
-    [k: string]: BigNumber;
-};
-export declare enum ConsensusProtocolVersion {
-    Iris = 5,
-    Ceres = 6
-}
-/**
- * @category transaction builder
- * @see {@link https://github.com/aeternity/protocol/blob/0f6dee3d9d1e8e2469816798f5c7587a6c918f94/contracts/contract_vms.md#virtual-machines-on-the-%C3%A6ternity-blockchain}
- */
-export declare enum VmVersion {
-    NoVm = 0,
-    Sophia = 1,
-    SophiaImprovementsMinerva = 3,
-    SophiaImprovementsFortuna = 4,
-    Fate = 5,
-    SophiaImprovementsLima = 6,
-    Fate2 = 7,
-    Fate3 = 8
-}
-/**
- * @category transaction builder
- * @see {@link https://github.com/aeternity/protocol/blob/0f6dee3d9d1e8e2469816798f5c7587a6c918f94/contracts/contract_vms.md#virtual-machines-on-the-%C3%A6ternity-blockchain}
- */
-export declare enum AbiVersion {
-    NoAbi = 0,
-    Sophia = 1,
-    Fate = 3
-}
-/**
- * Enum with tag types
- * @category transaction builder
- * @see {@link https://github.com/aeternity/protocol/blob/0f6dee3d9d1e8e2469816798f5c7587a6c918f94/serializations.md#binary-serialization}
- * @see {@link https://github.com/aeternity/aeserialization/blob/eb68fe331bd476910394966b7f5ede7a74d37e35/src/aeser_chain_objects.erl#L39-L97}
- */
-export declare enum Tag {
-    Account = 10,
-    SignedTx = 11,
-    SpendTx = 12,
-    Oracle = 20,
-    OracleRegisterTx = 22,
-    OracleQueryTx = 23,
-    OracleResponseTx = 24,
-    OracleExtendTx = 25,
-    Name = 30,
-    NameClaimTx = 32,
-    NamePreclaimTx = 33,
-    NameUpdateTx = 34,
-    NameRevokeTx = 35,
-    NameTransferTx = 36,
-    Contract = 40,
-    ContractCall = 41,
-    ContractCreateTx = 42,
-    ContractCallTx = 43,
-    ChannelCreateTx = 50,
-    ChannelDepositTx = 51,
-    ChannelWithdrawTx = 52,
-    ChannelForceProgressTx = 521,
-    ChannelCloseMutualTx = 53,
-    ChannelCloseSoloTx = 54,
-    ChannelSlashTx = 55,
-    ChannelSettleTx = 56,
-    ChannelOffChainTx = 57,
-    ChannelOffChainUpdateTransfer = 570,
-    ChannelOffChainUpdateDeposit = 571,
-    ChannelOffChainUpdateWithdraw = 572,
-    ChannelOffChainUpdateCreateContract = 573,
-    ChannelOffChainUpdateCallContract = 574,
-    ChannelClientReconnectTx = 575,
-    Channel = 58,
-    ChannelSnapshotSoloTx = 59,
-    TreesPoi = 60,
-    StateTrees = 62,
-    Mtree = 63,
-    MtreeValue = 64,
-    ContractsMtree = 621,
-    CallsMtree = 622,
-    ChannelsMtree = 623,
-    NameserviceMtree = 624,
-    OraclesMtree = 625,
-    AccountsMtree = 626,
-    GaAttachTx = 80,
-    GaMetaTx = 81,
-    PayingForTx = 82,
-    GaMetaTxAuthData = 810
-}

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

@@ -1,20 +0,0 @@
-import { Encoded } from '../../../utils/encoder';
-import { DelegationTag } from './schema';
-import { DlgParams, DlgUnpacked } from './schema.generated';
-/**
- * Pack delegation
- * @category delegation signature
- * @param params - Params of delegation
- * @returns Encoded delegation
- */
-export declare function packDelegation(params: DlgParams): Encoded.Bytearray;
-/**
- * Unpack delegation
- * @category delegation signature
- * @param encoded - Encoded delegation
- * @param expectedTag - Expected delegation signature type
- * @returns Params of delegation
- */
-export declare function unpackDelegation<T extends DelegationTag>(encoded: Encoded.Bytearray, expectedTag?: T): DlgUnpacked & {
-    tag: T;
-};