@aeternity/aepp-sdk 12.1.3 → 13.0.0-alpha.1

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

@@ -0,0 +1,161 @@
+/**
+ * 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 BigNumber from 'bignumber.js';
+import { send, SendOptions } from './spend';
+import { ORACLE_TTL_TYPES } from './tx/builder/schema';
+import { Tag } from './tx/builder/constants';
+import { Encoded } from './utils/encoder';
+import { _getPollInterval } from './chain';
+import { BuildTxOptions } from './tx';
+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: (queries: OracleQueries) => void, { interval, onNode, ...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, onNode, ...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>[3]) => 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
+ * @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 send>> & Awaited<ReturnType<typeof getQueryObject>>>;
+type PostQueryToOracleOptionsType = Parameters<typeof send>[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;
+};
+interface PostQueryToOracleOptions extends PostQueryToOracleOptionsType {
+}
+/**
+ * Extend oracle ttl
+ * @category oracle
+ * @param oracleId - Oracle public key
+ * @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(oracleId: Encoded.OracleAddress, options: ExtendOracleTtlOptions): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>>;
+type ExtendOracleTtlOptionsType = SendOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleExtendTx, 'oracleTtlType' | 'oracleTtlValue' | 'callerId' | 'oracleId'> & {
+    oracleTtlType?: ORACLE_TTL_TYPES;
+    oracleTtlValue?: number;
+};
+interface ExtendOracleTtlOptions extends ExtendOracleTtlOptionsType {
+}
+/**
+ * Extend oracle ttl
+ * @category oracle
+ * @param oracleId - Oracle public key
+ * @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(oracleId: Encoded.OracleAddress, queryId: Encoded.OracleQueryId, response: string, options: RespondToQueryOptions): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>>;
+type RespondToQueryOptionsType = SendOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleResponseTx, 'callerId' | 'oracleId' | 'queryId' | 'response' | 'responseTtlType' | 'responseTtlValue'> & {
+    responseTtlType?: ORACLE_TTL_TYPES;
+    responseTtlValue?: number;
+};
+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
+ * @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 send>> & Awaited<ReturnType<typeof getOracleObject>>>;
+type RegisterOracleOptionsType = SendOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleRegisterTx, 'accountId' | 'queryFormat' | 'responseFormat' | 'queryFee' | 'oracleTtlType' | 'oracleTtlValue'> & {
+    queryFee?: number | string | BigNumber;
+    oracleTtlType?: ORACLE_TTL_TYPES;
+    oracleTtlValue?: number;
+};
+interface RegisterOracleOptions extends RegisterOracleOptionsType {
+}
+export {};

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

@@ -0,0 +1,62 @@
+import { sendTransaction, resolveName } from './chain';
+import { BuildTxOptions } from './tx';
+import { Encoded } from './utils/encoder';
+import { Tag, AensName } from './tx/builder/constants';
+import AccountBase from './account/Base';
+/**
+ * Sign and post a transaction to the chain
+ * @category chain
+ * @param tx - Transaction
+ * @param options - Options
+ * @param options.verify - Verify transaction before broadcast, throw error if not
+ * valid
+ * @returns Transaction
+ */
+export declare function send(tx: Encoded.Transaction, options: SendOptions): Promise<SendReturnType>;
+type SendOptionsType = Parameters<AccountBase['signTransaction']>[1] & Parameters<typeof sendTransaction>[1] & {
+    onAccount: AccountBase;
+};
+export interface SendOptions extends SendOptionsType {
+}
+interface SendReturnType extends Awaited<ReturnType<typeof sendTransaction>> {
+}
+/**
+ * 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 | AensName, options: SpendOptions): ReturnType<typeof send>;
+type SpendOptionsType = BuildTxOptions<Tag.SpendTx, 'senderId' | 'recipientId' | 'amount'> & Parameters<typeof resolveName>[2] & {
+    onAccount: AccountBase;
+} & SendOptions;
+interface SpendOptions extends SpendOptionsType {
+}
+/**
+ * Send a fraction of coin balance to another account
+ * @category chain
+ * @param fraction - Fraction of balance to spend (between 0 and 1)
+ * @param recipientIdOrName - Address or name of recipient account
+ * @param options - Options
+ * @returns Transaction
+ */
+export declare function transferFunds(fraction: number | string, recipientIdOrName: AensName | Encoded.AccountAddress, options: TransferFundsOptions): ReturnType<typeof send>;
+type TransferFundsOptionsType = BuildTxOptions<Tag.SpendTx, 'senderId' | 'recipientId' | 'amount'> & Parameters<typeof resolveName>[2] & {
+    onAccount: AccountBase;
+} & SendOptions;
+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 send>;
+interface PayForTransactionOptions extends BuildTxOptions<Tag.PayingForTx, 'payerId' | 'tx'>, SendOptions {
+    onAccount: AccountBase;
+}
+export {};

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

