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

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

@@ -0,0 +1,19 @@
+import { Tag } from './builder/constants';
+import Node from '../Node';
+import { Encoded } from '../utils/encoder';
+import { buildTx as syncBuildTx } from './builder/index';
+import { AE_AMOUNT_FORMATS } from '../utils/amount-formatter';
+export type BuildTxOptions<TxType extends Tag, OmitFields extends string> = Omit<Parameters<any>[1], OmitFields>;
+/**
+ * @category transaction builder
+ */
+export declare function _buildTx<TxType extends Tag>(txType: TxType, { denomination, absoluteTtl, strategy, onNode, ..._params }: Omit<Parameters<any>[0], 'tag' | 'nonce' | 'ttl'> & {
+    denomination?: AE_AMOUNT_FORMATS;
+    absoluteTtl?: boolean;
+    strategy?: 'continuity' | 'max';
+    onNode: Node;
+    ttl?: number;
+    nonce?: number;
+} & (TxType extends Tag.OracleExtendTx | Tag.OracleResponseTx ? {
+    callerId: Encoded.AccountAddress;
+} : {})): Promise<Encoded.Transaction>;

package/types-legacy/ts4.2/tx/validator.d.ts

@@ -0,0 +1,18 @@
+import { unpackTx } from './builder';
+import Node from '../Node';
+export interface ValidatorResult {
+    message: string;
+    key: string;
+    checkedKeys: string[];
+}
+/**
+ * Transaction Validator
+ * This function validates some transaction properties,
+ * to make sure it can be posted it to the chain
+ * @category transaction builder
+ * @param transaction - Base64Check-encoded transaction
+ * @param nodeNotCached - Node to validate transaction against
+ * @returns Array with verification errors
+ * @example const errors = await verifyTransaction(transaction, node)
+ */
+export default function verifyTransaction(transaction: Parameters<typeof unpackTx>[0], nodeNotCached: Node): Promise<ValidatorResult[]>;

package/types-legacy/ts4.2/utils/amount-formatter.d.ts

@@ -0,0 +1,42 @@
+import BigNumber from 'bignumber.js';
+export declare enum AE_AMOUNT_FORMATS {
+    AE = "ae",
+    MILI_AE = "miliAE",
+    MICRO_AE = "microAE",
+    NANO_AE = "nanoAE",
+    PICO_AE = "picoAE",
+    FEMTO_AE = "femtoAE",
+    AETTOS = "aettos"
+}
+/**
+ * Convert amount from one to other denomination
+ * @param value - amount to convert
+ * @param options - options
+ * @param options.denomination - denomination of amount, can be ['ae', 'aettos']
+ * @param options.targetDenomination - target denomination,
+ * can be ['ae', 'aettos']
+ */
+export declare const formatAmount: (value: string | number | bigint | BigNumber, { denomination, targetDenomination }: {
+    denomination?: AE_AMOUNT_FORMATS | undefined;
+    targetDenomination?: AE_AMOUNT_FORMATS | undefined;
+}) => string;
+/**
+ * Convert amount to AE
+ * @param value - amount to convert
+ * @param options - options
+ * @param options.denomination - denomination of amount, can be ['ae', 'aettos']
+ */
+export declare const toAe: (value: string | number | BigNumber, { denomination }?: {
+    denomination?: AE_AMOUNT_FORMATS | undefined;
+}) => string;
+/**
+ * Convert amount to aettos
+ * @param value - amount to convert
+ * @param options - options
+ * @param options.denomination - denomination of amount, can be ['ae', 'aettos']
+ */
+export declare const toAettos: (value: string | number | BigNumber, { denomination }?: {
+    denomination?: AE_AMOUNT_FORMATS | undefined;
+}) => string;
+declare const _default: (rawValue: string | number | BigNumber) => string;
+export default _default;

package/types-legacy/ts4.2/utils/autorest.d.ts

@@ -0,0 +1,7 @@
+import { PipelinePolicy } from '@azure/core-rest-pipeline';
+import { AdditionalPolicyConfig } from '@azure/core-client';
+export declare const genRequestQueuesPolicy: () => AdditionalPolicyConfig;
+export declare const genCombineGetRequestsPolicy: () => AdditionalPolicyConfig;
+export declare const genAggressiveCacheGetResponsesPolicy: () => PipelinePolicy;
+export declare const genErrorFormatterPolicy: (getMessage: (b: any) => string) => AdditionalPolicyConfig;
+export declare const genVersionCheckPolicy: (name: string, ignorePath: string, versionPromise: Promise<string>, geVersion: string, ltVersion: string) => PipelinePolicy;

