@aeternity/aepp-sdk 13.2.2 → 13.3.0

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

@@ -1,11 +1,11 @@
 import BigNumber from 'bignumber.js';
+export declare const DRY_RUN_ACCOUNT: {
+    readonly pub: "ak_11111111111111111111111111111111273Yts";
+    readonly amount: 100000000000000000000000000000000000n;
+};
 export declare const MAX_AUTH_FUN_GAS = 50000;
 export type Int = number | string | BigNumber;
 export type AensName = `${string}.chain`;
-export declare const 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;

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

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

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

@@ -0,0 +1,136 @@
+/// <reference types="node" />
+import SchemaTypes from '../SchemaTypes';
+import { Encoded } from '../../../utils/encoder';
+/**
+ * @category delegation signature
+ */
+export declare enum DelegationTag {
+    AensWildcard = 1,
+    AensName = 2,
+    AensPreclaim = 3,
+    Oracle = 4,
+    OracleResponse = 5
+}
+/**
+ * @see {@link https://github.com/aeternity/protocol/blob/8a9d1d1206174627f6aaef86159dc9c643080653/contracts/fate.md#from-ceres-serialized-signature-data}
+ */
+export declare const schemas: readonly [
+    {
+        readonly tag: {
+            serialize: (value: DelegationTag.AensWildcard) => Buffer;
+            deserialize: (value: Buffer) => DelegationTag.AensWildcard;
+            constValue: DelegationTag.AensWildcard;
+            constValueOptional: boolean;
+        };
+        readonly version: {
+            serialize: (value?: 1 | undefined) => Buffer;
+            deserialize: (value: Buffer) => 1;
+            constValue: 1;
+            constValueOptional: boolean;
+        };
+        readonly accountAddress: {
+            serialize: (value: `ak_${string}`) => Buffer;
+            deserialize: (value: Buffer) => `ak_${string}`;
+        };
+        readonly contractAddress: {
+            serialize: (value: `ct_${string}`) => Buffer;
+            deserialize: (value: Buffer) => `ct_${string}`;
+        };
+    },
+    {
+        readonly tag: {
+            serialize: (value: DelegationTag.AensName) => Buffer;
+            deserialize: (value: Buffer) => DelegationTag.AensName;
+            constValue: DelegationTag.AensName;
+            constValueOptional: boolean;
+        };
+        readonly version: {
+            serialize: (value?: 1 | undefined) => Buffer;
+            deserialize: (value: Buffer) => 1;
+            constValue: 1;
+            constValueOptional: boolean;
+        };
+        readonly accountAddress: {
+            serialize: (value: `ak_${string}`) => Buffer;
+            deserialize: (value: Buffer) => `ak_${string}`;
+        };
+        readonly nameId: {
+            serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
+            deserialize: (value: Buffer) => `nm_${string}`;
+        };
+        readonly contractAddress: {
+            serialize: (value: `ct_${string}`) => Buffer;
+            deserialize: (value: Buffer) => `ct_${string}`;
+        };
+    },
+    {
+        readonly tag: {
+            serialize: (value: DelegationTag.AensPreclaim) => Buffer;
+            deserialize: (value: Buffer) => DelegationTag.AensPreclaim;
+            constValue: DelegationTag.AensPreclaim;
+            constValueOptional: boolean;
+        };
+        readonly version: {
+            serialize: (value?: 1 | undefined) => Buffer;
+            deserialize: (value: Buffer) => 1;
+            constValue: 1;
+            constValueOptional: boolean;
+        };
+        readonly accountAddress: {
+            serialize: (value: `ak_${string}`) => Buffer;
+            deserialize: (value: Buffer) => `ak_${string}`;
+        };
+        readonly contractAddress: {
+            serialize: (value: `ct_${string}`) => Buffer;
+            deserialize: (value: Buffer) => `ct_${string}`;
+        };
+    },
+    {
+        readonly tag: {
+            serialize: (value: DelegationTag.Oracle) => Buffer;
+            deserialize: (value: Buffer) => DelegationTag.Oracle;
+            constValue: DelegationTag.Oracle;
+            constValueOptional: boolean;
+        };
+        readonly version: {
+            serialize: (value?: 1 | undefined) => Buffer;
+            deserialize: (value: Buffer) => 1;
+            constValue: 1;
+            constValueOptional: boolean;
+        };
+        readonly accountAddress: {
+            serialize: (value: `ak_${string}`) => Buffer;
+            deserialize: (value: Buffer) => `ak_${string}`;
+        };
+        readonly contractAddress: {
+            serialize: (value: `ct_${string}`) => Buffer;
+            deserialize: (value: Buffer) => `ct_${string}`;
+        };
+    },
+    {
+        readonly tag: {
+            serialize: (value: DelegationTag.OracleResponse) => Buffer;
+            deserialize: (value: Buffer) => DelegationTag.OracleResponse;
+            constValue: DelegationTag.OracleResponse;
+            constValueOptional: boolean;
+        };
+        readonly version: {
+            serialize: (value?: 1 | undefined) => Buffer;
+            deserialize: (value: Buffer) => 1;
+            constValue: 1;
+            constValueOptional: boolean;
+        };
+        readonly queryId: {
+            readonly serialize: (value: Encoded.OracleQueryId) => Buffer;
+            readonly deserialize: (value: Buffer) => Encoded.OracleQueryId;
+        };
+        readonly contractAddress: {
+            serialize: (value: `ct_${string}`) => Buffer;
+            deserialize: (value: Buffer) => `ct_${string}`;
+        };
+    }
+];
+type Schemas = SchemaTypes<typeof schemas>;
+export type DlgParams = Schemas['TxParams'];
+export type DlgUnpacked = Schemas['TxUnpacked'];
+export {};

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

