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

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

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import coinAmount from './coin-amount';
-import { Int } from './u-int';
+import { Int } from '../constants';
 declare const _default: {
     /**
      * @param value - Deposit value in string format. Should be equal to '0'.

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

@@ -1,5 +1,7 @@
 /// <reference types="node" />
-export default function genEnumerationField<Enum extends number>(): {
-    serialize: (value: Enum) => Buffer;
-    deserialize: (value: Buffer) => Enum;
+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.2/tx/builder/field-types/fee.d.ts

@@ -1,17 +1,20 @@
 /// <reference types="node" />
 import BigNumber from 'bignumber.js';
-import { Tag } from '../constants';
+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(txType: Tag, buildTx: any): BigNumber;
+export declare function buildFee(builtTx: Encoded.Transaction, unpackTx: typeof unpackTxType, buildTx: typeof buildTxType): BigNumber;
 declare const _default: {
-    serializeAettos(_value: string | undefined, { txType, rebuildTx, _computingMinFee }: {
-        txType: Tag;
-        rebuildTx: (params: any) => any;
-        _computingMinFee?: string | undefined;
+    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("./u-int").Int | undefined, { denomination, ...options }: import("./coin-amount").Options): Buffer;
+    serialize(value: import("../constants").Int | undefined, { denomination, ...options }: import("./coin-amount").Options): Buffer;
     deserialize(value: Buffer): string;
 };
 export default _default;

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

@@ -1,9 +1,12 @@
 /// <reference types="node" />
 import { Tag } from '../constants';
+import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
 declare const _default: {
-    serialize(_value: number | undefined, { txType, rebuildTx, gasMax, _computingGasLimit, }: {
-        txType: Tag;
+    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;

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

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

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

@@ -1,45 +1,64 @@
 /// <reference types="node" />
 import _address from './address';
-import _addresses from './addresses';
+import _array from './array';
+import _encoded from './encoded';
+import _entry from './entry';
 import _enumeration from './enumeration';
-declare const field: {
-    serialize(value: string): Buffer;
-    deserialize(value: Buffer): string;
-};
-declare const uInt: {
-    serialize(value: import("./u-int").Int): Buffer;
-    deserialize(value: Buffer): string;
+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 shortUInt: {
-    serialize(value: number): Buffer;
-    deserialize(value: Buffer): number;
+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("./u-int").Int | undefined, { denomination, ...options }: import("./coin-amount").Options): Buffer;
+    serialize(value: import("../constants").Int | undefined, { denomination, ...options }: import("./coin-amount").Options): Buffer;
     deserialize(value: Buffer): string;
 };
-declare const address: typeof _address;
-declare const addresses: typeof _addresses;
+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("./u-int").Int | undefined, options: import("./coin-amount").Options): Buffer;
+    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, { txType, rebuildTx, _computingMinFee }: {
-        txType: import("../constants").Tag;
-        rebuildTx: (params: any) => any;
-        _computingMinFee?: string | undefined;
+    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("./u-int").Int | undefined, { denomination, ...options }: import("./coin-amount").Options): Buffer;
+    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, { txType, rebuildTx, gasMax, _computingGasLimit, }: {
-        txType: import("../constants").Tag;
+    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;
@@ -47,9 +66,10 @@ declare const gasLimit: {
 };
 declare const gasPrice: {
     serializeAettos(value?: string | undefined): string;
-    serialize(value: import("./u-int").Int | undefined, { denomination, ...options }: import("./coin-amount").Options): Buffer;
+    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`;
@@ -58,13 +78,13 @@ declare const nameFee: {
     serializeAettos(_value: string | undefined, txFields: {
         name: `${string}.chain`;
     }): string;
-    serialize(value: import("./u-int").Int | undefined, txFields: {
+    serialize(value: import("../constants").Int | undefined, txFields: {
         name: `${string}.chain`;
     } & import("./coin-amount").Options): Buffer;
     deserialize(value: Buffer): string;
 };
 declare const nameId: {
-    serialize(value: `nm_${string}` | `${string}.chain`): Buffer;
+    serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
     deserialize: (value: Buffer) => `nm_${string}`;
 };
 declare const pointers: {
@@ -78,8 +98,32 @@ declare const pointers: {
         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) => Buffer | Buffer[] | Buffer[][];
-    deserialize: (value: Buffer | Buffer[] | Buffer[][]) => any;
+    serialize: (value: any, options: any) => BinaryData;
+    deserialize: (value: BinaryData, options: any) => any;
 }
-export { field, uInt, shortUInt, coinAmount, address, addresses, deposit, enumeration, fee, gasLimit, gasPrice, name, nameFee, nameId, pointers, };
+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, };

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

@@ -0,0 +1,43 @@
+/// <reference types="node" />
+import { Tag } from '../constants';
+import { Encoded, Encoding } from '../../../utils/encoder';
+import type { unpackTx } from '..';
+type MPTreeBinary = [
+    Buffer,
+    Array<[
+        Buffer,
+        Buffer[]
+    ]>
+];
+declare class MPTree<E extends Encoding, T extends Tag> {
+    #private;
+    get isComplete(): boolean;
+    /**
+     * Deserialize Merkle Patricia Tree
+     * @param binary - Binary
+     * @param tag - Tag to use to decode value
+     * @param unpTx - Implementation of unpackTx use to decode values
+     * @returns Merkle Patricia Tree
+     */
+    constructor(binary: MPTreeBinary, encoding: E, tag: T, unpTx: typeof unpackTx);
+    isEqual(tree: MPTree<E, T>): boolean;
+    /**
+     * Serialize Merkle Patricia Tree
+     * @returns Binary
+     */
+    serialize(): MPTreeBinary;
+    /**
+     * Retrieve value from Merkle Patricia Tree
+     * @param key - The key of the element to retrieve
+     * @returns Value associated to the specified key
+     */
+    get(key: Encoded.Generic<E>): ReturnType<any> | undefined;
+    toObject(): Record<Encoded.Any, ReturnType<any>>;
+}
+export default function genMPTreeField<E extends Encoding, T extends Tag>(encoding: E, tag: T): {
+    serialize: (value: MPTree<E, T>) => MPTreeBinary;
+    deserialize: (value: MPTreeBinary, o: {
+        unpackTx: typeof unpackTx;
+    }) => MPTree<E, T>;
+};
+export {};

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