package/types-legacy/ts4.2/utils/bignumber.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Big Number Helpers
+ */
+import BigNumber from 'bignumber.js';
+/**
+ * Check if value is BigNumber, Number, BigInt or number string representation
+ * @param number - number to check
+ */
+export declare const isBigNumber: (number: string | number | bigint | BigNumber) => boolean;
+/**
+ * BigNumber ceil operation
+ */
+export declare const ceil: (bigNumber: BigNumber) => BigNumber;

package/types-legacy/ts4.2/utils/bytes.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import BigNumber from 'bignumber.js';
+/**
+ * Convert string, number, or BigNumber to byte array
+ * @param val - value to convert
+ * @param big - enables force conversion to BigNumber
+ * @returns Buffer
+ */
+export declare function toBytes(val?: null | string | number | BigNumber, big?: boolean): Buffer;

package/types-legacy/ts4.2/utils/crypto.d.ts

@@ -0,0 +1,95 @@
+/// <reference types="node" />
+import { SignKeyPair } from 'tweetnacl';
+import { Encoded, Encoding } from './encoder';
+/**
+ * Generate address from secret key
+ * @param secret - Private key as hex string
+ * @returns Public key encoded as address
+ */
+export declare function getAddressFromPriv(secret: string | Uint8Array): Encoded.AccountAddress;
+/**
+ * Check if address is valid
+ * @param address - Address
+ * @param prefix - Transaction prefix. Default: 'ak'
+ * @returns is valid
+ */
+export declare function isAddressValid(address: string, prefix?: Encoding): boolean;
+/**
+ * Generate a random salt (positive integer)
+ * @returns random salt
+ */
+export declare function genSalt(): number;
+/**
+ * Converts a positive integer to the smallest possible
+ * representation in a binary digit representation
+ * @param value - Value to encode
+ * @returns Encoded number
+ */
+export declare function encodeUnsigned(value: number): Buffer;
+/**
+ * Calculate 256bits Blake2b hash of `input`
+ * @param input - Data to hash
+ * @returns Hash
+ */
+export declare function hash(input: string | Uint8Array): Buffer;
+/**
+ * Compute contract address
+ * @category contract
+ * @param owner - Address of contract owner
+ * @param nonce - Round when contract was created
+ * @returns Contract address
+ */
+export declare function encodeContractAddress(owner: Encoded.AccountAddress, nonce: number): Encoded.ContractAddress;
+/**
+ * Generate keyPair from secret key
+ * @param secret - secret key
+ * @returns Object with Private(privateKey) and Public(publicKey) keys
+ */
+export declare function generateKeyPairFromSecret(secret: Uint8Array): SignKeyPair;
+/**
+ * Generate a random ED25519 keypair
+ * @param raw - Whether to return raw (binary) keys
+ * @returns Key pair
+ */
+export declare function generateKeyPair(raw: true): {
+    publicKey: Buffer;
+    secretKey: Buffer;
+};
+export declare function generateKeyPair(raw?: false): {
+    publicKey: Encoded.AccountAddress;
+    secretKey: string;
+};
+/**
+ * Generate signature
+ * @param data - Data to sign
+ * @param privateKey - Key to sign with
+ * @returns Signature
+ */
+export declare function sign(data: string | Uint8Array, privateKey: string | Uint8Array): Uint8Array;
+/**
+ * Verify that signature was signed by public key
+ * @param data - Data that was signed
+ * @param signature - Signature of data
+ * @param address - Address to verify against
+ * @returns is data was signed by address
+ */
+export declare function verify(data: Uint8Array, signature: Uint8Array, address: Encoded.AccountAddress): boolean;
+export declare function messageToHash(message: string): Buffer;
+export declare function signMessage(message: string, privateKey: string | Buffer): Uint8Array;
+/**
+ * Verify that message was signed by address
+ * @param message - Message that was signed
+ * @param signature - Signature of message
+ * @param address - Address to verify against
+ * @returns is data was signed by address
+ */
+export declare function verifyMessage(message: string, signature: Uint8Array, address: Encoded.AccountAddress): boolean;
+/**
+ * Check key pair for validity
+ *
+ * Sign a message, and then verifying that signature
+ * @param privateKey - Private key to verify
+ * @param publicKey - Public key to verify as hex string
+ * @returns Valid?
+ */
+export declare function isValidKeypair(privateKey: string | Uint8Array, publicKey: string | Uint8Array): boolean;