@@ -0,0 +1,98 @@
+import BigNumber from 'bignumber.js';
+export declare const MAX_AUTH_FUN_GAS = 50000;
+export type Int = number | string | BigNumber;
+export type AensName = `${string}.chain`;
+export declare const NAME_TTL = 180000;
+export declare const NAME_MAX_TTL = 36000;
+export declare const NAME_MAX_CLIENT_TTL = 84600;
+export declare const CLIENT_TTL = 84600;
+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_MAX_LENGTH = 12;
+export declare const NAME_BID_RANGES: {
+    [k: string]: BigNumber;
+};
+export declare enum ConsensusProtocolVersion {
+    Iris = 5
+}
+/**
+ * @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
+}
+/**
+ * @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
+}

package/types-legacy/ts4.5/tx/builder/field-types/abi-version.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { Tag, ConsensusProtocolVersion, AbiVersion } from '../constants';
+declare const _default: {
+    serialize(value: AbiVersion | undefined, { tag, consensusProtocolVersion }: {
+        tag: Tag;
+        consensusProtocolVersion: ConsensusProtocolVersion;
+    }): Buffer;
+    deserialize(buffer: Buffer): AbiVersion;
+};
+export default _default;

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

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import { Encoded } from '../../../utils/encoder';
+/**
+ * Map of prefix to ID tag constant
+ * @see {@link https://github.com/aeternity/protocol/blob/master/serializations.md#the-id-type}
+ * @see {@link https://github.com/aeternity/aeserialization/blob/eb68fe331bd476910394966b7f5ede7a74d37e35/src/aeser_id.erl#L97-L102}
+ * @see {@link https://github.com/aeternity/aeserialization/blob/eb68fe331bd476910394966b7f5ede7a74d37e35/src/aeser_api_encoder.erl#L163-L168}
+ */
+export declare const idTagToEncoding: readonly [
+    Encoded.Encoding.AccountAddress,
+    Encoded.Encoding.Name,
+    Encoded.Encoding.Commitment,
+    Encoded.Encoding.OracleAddress,
+    Encoded.Encoding.ContractAddress,
+    Encoded.Encoding.Channel
+];
+export type AddressEncodings = typeof idTagToEncoding[number];
+export default function genAddressField<Encoding extends AddressEncodings>(...encodings: Encoding[]): {
+    serialize: (value: Encoded.Generic<Encoding>) => Buffer;
+    deserialize: (value: Buffer) => Encoded.Generic<Encoding>;
+};

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

@@ -0,0 +1,7 @@
+export default function genArrayField<Input, Output, Binary>(itemHandler: {
+    serialize: (value: Input, params: unknown) => Binary;
+    deserialize: (value: Binary, params: unknown) => Output;
+}): {
+    serialize: (value: Input[], params: unknown) => Binary[];
+    deserialize: (value: Binary[], params: unknown) => Output[];
+};

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

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+declare const _default: {
+    serialize(value: boolean): Buffer;
+    deserialize(buffer: Buffer): boolean;
+};
+export default _default;

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

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import { Int } from '../constants';
+import { AE_AMOUNT_FORMATS } from '../../../utils/amount-formatter';
+export interface Options {
+    denomination?: AE_AMOUNT_FORMATS;
+}
+declare const _default: {
+    serializeAettos(value: string | undefined): string;
+    serialize(value: Int | undefined, { denomination, ...options }: Options): Buffer;
+    deserialize(value: Buffer): string;
+};
+export default _default;