@@ -1,7 +1,6 @@
 /// <reference types="node" />
-import { Int } from './u-int';
 import coinAmount from './coin-amount';
-import { AensName } from '../constants';
+import { AensName, Int } from '../constants';
 declare const _default: {
     serializeAettos(_value: string | undefined, txFields: {
         name: AensName;

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

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

package/types-legacy/ts4.2/tx/builder/field-types/short-u-int-const.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+export default function genShortUIntConstField<Value extends number>(value: Value): {
+    serialize: (value?: Value) => Buffer;
+    deserialize: (value: Buffer) => Value;
+};

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

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

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

@@ -1,6 +1,5 @@
 /// <reference types="node" />
-import BigNumber from 'bignumber.js';
-export type Int = number | string | BigNumber;
+import { Int } from '../constants';
 declare const _default: {
     serialize(value: Int): Buffer;
     deserialize(value: Buffer): string;

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

@@ -1,23 +1,12 @@
 import { Encoded, Encoding } from '../../utils/encoder';
 import { AE_AMOUNT_FORMATS } from '../../utils/amount-formatter';
-import { RawTxObject, TxSchema, TxTypeSchemas } from './schema';
+import { RawTxObject, TxTypeSchemas } from './schema';
 import { Tag } from './constants';
-/**
- * @category transaction builder
- */
-export interface BuiltTx<Tx extends TxSchema, Prefix extends Encoding> {
-    tx: Encoded.Generic<Prefix>;
-    rlpEncoded: Uint8Array;
-    binary: Uint8Array;
-    txObject: RawTxObject<Tx>;
-}
 /**
  * Build transaction hash
  * @category transaction builder
- * @param _params - Object with tx params
- * @param type - Transaction type
+ * @param params - Object with tx params
  * @param options - options
- * @param options.excludeKeys - Array of keys to exclude for validation and build
  * @param options.denomination - Denomination of amounts
  * @param options.prefix - Prefix of transaction
  * @throws {@link InvalidTxParamsError}
@@ -26,22 +15,15 @@ export interface BuiltTx<Tx extends TxSchema, Prefix extends Encoding> {
  * @returns object.rlpEncoded rlp encoded transaction
  * @returns object.binary binary transaction
  */
-export declare function buildTx<TxType extends Tag, Prefix>(_params: Omit<TxTypeSchemas[TxType], 'tag' | 'VSN'> & {
-    VSN?: number;
-}, type: TxType, { excludeKeys, prefix, vsn, denomination, }?: {
-    excludeKeys?: string[];
-    prefix?: Encoding;
-    vsn?: number;
+export declare function buildTx<TxType extends Tag, E extends Encoding = Encoding.Transaction>(params: {
+    tag: TxType;
+    version?: number;
+} & Omit<TxTypeSchemas[TxType], 'tag' | 'version'> & (TxType extends Tag.ContractCreateTx | Tag.ContractCallTx | Tag.ChannelOffChainUpdateCallContract | Tag.GaAttachTx | Tag.GaMetaTx ? {
+    gasMax?: number;
+} : {}), { prefix, denomination, }?: {
+    prefix?: E;
     denomination?: AE_AMOUNT_FORMATS;
-}): BuiltTx<TxSchema, Prefix extends Encoding ? Prefix : Encoding.Transaction>;
-/**
- * @category transaction builder
- */
-export interface TxUnpacked<Tx extends TxSchema> {
-    txType: Tag;
-    tx: RawTxObject<Tx>;
-    rlpEncoded: Uint8Array;
-}
+}): Encoded.Generic<E>;
 /**
  * Unpack transaction hash
  * @category transaction builder
@@ -51,7 +33,7 @@ export interface TxUnpacked<Tx extends TxSchema> {
  * @returns object.tx Object with transaction param's
  * @returns object.txType Transaction type
  */
-export declare function unpackTx<TxType extends Tag>(encodedTx: Encoded.Transaction | Encoded.Poi, txType?: TxType): TxUnpacked<TxTypeSchemas[TxType]>;
+export declare function unpackTx<TxType extends Tag>(encodedTx: Encoded.Transaction | Encoded.Poi, txType?: TxType): RawTxObject<TxTypeSchemas[TxType]>;
 /**
  * Build a transaction hash
  * @category transaction builder