@@ -0,0 +1,141 @@
+import { DlgParams as DlgParamsComplex, DlgUnpacked as DlgUnpackedComplex } from "./schema";
+import { DelegationTag as Tag } from "./schema";
+/**
+ * @category delegation signature
+ */
+type DlgParamsAensWildcard1Type = Omit<DlgParamsComplex & {
+    tag: Tag.AensWildcard;
+    version: 1;
+}, "version"> & {
+    version?: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgParamsAensWildcard1 extends DlgParamsAensWildcard1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgUnpackedAensWildcard1Type = DlgUnpackedComplex & {
+    tag: Tag.AensWildcard;
+    version: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgUnpackedAensWildcard1 extends DlgUnpackedAensWildcard1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgParamsAensName1Type = Omit<DlgParamsComplex & {
+    tag: Tag.AensName;
+    version: 1;
+}, "version"> & {
+    version?: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgParamsAensName1 extends DlgParamsAensName1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgUnpackedAensName1Type = DlgUnpackedComplex & {
+    tag: Tag.AensName;
+    version: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgUnpackedAensName1 extends DlgUnpackedAensName1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgParamsAensPreclaim1Type = Omit<DlgParamsComplex & {
+    tag: Tag.AensPreclaim;
+    version: 1;
+}, "version"> & {
+    version?: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgParamsAensPreclaim1 extends DlgParamsAensPreclaim1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgUnpackedAensPreclaim1Type = DlgUnpackedComplex & {
+    tag: Tag.AensPreclaim;
+    version: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgUnpackedAensPreclaim1 extends DlgUnpackedAensPreclaim1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgParamsOracle1Type = Omit<DlgParamsComplex & {
+    tag: Tag.Oracle;
+    version: 1;
+}, "version"> & {
+    version?: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgParamsOracle1 extends DlgParamsOracle1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgUnpackedOracle1Type = DlgUnpackedComplex & {
+    tag: Tag.Oracle;
+    version: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgUnpackedOracle1 extends DlgUnpackedOracle1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgParamsOracleResponse1Type = Omit<DlgParamsComplex & {
+    tag: Tag.OracleResponse;
+    version: 1;
+}, "version"> & {
+    version?: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgParamsOracleResponse1 extends DlgParamsOracleResponse1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgUnpackedOracleResponse1Type = DlgUnpackedComplex & {
+    tag: Tag.OracleResponse;
+    version: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgUnpackedOracleResponse1 extends DlgUnpackedOracleResponse1Type {
+}
+/**
+ * @category delegation signature
+ */
+export type DlgParams = DlgParamsAensWildcard1 | DlgParamsAensName1 | DlgParamsAensPreclaim1 | DlgParamsOracle1 | DlgParamsOracleResponse1;
+/**
+ * @category delegation signature
+ */
+export type DlgUnpacked = DlgUnpackedAensWildcard1 | DlgUnpackedAensName1 | DlgUnpackedAensPreclaim1 | DlgUnpackedOracle1 | DlgUnpackedOracleResponse1;
+export {};

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

@@ -2,8 +2,8 @@
 import { Int } from '../constants';
 import { AE_AMOUNT_FORMATS } from '../../../utils/amount-formatter';
 declare const _default: {
-    serializeAettos(value: string | undefined, params: {}): string;
-    serialize(value: Int | undefined, params: {}, { denomination }: {
+    serializeAettos(value: string | undefined, params: {}, options: {}): string;
+    serialize(value: Int | undefined, params: {}, { denomination, ...options }: {
         denomination?: AE_AMOUNT_FORMATS | undefined;
     }): Buffer;
     deserialize(value: Buffer): string;

package/types-legacy/ts4.5/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.5/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.5/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.5/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.5/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.5/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.5/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.5/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.5/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.5/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.5/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.5/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