@aeternity/aepp-sdk 13.2.1 → 13.3.0

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

@@ -1,22 +1,30 @@
 /// <reference types="node" />
 import BigNumber from 'bignumber.js';
+import { Int } from '../constants';
+import coinAmount from './coin-amount';
 import { Encoded } from '../../../utils/encoder';
 import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
+import Node from '../../../Node';
 /**
- * Calculate fee based on tx type and params
+ * Calculate gas based on tx type and params
  */
-export declare function buildFee(builtTx: Encoded.Transaction, unpackTx: typeof unpackTxType, buildTx: typeof buildTxType): BigNumber;
+export declare function buildGas(builtTx: Encoded.Transaction, unpackTx: typeof unpackTxType, buildTx: typeof buildTxType): number;
+export interface SerializeAettosParams {
+    rebuildTx: (params: any) => Encoded.Transaction;
+    unpackTx: typeof unpackTxType;
+    buildTx: typeof buildTxType;
+    _computingMinFee?: 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;
+    prepare(value: Int | undefined, params: {}, { onNode }: {
+        onNode?: Node | undefined;
+    }): Promise<Int | undefined>;
+    serializeAettos(_value: string | undefined, { rebuildTx, unpackTx, buildTx, _computingMinFee, }: SerializeAettosParams, { _canIncreaseFee }: {
+        _canIncreaseFee?: boolean | undefined;
     }): string;
-    serialize(value: import("../constants").Int | undefined, params: {}, { denomination }: {
-        denomination?: import("../../..").AE_AMOUNT_FORMATS | undefined;
-    }): Buffer;
+    serialize(value: Parameters<typeof coinAmount.serialize>[0], params: Parameters<typeof coinAmount.serialize>[1] & SerializeAettosParams, options: {
+        _canIncreaseFee?: boolean;
+    } & Parameters<typeof coinAmount.serialize>[2]): Buffer;
     deserialize(value: Buffer): string;
 };
 export default _default;

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

@@ -1,8 +1,16 @@
 /// <reference types="node" />