package/types-legacy/ts4.2/utils/encoder-types.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @category transaction builder
+ * @see {@link https://github.com/aeternity/protocol/blob/master/node/api/api_encoding.md}
+ * @see {@link https://github.com/aeternity/aeserialization/blob/eb68fe331bd476910394966b7f5ede7a74d37e35/src/aeser_api_encoder.erl#L205-L230}
+ */
+export declare enum Encoding {
+    KeyBlockHash = "kh",
+    MicroBlockHash = "mh",
+    BlockPofHash = "bf",
+    BlockTxHash = "bx",
+    BlockStateHash = "bs",
+    Channel = "ch",
+    ContractAddress = "ct",
+    ContractBytearray = "cb",
+    ContractStoreKey = "ck",
+    ContractStoreValue = "cv",
+    Transaction = "tx",
+    TxHash = "th",
+    OracleAddress = "ok",
+    OracleQuery = "ov",
+    OracleQueryId = "oq",
+    OracleResponse = "or",
+    AccountAddress = "ak",
+    Signature = "sg",
+    Commitment = "cm",
+    PeerPubkey = "pp",
+    Name = "nm",
+    State = "st",
+    Poi = "pi",
+    StateTrees = "ss",
+    CallStateTree = "cs",
+    Bytearray = "ba"
+}
+export type KeyBlockHash = `${Encoding.KeyBlockHash}_${string}`;
+export type MicroBlockHash = `${Encoding.MicroBlockHash}_${string}`;
+export type BlockPofHash = `${Encoding.BlockPofHash}_${string}`;
+export type BlockTxHash = `${Encoding.BlockTxHash}_${string}`;
+export type BlockStateHash = `${Encoding.BlockStateHash}_${string}`;
+export type Channel = `${Encoding.Channel}_${string}`;
+export type ContractAddress = `${Encoding.ContractAddress}_${string}`;
+export type ContractBytearray = `${Encoding.ContractBytearray}_${string}`;
+export type ContractStoreKey = `${Encoding.ContractStoreKey}_${string}`;
+export type ContractStoreValue = `${Encoding.ContractStoreValue}_${string}`;
+export type Transaction = `${Encoding.Transaction}_${string}`;
+export type TxHash = `${Encoding.TxHash}_${string}`;
+export type OracleAddress = `${Encoding.OracleAddress}_${string}`;
+export type OracleQuery = `${Encoding.OracleQuery}_${string}`;
+export type OracleQueryId = `${Encoding.OracleQueryId}_${string}`;
+export type OracleResponse = `${Encoding.OracleResponse}_${string}`;
+export type AccountAddress = `${Encoding.AccountAddress}_${string}`;
+export type Signature = `${Encoding.Signature}_${string}`;
+export type Commitment = `${Encoding.Commitment}_${string}`;
+export type PeerPubkey = `${Encoding.PeerPubkey}_${string}`;
+export type Name = `${Encoding.Name}_${string}`;
+export type State = `${Encoding.State}_${string}`;
+export type Poi = `${Encoding.Poi}_${string}`;
+export type StateTrees = `${Encoding.StateTrees}_${string}`;
+export type CallStateTree = `${Encoding.CallStateTree}_${string}`;
+export type Bytearray = `${Encoding.Bytearray}_${string}`;
+export type Generic<Type extends Encoding> = `${Type}_${string}`;
+export type Any = `${Encoding}_${string}`;

package/types-legacy/ts4.2/utils/encoder.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import * as Encoded from './encoder-types';
+import { Encoding } from './encoder-types';
+export { Encoded, Encoding };
+/**
+ * Calculate SHA256 hash of `input`
+ * @param input - Data to hash
+ * @returns Hash
+ */
+export declare function sha256hash(input: Uint8Array | string): Buffer;
+/**
+ * Decode data using the default encoding/decoding algorithm
+ * @param data - An Base58/64check encoded and prefixed string
+ * (ex tx_..., sg_..., ak_....)
+ * @returns Decoded data
+ */
+export declare function decode(data: Encoded.Any): Buffer;
+/**
+ * Encode data using the default encoding/decoding algorithm
+ * @param data - An decoded data
+ * @param type - Prefix of Transaction
+ * @returns Encoded string Base58check or Base64check data
+ */
+export declare function encode<Type extends Encoding>(data: Uint8Array, type: Type): Encoded.Generic<Type>;