@aeternity/aepp-sdk 13.2.2 → 13.3.0

package/types-legacy/ts4.5/channel/internal.d.ts

@@ -29,41 +29,137 @@ interface SignOptions {
 }
 export type SignTxWithTag = (tag: string, tx: Encoded.Transaction, options?: SignOptions) => (Promise<Encoded.Transaction>);
 export type SignTx = (tx: Encoded.Transaction, options?: SignOptions) => (Promise<Encoded.Transaction | number | null>);
+/**
+ * @see {@link https://github.com/aeternity/protocol/blob/6734de2e4c7cce7e5e626caa8305fb535785131d/node/api/channels_api_usage.md#channel-establishing-parameters}
+ */
 export interface ChannelOptions {
     existingFsmId?: Encoded.Bytearray;
+    /**
+     * Channel url (for example: "ws://localhost:3001")
+     */
     url: string;
     /**
-     * @see {@link https://github.com/aeternity/protocol/blob/6734de2e4c7cce7e5e626caa8305fb535785131d/node/api/channels_api_usage.md#channel-establishing-parameters}
+     * Initiator's public key
      */
     initiatorId: Encoded.AccountAddress;
+    /**
+     * Responder's public key
+     */
     responderId: Encoded.AccountAddress;
+    /**
+     * Amount of blocks for disputing a solo close
+     */
     lockPeriod: number;
+    /**
+     * Initial deposit in favour of the responder by the initiator
+     */
     pushAmount: number;
-    initiatorAmount: BigNumber;
-    responderAmount: BigNumber;
+    /**
+     * Amount of coins the initiator has committed to the channel
+     */
+    initiatorAmount: BigNumber | number;
+    /**
+     * Amount of coins the responder has committed to the channel
+     */
+    responderAmount: BigNumber | number;
+    /**
+     * The minimum amount both peers need to maintain
+     */
     channelReserve?: BigNumber | number;
+    /**
+     * Minimum block height to include the channel_create_tx
+     */
     ttl?: number;
+    /**
+     * Host of the responder's node
+     */
     host: string;
+    /**
+     * The port of the responders node
+     */
     port: number;
+    /**
+     * Participant role
+     */
     role: 'initiator' | 'responder';
+    /**
+     * How to calculate minimum depth (default: txfee)
+     */
     minimumDepthStrategy?: 'txfee' | 'plain';
+    /**
+     * The minimum amount of blocks to be mined
+     */
     minimumDepth?: number;
+    /**
+     * The fee to be used for the channel open transaction
+     */
     fee?: BigNumber | number;
+    /**
+     * Used for the fee computation of the channel open transaction
+     */
     gasPrice?: BigNumber | number;
     signedTx?: string;
+    /**
+     * Existing channel id (required if reestablishing a channel)
+     */
     existingChannelId?: string;
+    /**
+     * Offchain transaction (required if reestablishing a channel)
+     */
     offChainTx?: string;
     reconnectTx?: string;
+    /**
+     * The time waiting for a new event to be initiated (default: 600000)
+     */
     timeoutIdle?: number;
+    /**
+     * The time waiting for the initiator to produce the create channel transaction after the noise
+     * session had been established (default: 120000)
+     */
     timeoutFundingCreate?: number;
+    /**
+     * The time frame the other client has to sign an off-chain update after our client had initiated
+     * and signed it. This applies only for double signed on-chain intended updates: channel create
+     * transaction, deposit, withdrawal and etc. (default: 120000)
+     */
     timeoutFundingSign?: number;
+    /**
+     * The time frame the other client has to confirm an on-chain transaction reaching maturity
+     * (passing minimum depth) after the local node has detected this. This applies only for double
+     * signed on-chain intended updates: channel create transaction, deposit, withdrawal and etc.
+     * (default: 360000)
+     */
     timeoutFundingLock?: number;
+    /**
+     * The time frame the client has to return a signed off-chain update or to decline it.
+     * This applies for all off-chain updates (default: 500000)
+     */
     timeoutSign?: number;
+    /**
+     * The time frame the other client has to react to an event. This applies for all off-chain
+     * updates that are not meant to land on-chain, as well as some special cases: opening a noise
+     * connection, mutual closing acknowledgement and reestablishing an existing channel
+     * (default: 120000)
+     */
     timeoutAccept?: number;
+    /**
+     * the time frame the responder has to accept an incoming noise session.
+     * Applicable only for initiator (default: timeout_accept's value)
+     */
     timeoutInitialized?: number;
+    /**
+     * The time frame the initiator has to start an outgoing noise session to the responder's node.
+     * Applicable only for responder (default: timeout_idle's value)
+     */
     timeoutAwaitingOpen?: number;
     statePassword?: string;
-    debug: boolean;
+    /**
+     * Log websocket communication and state changes
+     */
+    debug?: boolean;
+    /**
+     * Function which verifies and signs transactions
+     */
     sign: SignTxWithTag;
     offchainTx?: string;
 }
