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

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

@@ -0,0 +1,71 @@
+import BigNumber from 'bignumber.js';
+export declare const MAX_AUTH_FUN_GAS = 50000;
+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;
+};
+/**
+ * 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,
+    OracleRegisterTx = 22,
+    OracleQueryTx = 23,
+    OracleResponseTx = 24,
+    OracleExtendTx = 25,
+    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,
+    CompilerSophia = 70,
+    GaAttachTx = 80,
+    GaMetaTx = 81,
+    PayingForTx = 82
+}

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

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { Encoding } 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}
+ */
+declare const idTagToEncoding: readonly [
+    Encoding.AccountAddress,
+    Encoding.Name,
+    Encoding.Commitment,
+    Encoding.OracleAddress,
+    Encoding.ContractAddress,
+    Encoding.Channel
+];
+export type AddressEncodings = typeof idTagToEncoding[number];
+export default function genAddressField<Encoding extends AddressEncodings>(): {
+    serialize: (value: `${Encoding}_${string}`) => Buffer;
+    deserialize: (value: Buffer) => `${Encoding}_${string}`;
+};
+export {};

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

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import { AddressEncodings } from './address';
+export default function genAddressesField<Encoding extends AddressEncodings>(): {
+    serialize: (value: Array<`${Encoding}_${string}`>) => Buffer[];
+    deserialize: (value: Buffer[]) => Array<`${Encoding}_${string}`>;
+};

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

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import { Int } from './u-int';
+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.2/tx/builder/field-types/deposit.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import coinAmount from './coin-amount';
+import { Int } from './u-int';
+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.2/tx/builder/field-types/enumeration.d.ts

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

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

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import BigNumber from 'bignumber.js';
+import { Tag } from '../constants';
+/**
+ * Calculate fee based on tx type and params
+ */
+export declare function buildFee(txType: Tag, buildTx: any): BigNumber;
+declare const _default: {
+    serializeAettos(_value: string | undefined, { txType, rebuildTx, _computingMinFee }: {
+        txType: Tag;
+        rebuildTx: (params: any) => any;
+        _computingMinFee?: string | undefined;
+    }): string;
+    serialize(value: import("./u-int").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/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.2/tx/builder/field-types/gas-limit.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import { Tag } from '../constants';
+declare const _default: {
+    serialize(_value: number | undefined, { txType, rebuildTx, gasMax, _computingGasLimit, }: {
+        txType: Tag;
+        rebuildTx: (params: any) => any;
+        gasMax: number;
+        _computingGasLimit?: number | undefined;
+    }): Buffer;
+    deserialize(value: Buffer): number;
+};
+export default _default;

package/types-legacy/ts4.2/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("./u-int").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

@@ -0,0 +1,85 @@
+/// <reference types="node" />
+import _address from './address';
+import _addresses from './addresses';
+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;
+};
+declare const shortUInt: {
+    serialize(value: number): Buffer;
+    deserialize(value: Buffer): number;
+};
+declare const coinAmount: {
+    serializeAettos(value: string | undefined): string;
+    serialize(value: import("./u-int").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 deposit: {
+    serialize(value: import("./u-int").Int | undefined, options: import("./coin-amount").Options): Buffer;
+    serializeAettos(value: string | undefined): string;
+    deserialize(value: Buffer): string;
+};
+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;
+    }): string;
+    serialize(value: import("./u-int").Int | undefined, { denomination, ...options }: import("./coin-amount").Options): Buffer;
+    deserialize(value: Buffer): string;
+};
+declare const gasLimit: {
+    serialize(_value: number | undefined, { txType, rebuildTx, gasMax, _computingGasLimit, }: {
+        txType: import("../constants").Tag;
+        rebuildTx: (params: any) => any;
+        gasMax: number;
+        _computingGasLimit?: number | undefined;
+    }): Buffer;
+    deserialize(value: Buffer): number;
+};
+declare const gasPrice: {
+    serializeAettos(value?: string | undefined): string;
+    serialize(value: import("./u-int").Int | undefined, { denomination, ...options }: import("./coin-amount").Options): Buffer;
+    deserialize(value: Buffer): string;
+};
+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("./u-int").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;
+    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}`;
+    })[];
+};
+export interface Field {
+    serialize: (value: any, options: any) => Buffer | Buffer[] | Buffer[][];
+    deserialize: (value: Buffer | Buffer[] | Buffer[][]) => any;
+}
+export { field, uInt, shortUInt, coinAmount, address, addresses, deposit, enumeration, fee, gasLimit, gasPrice, name, nameFee, nameId, pointers, };

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

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import { Int } from './u-int';
+import coinAmount from './coin-amount';
+import { AensName } from '../constants';
+declare const _default: {
+    serializeAettos(_value: string | undefined, txFields: {
+        name: AensName;
+    }): string;
+    /**
+     * @param value - AENS name fee Buffer
+     * @param txFields - Transaction fields
+     * @param txFields.name - AENS Name in transaction
+     */
+    serialize(value: Int | undefined, txFields: {
+        name: AensName;
+    } & Parameters<(typeof coinAmount)['serialize']>[1]): Buffer;
+    deserialize(value: Buffer): string;
+};
+export default _default;

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

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { AensName } from '../constants';
+import { Encoded } from '../../../utils/encoder';
+declare const _default: {
+    /**
+     * @param value - AENS name ID
+     */
+    serialize(value: AensName | Encoded.Name): Buffer;
+    deserialize: (value: Buffer) => `nm_${string}`;
+};
+export default _default;

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

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { AensName } from '../constants';
+declare const _default: {
+    /**
+     * @param value - AENS name
+     */
+    serialize(value: AensName): Buffer;
+    /**
+     * @param value - AENS name
+     */
+    deserialize(value: Buffer): AensName;
+};
+export default _default;

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

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import { NamePointer as NamePointerString } from '../../../apis/node';
+import { Encoded } from '../../../utils/encoder';
+import { AddressEncodings } from './address';
+type NamePointer = NamePointerString & {
+    id: Encoded.Generic<AddressEncodings>;
+};
+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/short-u-int.d.ts

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

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

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

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

@@ -0,0 +1,112 @@
+/// <reference types="node" />
+import BigNumber from 'bignumber.js';
+import { Encoded } from '../../utils/encoder';
+import { AensName } from './constants';
+/**
+ * JavaScript-based Transaction builder helper function's
+ */
+/**
+ * Build a contract public key
+ * @category contract
+ * @param ownerId - The public key of the owner account
+ * @param nonce - the nonce of the transaction
+ * @returns Contract public key
+ */
+export declare function buildContractId(ownerId: Encoded.AccountAddress, nonce: number | BigNumber): Encoded.ContractAddress;
+/**
+ * Build a oracle query id
+ * @category oracle
+ * @param senderId - The public key of the sender account
+ * @param nonce - the nonce of the transaction
+ * @param oracleId - The oracle public key
+ * @returns Contract public key
+ */
+export declare function oracleQueryId(senderId: Encoded.AccountAddress, nonce: number | BigNumber | string, oracleId: Encoded.OracleAddress): Encoded.OracleQueryId;
+/**
+ * Encode an AENS name
+ * @category AENS
+ * @param name - Name to encode
+ * @returns `nm_` prefixed encoded AENS name
+ */
+export declare function produceNameId(name: AensName): Encoded.Name;
+/**
+ * Generate the commitment hash by hashing the salt and
+ * name, base 58 encoding the result and prepending 'cm_'
+ * @category transaction builder
+ * @param name - Name to be registered
+ * @param salt - Random number
+ * @returns Commitment hash
+ */
+export declare function commitmentHash(name: AensName, salt?: number): Encoded.Commitment;
+/**
+ * Utility function to convert bytes to int
+ * @category transaction builder
+ * @param buf - Value
+ * @returns Buffer Buffer from number(BigEndian)
+ */
+export declare function readInt(buf?: Buffer): string;
+/**
+ * Is AENS name valid
+ * @category AENS
+ * @param name - AENS name
+ */
+export declare function isNameValid(name: string): name is AensName;
+declare const encodingToPointerKey: readonly [
+    readonly [
+        Encoded.Encoding.AccountAddress,
+        "account_pubkey"
+    ],
+    readonly [
+        Encoded.Encoding.OracleAddress,
+        "oracle_pubkey"
+    ],
+    readonly [
+        Encoded.Encoding.ContractAddress,
+        "contract_pubkey"
+    ],
+    readonly [
+        Encoded.Encoding.Channel,
+        "channel"
+    ]
+];
+/**
+ * @category AENS
+ * @param identifier - account/oracle/contract address, or channel
+ * @returns default AENS pointer key
+ */
+export declare function getDefaultPointerKey(identifier: Encoded.Generic<typeof encodingToPointerKey[number][0]>): typeof encodingToPointerKey[number][1];
+/**
+ * Get the minimum AENS name fee
+ * @category AENS
+ * @param name - the AENS name to get the fee for
+ * @returns the minimum fee for the AENS name auction
+ */
+export declare function getMinimumNameFee(name: AensName): BigNumber;
+/**
+ * Compute bid fee for AENS auction
+ * @category AENS
+ * @param name - the AENS name to get the fee for
+ * @param options - Options
+ * @param options.startFee - Auction start fee
+ * @param options.increment - Bid multiplier(In percentage, must be between 0 and 1)
+ * @returns Bid fee
+ */
+export declare function computeBidFee(name: AensName, { startFee, increment }?: {
+    startFee?: number | string | BigNumber;
+    increment?: number;
+}): BigNumber;
+/**
+ * Compute auction end height
+ * @category AENS
+ * @param name - Name to compute auction end for
+ * @param claimHeight - Auction starting height
+ * @see {@link https://github.com/aeternity/aeternity/blob/72e440b8731422e335f879a31ecbbee7ac23a1cf/apps/aecore/src/aec_governance.erl#L273}
+ * @returns Auction end height
+ */
+export declare function computeAuctionEndBlock(name: AensName, claimHeight: number): number;
+/**
+ * Is name accept going to auction
+ * @category AENS
+ */
+export declare function isAuctionName(name: AensName): boolean;
+export {};

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

@@ -0,0 +1,68 @@
+import { Encoded, Encoding } from '../../utils/encoder';
+import { AE_AMOUNT_FORMATS } from '../../utils/amount-formatter';
+import { RawTxObject, TxSchema, 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 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}
+ * @returns object
+ * @returns object.tx Base64Check transaction hash with 'tx_' prefix
+ * @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;
+    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;
+}
+/**
+ * Unpack transaction hash
+ * @category transaction builder
+ * @param encodedTx - Transaction to unpack
+ * @param txType - Expected transaction type
+ * @returns object
+ * @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]>;
+/**
+ * Build a transaction hash
+ * @category transaction builder
+ * @param rawTx - base64 or rlp encoded transaction
+ * @returns Transaction hash
+ */
+export declare function buildTxHash(rawTx: Encoded.Transaction | Uint8Array): Encoded.TxHash;
+/**
+ * Build a contract public key by contractCreateTx or gaAttach
+ * @category contract
+ * @param contractTx - Transaction
+ * @returns Contract public key
+ */
+export declare function buildContractIdByContractTx(contractTx: Encoded.Transaction): Encoded.ContractAddress;