package/types-legacy/ts4.5/tx/builder/field-types/ct-version.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="node" />
+import { ConsensusProtocolVersion, VmVersion, AbiVersion } from '../constants';
+export declare const ProtocolToVmAbi: {
+    readonly 5: {
+        readonly 'contract-create': {
+            readonly vmVersion: readonly [
+                VmVersion.Fate2
+            ];
+            readonly abiVersion: readonly [
+                AbiVersion.Fate
+            ];
+        };
+        readonly 'contract-call': {
+            readonly vmVersion: readonly [
+            ];
+            readonly abiVersion: readonly [
+                AbiVersion.Fate,
+                AbiVersion.Sophia
+            ];
+        };
+        readonly 'oracle-call': {
+            readonly vmVersion: readonly [
+            ];
+            readonly abiVersion: readonly [
+                AbiVersion.NoAbi,
+                AbiVersion.Sophia
+            ];
+        };
+    };
+};
+export interface CtVersion {
+    vmVersion: VmVersion;
+    abiVersion: AbiVersion;
+}
+export declare function getProtocolDetails(protocolVersion: ConsensusProtocolVersion, type: 'contract-create' | 'contract-call' | 'oracle-call'): CtVersion;
+declare const _default: {
+    serialize(value: CtVersion | undefined, { consensusProtocolVersion }: {
+        consensusProtocolVersion: ConsensusProtocolVersion;
+    }): Buffer;
+    deserialize(buffer: Buffer): CtVersion;
+};
+export default _default;

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

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import coinAmount from './coin-amount';
+import { Int } from '../constants';
+declare const _default: {
+    /**
+     * @param value - Deposit value in string format. Should be equal to '0'.
+     * @param options - Options
+     * @returns Deposit value Buffer.
+     */
+    serialize(value: Int | undefined, options: Parameters<(typeof coinAmount)['serialize']>[1]): Buffer;
+    serializeAettos(value: string | undefined): string;
+    deserialize(value: Buffer): string;
+};
+export default _default;

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

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import { Encoded, Encoding } from '../../../utils/encoder';
+export default function genEncodedField<E extends Encoding, Optional extends boolean = false>(encoding: E, optional?: Optional): {
+    serialize: Optional extends true ? (value?: Encoded.Generic<E>) => Buffer : (value: Encoded.Generic<E>) => Buffer;
+    deserialize: (value: Buffer) => Encoded.Generic<Encoding>;
+};

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

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { Tag } from '../constants';
+import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
+export default function genEntryField<T extends Tag = Tag>(tag?: T): {
+    serialize: (value: any, options: {
+        buildTx: typeof buildTxType;
+    }) => Buffer;
+    deserialize: (value: Buffer, options: {
+        unpackTx: typeof unpackTxType;
+    }) => any;
+};

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

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+export default function genEnumerationField<Enum extends {
+    [key: string]: number | string;
+}>(enm: Enum): {
+    serialize: (value: Enum[keyof Enum]) => Buffer;
+    deserialize: (value: Buffer) => Enum[keyof Enum];
+};

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

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import BigNumber from 'bignumber.js';
+import { Encoded } from '../../../utils/encoder';
+import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
+/**
+ * Calculate fee based on tx type and params
+ */
+export declare function buildFee(builtTx: Encoded.Transaction, unpackTx: typeof unpackTxType, buildTx: typeof buildTxType): BigNumber;
+declare const _default: {
+    serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, _pickBiggerFee, }: {
+        rebuildTx: (params: any) => Encoded.Transaction;
+        unpackTx: typeof unpackTxType;
+        buildTx: typeof buildTxType;
+        _computingMinFee?: BigNumber | undefined;
+        _pickBiggerFee?: boolean | undefined;
+    }): string;
+    serialize(value: import("../constants").Int | undefined, { denomination, ...options }: import("./coin-amount").Options): Buffer;
+    deserialize(value: Buffer): string;
+};
+export default _default;

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

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+declare const _default: {
+    serialize(value: string): Buffer;
+    deserialize(value: Buffer): string;
+};
+export default _default;