@@ -76,6 +172,9 @@ export interface ChannelState {
     reject: (e: BaseError) => void;
     sign: SignTx;
     handler?: ChannelHandler;
+    /**
+     * Called when transaction has been posted on chain
+     */
     onOnChainTx?: (tx: Encoded.Transaction) => void;
     onOwnWithdrawLocked?: () => void;
     onWithdrawLocked?: () => void;
@@ -114,7 +213,7 @@ export declare function emit<E extends keyof ChannelEvents>(channel: Channel, ..
     ...Parameters<ChannelEvents[E]>
 ]): void;
 export type ChannelStatus = 'connecting' | 'connected' | 'accepted' | 'halfSigned' | 'signed' | 'open' | 'closing' | 'closed' | 'died' | 'disconnected';
-export declare function changeStatus(channel: Channel, newStatus: ChannelStatus): void;
+export declare function changeStatus(channel: Channel, newStatus: ChannelStatus, debug?: unknown): void;
 export declare function changeState(channel: Channel, newState: Encoded.Transaction | ''): void;
 export declare function notify(channel: Channel, method: string, params?: object): void;
 export declare function enqueueAction(channel: Channel, guard: ChannelAction['guard'], action: () => {

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

@@ -11,7 +11,8 @@ import { Encoded } from '../utils/encoder';
 import { ContractCallObject as NodeContractCallObject, Event as NodeEvent } from '../apis/node';
 import CompilerBase, { Aci } from './compiler/Base';
 import Node, { TransformNodeType } from '../Node';
-import { txDryRun, sendTransaction, SendTransactionOptions } from '../chain';
+import { txDryRun } from '../chain';
+import { sendTransaction, SendTransactionOptions } from '../send-transaction';
 import AccountBase from '../account/Base';
 import { TxUnpacked } from '../tx/builder/schema.generated';
 interface Event extends NodeEvent {
@@ -137,12 +138,19 @@ declare class Contract<M extends ContractMethodsBase> {
     _name: string;
     _calldata: Calldata;
     $options: Omit<ConstructorParameters<typeof Contract>[0], 'aci'>;
+    /**
+     * @param options - Options
+     */
     constructor({ aci, ...otherOptions }: {
         onCompiler?: CompilerBase;
         onNode: Node;
         bytecode?: Encoded.ContractBytearray;
         aci: Aci;
         address?: Encoded.ContractAddress;
+        /**
+         * Supported only in Ceres
+         */
+        name?: AensName;
         sourceCodePath?: Parameters<CompilerBase['compile']>[0];
         sourceCode?: Parameters<CompilerBase['compileBySourceCode']>[0];
         fileSystem?: Parameters<CompilerBase['compileBySourceCode']>[1];

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

@@ -16,6 +16,18 @@ export type Aci = Array<{
         typedefs: any[];
     };
 }>;
+export type CompileResult = Promise<{
+    bytecode: Encoded.ContractBytearray;
+    aci: Aci;
+    warnings: Array<{
+        message: string;
+        pos: {
+            file?: string;
+            line: number;
+            col: number;
+        };
+    }>;
+}>;
 /**
  * A base class for all compiler implementations
  */
@@ -26,10 +38,7 @@ export default abstract class CompilerBase {
      * @param path - Path to contract source code
      * @returns ACI and bytecode
      */
-    abstract compile(path: string): Promise<{
-        bytecode: Encoded.ContractBytearray;
-        aci: Aci;
-    }>;
+    abstract compile(path: string): CompileResult;
     /**
      * Compile contract by contract's source code
      * @param sourceCode - Contract source code as string
@@ -43,10 +52,7 @@ export default abstract class CompilerBase {
      * ```
      * @returns ACI and bytecode
      */
-    abstract compileBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): Promise<{
-        bytecode: Encoded.ContractBytearray;
-        aci: Aci;
-    }>;
+    abstract compileBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): CompileResult;
     /**
      * Generate contract's ACI by contract's path
      * Available only in Node.js

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

@@ -1,8 +1,10 @@
-import CompilerBase, { Aci } from './Base';
+import CompilerBase, { Aci, CompileResult } from './Base';
 import { Encoded } from '../../utils/encoder';
+export declare const getPackagePath: () => string;
 /**
  * A wrapper around aesophia_cli, available only in Node.js.
  * Requires Erlang installed, assumes that `escript` is available in PATH.
+ * @category contract
  */
 export default class CompilerCli extends CompilerBase {
     #private;
@@ -14,14 +16,8 @@ export default class CompilerCli extends CompilerBase {
     constructor(compilerPath?: string, { ignoreVersion }?: {
         ignoreVersion?: boolean;
     });
-    compile(path: string): Promise<{
-        bytecode: Encoded.ContractBytearray;
-        aci: Aci;
-    }>;
-    compileBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): Promise<{
-        bytecode: Encoded.ContractBytearray;
-        aci: Aci;
-    }>;
+    compile(path: string): CompileResult;
+    compileBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): CompileResult;
     generateAci(path: string): Promise<Aci>;
     generateAciBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): Promise<Aci>;
     validate(bytecode: Encoded.ContractBytearray, path: string): Promise<boolean>;

package/types-legacy/ts4.5/contract/compiler/Cli8.d.ts

@@ -0,0 +1,13 @@
+import CompilerCli from './Cli';
+/**
+ * @category contract
+ */
+export default class CompilerCli8 extends CompilerCli {
+    /**
+     * @param options - Options
+     * @param options.ignoreVersion - Don't ensure that the compiler is supported
+     */
+    constructor({ ignoreVersion }?: {
+        ignoreVersion?: boolean;
+    });
+}

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

@@ -1,5 +1,5 @@
 import { Compiler as CompilerApi } from '../../apis/compiler';
-import CompilerBase, { Aci } from './Base';
+import CompilerBase, { Aci, CompileResult } from './Base';
 import { Encoded } from '../../utils/encoder';
 /**
  * Contract Compiler over HTTP
@@ -18,14 +18,8 @@ export default class CompilerHttp extends CompilerBase {
     constructor(compilerUrl: string, { ignoreVersion }?: {
         ignoreVersion?: boolean;
     });
-    compileBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): Promise<{
-        bytecode: Encoded.ContractBytearray;
-        aci: Aci;
-    }>;
-    compile(path: string): Promise<{
-        bytecode: Encoded.ContractBytearray;
-        aci: Aci;
-    }>;
+    compileBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): CompileResult;
+    compile(path: string): CompileResult;
     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>;

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

@@ -1,5 +1,5 @@
 import HttpBrowser from './Http';
-import { Aci } from './Base';
+import { Aci, CompileResult } from './Base';
 import { Encoded } from '../../utils/encoder';
 /**
  * Contract Compiler over HTTP for Nodejs
@@ -9,10 +9,7 @@ import { Encoded } from '../../utils/encoder';
  * @example CompilerHttpNode('COMPILER_URL')
  */
 export default class CompilerHttpNode extends HttpBrowser {
-    compile(path: string): Promise<{
-        bytecode: Encoded.ContractBytearray;
-        aci: Aci;
-    }>;
+    compile(path: string): CompileResult;
     generateAci(path: string): Promise<Aci>;
     validate(bytecode: Encoded.ContractBytearray, path: string): Promise<boolean>;
 }

package/types-legacy/ts4.5/contract/delegation-signature.d.ts

@@ -37,8 +37,9 @@ import Node from '../Node';
  *   .createDelegationSignature(contractAddress, [oracleQueryId], { onAccount, omitAddress: true })
  * ```
  */
-export default function createDelegationSignature(contractAddress: Encoded.ContractAddress, ids: Array<Encoded.Any | AensName>, { onAccount, omitAddress, ...options }: {
+export default function createDelegationSignature(contractAddress: Encoded.ContractAddress, ids: Array<Encoded.Any | AensName>, { onAccount, omitAddress, isOracle, ...options }: {
     omitAddress?: boolean;
     onAccount: AccountBase;
+    isOracle?: boolean;
     onNode: Node;
 }): Promise<Uint8Array>;

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

@@ -8,13 +8,12 @@ import { Encoded } from '../utils/encoder';
 import AccountBase from '../account/Base';
 import Contract from './Contract';
 import Node from '../Node';
-import { SendTransactionOptions } from '../chain';
+import { SendTransactionOptions } from '../send-transaction';
 import CompilerBase from './compiler/Base';
 /**
  * Convert current account to GA
  * @category contract
  * @param authFnName - Authorization function name
- * @param sourceCode - Auth contract source code
  * @param args - init arguments
  * @param options - Options
  * @returns General Account Object

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

@@ -1,6 +1,7 @@
 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
@@ -22,3 +23,40 @@ export declare function encodeFateValue(value: unknown, aci: AciValue): Encoded.
  * @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,13 +1,18 @@
-export { _getPollInterval, InvalidTxError, getHeight, poll, awaitHeight, waitForTxConfirm, sendTransaction, getAccount, getBalance, getCurrentGeneration, getGeneration, getMicroBlockTransactions, getKeyBlock, getMicroBlockHeader, txDryRun, getContractByteCode, getContract, getName, resolveName, } from './chain';
+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, 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 { 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, ORACLE_TTL, QUERY_TTL, RESPONSE_TTL, DRY_RUN_ACCOUNT, CallReturnType, } from './tx/builder/schema';
+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';
@@ -42,5 +47,5 @@ export { MESSAGE_DIRECTION, WALLET_TYPE, SUBSCRIPTION_TYPES, METHODS, RPC_STATUS
 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, 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, } from './deprecated';
+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,4 +1,5 @@
 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

@@ -6,10 +6,10 @@
  * repository.
  */
 import { BuildTxOptions } from './tx/builder';
-import { ORACLE_TTL_TYPES } from './tx/builder/schema';
 import { Tag } from './tx/builder/constants';
 import { Encoded } from './utils/encoder';
-import { _getPollInterval, sendTransaction, SendTransactionOptions } from './chain';
+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'];
@@ -62,37 +62,20 @@ interface GetQueryObjectReturnType extends Awaited<ReturnType<Node['getOracleQue
  * @param oracleId - Oracle public key
  * @param query - Oracle query object
  * @param options - Options object
- * @param options.queryTtl - queryTtl Oracle query time to leave
- * @param options.responseTtl - queryFee Oracle query response time to leave
- * @param options.queryFee - queryFee Oracle query fee
- * @param options.fee - fee Transaction fee
- * @param options.ttl - Transaction time to leave
  * @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' | 'queryTtlType' | 'queryTtlValue' | 'responseTtlType' | 'responseTtlValue'> & {
-    queryTtlType?: ORACLE_TTL_TYPES;
-    queryTtlValue?: number;
-    responseTtlType?: ORACLE_TTL_TYPES;
-    responseTtlValue?: number;
-};
+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
- * @param options.fee - fee Transaction fee
- * @param options.ttl - Transaction time to leave
- * @param options.oracleTtlType - Oracle time to leave for extend
- * @param options.oracleTtlValue - Oracle time to leave for extend
  * @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, 'oracleTtlType' | 'oracleTtlValue' | 'callerId' | 'oracleId'> & {
-    oracleTtlType?: ORACLE_TTL_TYPES;
-    oracleTtlValue?: number;
-};
+type ExtendOracleTtlOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleExtendTx, 'callerId' | 'oracleId'>;
 interface ExtendOracleTtlOptions extends ExtendOracleTtlOptionsType {
 }
 /**
@@ -101,16 +84,10 @@ interface ExtendOracleTtlOptions extends ExtendOracleTtlOptionsType {
  * @param queryId - Oracle query id
  * @param response - Oracle query response
  * @param options - Options object
- * @param options.responseTtl - responseTtl Query response time to leave
- * @param options.fee - Transaction fee
- * @param options.ttl - Transaction time to leave
  * @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' | 'responseTtlType' | 'responseTtlValue'> & {
-    responseTtlType?: ORACLE_TTL_TYPES;
-    responseTtlValue?: number;
-};
+type RespondToQueryOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleResponseTx, 'callerId' | 'oracleId' | 'queryId' | 'response'>;
 interface RespondToQueryOptions extends RespondToQueryOptionsType {
 }
 /**
@@ -139,18 +116,10 @@ interface GetOracleObjectReturnType extends Awaited<ReturnType<Node['getOracleBy
  * @param queryFormat - Format of query
  * @param responseFormat - Format of query response
  * @param options - Options
- * @param options.queryFee - Oracle query Fee
- * @param options - Options object
- * @param options.abiVersion - Always 0 (do not use virtual machine)
- * @param options.fee - Transaction fee
- * @param options.ttl - Transaction time to leave
  * @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' | 'oracleTtlType' | 'oracleTtlValue'> & {
-    oracleTtlType?: ORACLE_TTL_TYPES;
-    oracleTtlValue?: number;
-};
+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

@@ -0,0 +1,53 @@
+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,4 +1,5 @@
-import { sendTransaction, resolveName, SendTransactionOptions } from './chain';
+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';
@@ -11,7 +12,7 @@ import AccountBase from './account/Base';
  * @param options - Options
  * @returns Transaction
  */
-export declare function spend(amount: number | string, recipientIdOrName: Encoded.AccountAddress | AensName, options: SpendOptions): ReturnType<typeof sendTransaction>;
+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;
@@ -35,7 +36,7 @@ interface SpendOptions extends SpendOptionsType {
  * ```
  */
 export declare function transferFunds(fraction: number | string, // TODO: accept only number
-recipientIdOrName: AensName | Encoded.AccountAddress, options: TransferFundsOptions): ReturnType<typeof sendTransaction>;
+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;

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

@@ -0,0 +1,32 @@
+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 {};