+import { Int } from '../constants';
+import Node from '../../../Node';
+import { AE_AMOUNT_FORMATS } from '../../../utils/amount-formatter';
+export declare function getCachedIncreasedGasPrice(node: Node): Promise<bigint>;
 declare const _default: {
+    prepare(value: Int | undefined, params: {}, { onNode, denomination }: {
+        onNode?: Node | undefined;
+        denomination?: AE_AMOUNT_FORMATS | undefined;
+    }): Promise<Int | undefined>;
     serializeAettos(value?: string | undefined): string;
-    serialize(value: import("../constants").Int | undefined, params: {}, { denomination }: {
-        denomination?: import("../../..").AE_AMOUNT_FORMATS | undefined;
+    serialize(value: Int | undefined, params: {}, { denomination, ...options }: {
+        denomination?: AE_AMOUNT_FORMATS | undefined;
     }): Buffer;
     deserialize(value: Buffer): string;
 };

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

@@ -1,32 +1,35 @@
 /// <reference types="node" />
-import abiVersion from './abi-version';
-import address from './address';
-import array from './array';
-import boolean from './boolean';
-import coinAmount from './coin-amount';
-import ctVersion from './ct-version';
-import deposit from './deposit';
-import encoded from './encoded';
-import entry from './entry';
-import enumeration from './enumeration';
-import fee from './fee';
-import field from './field';
-import gasLimit from './gas-limit';
-import gasPrice from './gas-price';
-import map from './map';
-import mptree from './mptree';
-import name from './name';
-import nameFee from './name-fee';
-import nameId from './name-id';
-import nonce from './nonce';
-import pointers from './pointers';
-import raw from './raw';
-import shortUInt from './short-u-int';
-import shortUIntConst from './short-u-int-const';
-import string from './string';
-import ttl from './ttl';
-import uInt from './u-int';
-import wrapped from './wrapped';
+export { default as abiVersion } from './abi-version';
+export { default as address } from './address';
+export { default as array } from './array';
+export { default as boolean } from './boolean';
+export { default as coinAmount } from './coin-amount';
+export { default as ctVersion } from './ct-version';
+export { default as encoded } from './encoded';
+export { default as entry } from './entry';
+export { default as enumeration } from './enumeration';
+export { default as fee } from './fee';
+export { default as field } from './field';
+export { default as gasLimit } from './gas-limit';
+export { default as gasPrice } from './gas-price';
+export { default as map } from './map';
+export { default as mptree } from './mptree';
+export { default as name } from './name';
+export { default as nameFee } from './name-fee';
+export { default as nameId } from './name-id';
+export { default as nonce } from './nonce';
+export { default as pointers } from './pointers';
+export { default as pointers2 } from './pointers2';
+export { default as queryFee } from './query-fee';
+export { default as raw } from './raw';
+export { default as shortUInt } from './short-u-int';
+export { default as shortUIntConst } from './short-u-int-const';
+export { default as string } from './string';
+export { default as ttl } from './ttl';
+export { default as uInt } from './u-int';
+export { default as withDefault } from './with-default';
+export { default as withFormatting } from './with-formatting';
+export { default as wrapped } from './wrapped';
 export type BinaryData = Buffer | Buffer[] | Buffer[][] | Array<[
     Buffer,
     Array<[
@@ -40,4 +43,3 @@ export interface Field {
     deserialize: (value: BinaryData, options: any) => any;
     recursiveType?: boolean;
 }
-export { abiVersion, address, array, boolean, coinAmount, ctVersion, deposit, encoded, entry, enumeration, fee, field, gasLimit, gasPrice, map, mptree, name, nameFee, nameId, nonce, pointers, raw, shortUInt, shortUIntConst, string, ttl, uInt, wrapped, };

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

@@ -6,7 +6,7 @@ declare const _default: {
         name: AensName;
     }): string;
     /**
-     * @param value - AENS name fee Buffer
+     * @param value - AENS name fee
      * @param txFields - Transaction fields
      * @param txFields.name - AENS Name in transaction
      */

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

@@ -8,6 +8,7 @@ export default function genNonceField<SenderKey extends string>(senderKey: Sende
     } & {
         strategy?: NextNonceStrategy;
         onNode?: Node;
+        _isInternalBuild?: boolean;
     }) => Promise<number>;
     deserialize: (value: Buffer) => number;
     senderKey: string;

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

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import { NamePointer as NamePointerString } from '../../../apis/node';
+import { Encoded, Encoding } from '../../../utils/encoder';
+import { AddressEncodings } from './address';
+type NamePointer = NamePointerString & {
+    id: Encoded.Generic<AddressEncodings | Encoding.Bytearray>;
+};
+declare const _default: {
+    /**
+     * Helper function to build pointers for name update TX
+     * @param pointers - Array of pointers
+     * `([ { key: 'account_pubkey', id: 'ak_32klj5j23k23j5423l434l2j3423'} ])`
+     * @returns Serialized pointers array
+     */
+    serialize(pointers: NamePointer[]): Buffer[][];
+    /**
+     * Helper function to read pointers from name update TX
+     * @param pointers - Array of pointers
+     * @returns Deserialize pointer array
+     */
+    deserialize(pointers: Array<[
+        key: Buffer,
+        id: Buffer
+    ]>): NamePointer[];
+};
+export default _default;

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

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import { Int } from '../constants';
+import Node from '../../../Node';
+import { Encoded } from '../../../utils/encoder';
+/**
+ * Oracle query fee
+ */
+declare const _default: {
+    prepare(value: Int | undefined, params: {}, options: {
+        oracleId?: Encoded.OracleAddress;
+        onNode?: Node;
+    }): Promise<Int>;
+    serializeAettos(value: string | undefined, params: {}, options: {}): string;
+    serialize(value: Int | undefined, params: {}, { denomination, ...options }: {
+        denomination?: import("../../..").AE_AMOUNT_FORMATS | undefined;
+    }): Buffer;
+    deserialize(value: Buffer): string;
+};
+export default _default;

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

@@ -1,10 +1,18 @@
 /// <reference types="node" />
 import Node from '../../../Node';
+import { _getPollInterval } from '../../../chain';
+/**
+ * Time to leave
+ */
 declare const _default: {
     serialize(value: number | undefined): Buffer;
-    prepare(value: number | undefined, params: {}, { onNode, absoluteTtl }: {
+    prepare(value: number | undefined, params: {}, { onNode, absoluteTtl, _isInternalBuild, ...options }: {
         onNode?: Node | undefined;
         absoluteTtl?: boolean | undefined;
+        _isInternalBuild?: boolean | undefined;
+    } & {
+        _expectedMineRate?: number | undefined;
+        _microBlockCycle?: number | undefined;
     }): Promise<number | undefined>;
     deserialize(value: Buffer): number;
 };

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

@@ -0,0 +1,7 @@
+export default function withDefault<Input, Output, Binary>(defaultValue: Input, field: {
+    serialize: (value: Input, params: unknown) => Binary;
+    deserialize: (value: Binary, params: unknown) => Output;
+}): {
+    serialize: (value: Input | undefined, params: unknown) => Binary;
+    deserialize: (value: Binary, params: unknown) => Output;
+};

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

@@ -0,0 +1,7 @@
+export default function withFormatting<Input, Output, Binary, Params, Options>(format: (v: Input | undefined) => Input, field: {
+    serialize: (value: Input, params: Params, options: Options) => Binary;
+    deserialize: (value: Binary) => Output;
+}): {
+    serialize: (value: Input | undefined, params: Params, options: Options) => Binary;
+    deserialize: (value: Binary) => Output;
+};

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

@@ -49,13 +49,13 @@ export declare function readInt(buf?: Buffer): string;
 /**
  * Ensure that name is valid AENS name, would throw an exception otherwise
  * @category AENS
- * @param name - AENS name
+ * @param maybeName - AENS name
  */
 export declare function ensureName(maybeName: string): asserts maybeName is AensName;
 /**
  * Is AENS name valid
  * @category AENS
- * @param name - AENS name
+ * @param maybeName - AENS name
  */
 export declare function isNameValid(maybeName: string): maybeName is AensName;
 declare const encodingToPointerKey: readonly [

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

@@ -11,29 +11,36 @@ export declare function getSchema(tag: Tag, version?: number): Array<[
 ]>;
 type TxEncoding = Encoding.Transaction | Encoding.Poi | Encoding.StateTrees | Encoding.CallStateTree;
 /**
- * Build transaction hash
+ * Build transaction
  * @category transaction builder
- * @param params - Object with tx params
- * @param options - options
- * @param options.prefix - Prefix of transaction
- * @returns object Base64Check transaction hash with 'tx_' prefix
+ * @param params - Transaction params
  */
-export declare function buildTx<E extends TxEncoding = Encoding.Transaction>(params: TxParams, { prefix }?: {
-    prefix?: E;
+export declare function buildTx(params: TxParams): Encoded.Transaction;
+/**
+ * Build node entry with a custom encoding
+ * @param params - Entry params
+ * @param options - Options
+ * @param options.prefix - Output encoding
+ */
+export declare function buildTx<E extends TxEncoding>(params: TxParams, { prefix }: {
+    prefix: E;
 }): Encoded.Generic<E>;
 export type BuildTxOptions<TxType extends Tag, OmitFields extends string> = Omit<TxParamsAsync & {
     tag: TxType;
 }, 'tag' | OmitFields>;
 /**
+ * Build transaction async (may request node for additional data)
  * @category transaction builder
+ * @param params - Transaction params
+ * @returns tx_-encoded transaction
  */
 export declare function buildTxAsync(params: TxParamsAsync): Promise<Encoded.Transaction>;
 /**
  * Unpack transaction encoded as string
  * @category transaction builder
- * @param encodedTx - Transaction to unpack
+ * @param encodedTx - Encoded transaction
  * @param txType - Expected transaction type
- * @returns Object with transaction param's
+ * @returns Transaction params
  */
 export declare function unpackTx<TxType extends Tag>(encodedTx: Encoded.Generic<TxEncoding>, txType?: TxType): TxUnpacked & {
     tag: TxType;
@@ -46,7 +53,7 @@ export declare function unpackTx<TxType extends Tag>(encodedTx: Encoded.Generic<
  */
 export declare function buildTxHash(rawTx: Encoded.Transaction | Uint8Array): Encoded.TxHash;
 /**
- * Build a contract public key by contractCreateTx or gaAttach
+ * Build a contract public key by contractCreateTx, gaAttach or signedTx
  * @category contract
  * @param contractTx - Transaction
  * @returns Contract public key