package/types-legacy/ts4.5/tx/builder/field-types/gas-limit.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { Tag } from '../constants';
+import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
+declare const _default: {
+    serialize(_value: number | undefined, { tag, rebuildTx, unpackTx, buildTx, gasMax, _computingGasLimit, }: {
+        tag: Tag;
+        rebuildTx: (params: any) => any;
+        unpackTx: typeof unpackTxType;
+        buildTx: typeof buildTxType;
+        gasMax: number;
+        _computingGasLimit?: number | undefined;
+    }): Buffer;
+    deserialize(value: Buffer): number;
+};
+export default _default;

package/types-legacy/ts4.5/tx/builder/field-types/gas-price.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+declare const _default: {
+    serializeAettos(value?: string | undefined): string;
+    serialize(value: import("../constants").Int | undefined, { denomination, ...options }: import("./coin-amount").Options): Buffer;
+    deserialize(value: Buffer): string;
+};
+export default _default;

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

@@ -0,0 +1,129 @@
+/// <reference types="node" />
+import _address from './address';
+import _array from './array';
+import _encoded from './encoded';
+import _entry from './entry';
+import _enumeration from './enumeration';
+import _mptree from './mptree';
+import _shortUIntConst from './short-u-int-const';
+declare const abiVersion: {
+    serialize(value: import("../constants").AbiVersion | undefined, { tag, consensusProtocolVersion }: {
+        tag: import("../constants").Tag;
+        consensusProtocolVersion: import("../constants").ConsensusProtocolVersion;
+    }): Buffer;
+    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, { denomination, ...options }: import("./coin-amount").Options): Buffer;
+    deserialize(value: Buffer): string;
+};
+declare const ctVersion: {
+    serialize(value: import("./ct-version").CtVersion | undefined, { consensusProtocolVersion }: {
+        consensusProtocolVersion: import("../constants").ConsensusProtocolVersion;
+    }): Buffer;
+    deserialize(buffer: Buffer): import("./ct-version").CtVersion;
+};
+declare const deposit: {
+    serialize(value: import("../constants").Int | undefined, options: import("./coin-amount").Options): 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, { denomination, ...options }: import("./coin-amount").Options): 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, gasMax, _computingGasLimit, }: {
+        tag: import("../constants").Tag;
+        rebuildTx: (params: any) => any;
+        unpackTx: typeof import("..").unpackTx;
+        buildTx: typeof import("..").buildTx;
+        gasMax: number;
+        _computingGasLimit?: number | undefined;
+    }): Buffer;
+    deserialize(value: Buffer): number;
+};
+declare const gasPrice: {
+    serializeAettos(value?: string | undefined): string;
+    serialize(value: import("../constants").Int | undefined, { denomination, ...options }: import("./coin-amount").Options): Buffer;
+    deserialize(value: Buffer): string;
+};
+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`;
+    } & import("./coin-amount").Options): Buffer;
+    deserialize(value: Buffer): string;
+};
+declare const nameId: {
+    serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
+    deserialize: (value: Buffer) => `nm_${string}`;
+};
+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 uInt: {
+    serialize(value: import("../constants").Int): Buffer;
+    deserialize(value: Buffer): string;
+};
+export type BinaryData = Buffer | Buffer[] | Buffer[][] | Array<[
+    Buffer,
+    Array<[
+        Buffer,
+        Buffer[]
+    ]>
+]>;
+export interface Field {
+    serialize: (value: any, options: any) => BinaryData;
+    deserialize: (value: BinaryData, options: any) => any;
+}
+export { abiVersion, address, array, boolean, coinAmount, ctVersion, deposit, encoded, entry, enumeration, fee, field, gasLimit, gasPrice, mptree, name, nameFee, nameId, pointers, raw, shortUInt, shortUIntConst, string, uInt, };