@aeternity/aepp-sdk 13.3.3 → 14.0.0

package/types-legacy/ts4.5/tx/execution-cost.d.ts

@@ -1,53 +0,0 @@
-import { Encoded } from '../utils/encoder';
-import Node from '../Node';
-/**
- * Calculates the cost of transaction execution
- * Provides an upper cost of contract-call-related transactions because of `gasLimit`.
- * Also assumes that oracle query fee is 0 unless it is provided in options.
- *
- * The idea is that if you need to show transaction details with some accuracy you can define
- * expense fields that you want to show separately. And to show `getExecutionCost` result as a fee,
- * subtracting all fields shown separately.
- *
- * @example
- * ```vue
- * <template>
- * Amount: {{ txUnpacked.amount }}
- * Name fee: {{ txUnpacked.nameFee }}
- * Other fees: {{ getExecutionCost(txEncoded) - txUnpacked.amount - txUnpacked.nameFee }}
- * </template>
- * ```
- *
- * Doing this way you won't worry to show wrong fee for a transaction you may not support. Because
- * the SDK calculates the overall price of any transaction on its side.
- *
- * @param transaction - Transaction to calculate the cost of
- * @param options - Options
- * @param options.innerTx - Should be provided if transaction wrapped with Tag.PayingForTx
- * @param options.gasUsed - Amount of gas actually used to make calculation more accurate
- * @param options.queryFee - Oracle query fee
- * @param options.isInitiator - Is transaction signer an initiator of state channel
- */
-export declare function getExecutionCost(transaction: Encoded.Transaction, { innerTx, gasUsed, queryFee, isInitiator, }?: {
-    innerTx?: 'fee-payer' | 'freeloader';
-    gasUsed?: number;
-    queryFee?: string;
-    isInitiator?: boolean;
-}): bigint;
-/**
- * Calculates the cost of signed transaction execution
- * @param transaction - Transaction to calculate the cost of
- * @param networkId - Network id used to sign the transaction
- * @param options - Options
- */
-export declare function getExecutionCostBySignedTx(transaction: Encoded.Transaction, networkId: string, options?: Omit<Parameters<typeof getExecutionCost>[1], 'innerTx'>): bigint;
-/**
- * Calculates the cost of signed and not signed transaction execution using node
- * @param transaction - Transaction to calculate the cost of
- * @param node - Node to use
- * @param options - Options
- * @param options.isMined - Is transaction already mined or not
- */
-export declare function getExecutionCostUsingNode(transaction: Encoded.Transaction, node: Node, { isMined, ...options }?: {
-    isMined?: boolean;
-} & Parameters<typeof getExecutionCost>[1]): Promise<bigint>;

package/types-legacy/ts4.5/tx/transaction-signer.d.ts

@@ -1,6 +0,0 @@
-import { Encoded } from '../utils/encoder';
-/**
- * Returns account address that signed a transaction
- * @param transaction - transaction to get a signer of
- */
-export default function getTransactionSignerAddress(transaction: Encoded.Transaction): Encoded.AccountAddress;

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

@@ -1,18 +0,0 @@
-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.5/utils/amount-formatter.d.ts

@@ -1,41 +0,0 @@
-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;
-export declare const prefixedAmount: (rawValue: string | number | BigNumber) => string;

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

@@ -1,7 +0,0 @@
-import { AdditionalPolicyConfig, OperationOptions } from '@azure/core-client';
-export declare const genRequestQueuesPolicy: () => AdditionalPolicyConfig;
-export declare const genCombineGetRequestsPolicy: () => AdditionalPolicyConfig;
-export declare const genAggressiveCacheGetResponsesPolicy: () => AdditionalPolicyConfig;
-export declare const genErrorFormatterPolicy: (getMessage: (b: any) => string) => AdditionalPolicyConfig;
-export declare const genVersionCheckPolicy: (name: string, versionCb: (options: OperationOptions) => Promise<string>, geVersion: string, ltVersion: string) => AdditionalPolicyConfig;
-export declare const genRetryOnFailurePolicy: (retryCount: number, retryOverallDelay: number) => AdditionalPolicyConfig;

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

@@ -1,13 +0,0 @@
-/**
- * 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.5/utils/bytes.d.ts

@@ -1,9 +0,0 @@
-/// <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.5/utils/crypto.d.ts

@@ -1,100 +0,0 @@
-/// <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 maybeAddress - Address to check
- */
-export declare function isAddressValid(maybeAddress: string): maybeAddress is Encoded.AccountAddress;
-/**
- * Check if data is encoded in one of provided encodings
- * @param maybeEncoded - Data to check
- * @param encodings - Rest parameters with encodings to check against
- */
-export declare function isAddressValid<E extends Encoding>(maybeEncoded: string, ...encodings: E[]): maybeEncoded is Encoded.Generic<E>;
-/**
- * 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 const messagePrefixLength: Buffer;
-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
- *
- * Signs a message, and then verifies 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.5/utils/encoder-types.d.ts

@@ -1,61 +0,0 @@
-/**
- * @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.5/utils/encoder.d.ts

@@ -1,24 +0,0 @@
-/// <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>;