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

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

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import coinAmount from './coin-amount';
+import { AensName, Int } 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/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/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/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

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import { Int } from '../constants';
+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,50 @@
+import { Encoded, Encoding } from '../../utils/encoder';
+import { AE_AMOUNT_FORMATS } from '../../utils/amount-formatter';
+import { RawTxObject, TxTypeSchemas } from './schema';
+import { Tag } from './constants';
+/**
+ * Build transaction hash
+ * @category transaction builder
+ * @param params - Object with tx params
+ * @param options - options
+ * @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, 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;
+}): Encoded.Generic<E>;
+/**
+ * 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): RawTxObject<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;