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

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

@@ -0,0 +1,475 @@
+import BigNumber from 'bignumber.js';
+import { Int } from '../tx/builder/constants';
+/**
+ * aepp-sdk originated error
+ * @category exception
+ */
+export declare abstract class BaseError extends Error {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class AccountError extends BaseError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class AensError extends BaseError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class AeppError extends BaseError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class ChannelError extends BaseError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class CompilerError extends BaseError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class ContractError extends BaseError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class CryptographyError extends BaseError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class NodeError extends BaseError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class TransactionError extends BaseError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class WalletError extends BaseError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class ArgumentError extends BaseError {
+    constructor(argumentName: string, requirement: unknown, argumentValue: unknown);
+}
+/**
+ * @category exception
+ */
+export declare class IllegalArgumentError extends CryptographyError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class ArgumentCountMismatchError extends BaseError {
+    constructor(functionName: string, requiredCount: number, providedCount: number);
+}
+/**
+ * @category exception
+ */
+export declare class InsufficientBalanceError extends BaseError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class MissingParamError extends BaseError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class NoSerializerFoundError extends BaseError {
+    constructor();
+}
+/**
+ * @category exception
+ */
+export declare class RequestTimedOutError extends BaseError {
+    constructor(height: number);
+}
+/**
+ * @category exception
+ */
+export declare class TxTimedOutError extends BaseError {
+    constructor(blocks: number, th: string);
+}
+/**
+ * @category exception
+ */
+export declare class TypeError extends BaseError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class UnsupportedPlatformError extends BaseError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class UnsupportedProtocolError extends BaseError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class NotImplementedError extends BaseError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class UnsupportedVersionError extends BaseError {
+    constructor(dependency: string, version: string, geVersion: string, ltVersion: string);
+}
+/**
+ * @category exception
+ */
+export declare class InternalError extends BaseError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class UnexpectedTsError extends InternalError {
+    constructor(message?: string);
+}
+/**
+ * @category exception
+ */
+export declare class UnavailableAccountError extends AccountError {
+    constructor(address: string);
+}
+/**
+ * @category exception
+ */
+export declare class AensPointerContextError extends AensError {
+    constructor(nameOrId: string, prefix: string);
+}
+/**
+ * @category exception
+ */
+export declare class InsufficientNameFeeError extends AensError {
+    constructor(nameFee: BigNumber, minNameFee: BigNumber);
+}
+/**
+ * @category exception
+ */
+export declare class InvalidAensNameError extends AensError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class InvalidRpcMessageError extends AeppError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class MissingCallbackError extends AeppError {
+    constructor(id: number);
+}
+/**
+ * @category exception
+ */
+export declare class UnAuthorizedAccountError extends AeppError {
+    constructor(onAccount: string);
+}
+/**
+ * @category exception
+ */
+export declare class UnknownRpcClientError extends AeppError {
+    constructor(id: string);
+}
+/**
+ * @category exception
+ */
+export declare class UnsubscribedAccountError extends AeppError {
+    constructor();
+}
+/**
+ * @category exception
+ */
+export declare class ChannelCallError extends ChannelError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class ChannelConnectionError extends ChannelError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class ChannelPingTimedOutError extends ChannelError {
+    constructor();
+}
+/**
+ * @category exception
+ */
+export declare class UnexpectedChannelMessageError extends ChannelError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class ChannelIncomingMessageError extends ChannelError {
+    handlerError: BaseError;
+    incomingMessage: {
+        [key: string]: any;
+    };
+    constructor(handlerError: BaseError, incomingMessage: {
+        [key: string]: any;
+    });
+}
+/**
+ * @category exception
+ */
+export declare class UnknownChannelStateError extends ChannelError {
+    constructor();
+}
+/**
+ * @category exception
+ */
+export declare class InvalidAuthDataError extends CompilerError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class BytecodeMismatchError extends ContractError {
+    constructor(source: string);
+}
+/**
+ * @category exception
+ */
+export declare class DuplicateContractError extends ContractError {
+    constructor();
+}
+/**
+ * @category exception
+ */
+export declare class InactiveContractError extends ContractError {
+    constructor(contractAddress: string);
+}
+/**
+ * @category exception
+ */
+export declare class InvalidMethodInvocationError extends ContractError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class MissingContractAddressError extends ContractError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class MissingContractDefError extends ContractError {
+    constructor();
+}
+/**
+ * @category exception
+ */
+export declare class MissingFunctionNameError extends ContractError {
+    constructor();
+}
+/**
+ * @category exception
+ */
+export declare class NodeInvocationError extends ContractError {
+    transaction: string;
+    constructor(message: string, transaction: string);
+}
+/**
+ * @category exception
+ */
+export declare class NoSuchContractFunctionError extends ContractError {
+    constructor(name: string);
+}
+/**
+ * @category exception
+ */
+export declare class NotPayableFunctionError extends ContractError {
+    constructor(amount: Int, fn: string);
+}
+/**
+ * @category exception
+ */
+export declare class MissingEventDefinitionError extends ContractError {
+    constructor(eventNameHash: string, eventAddress: string);
+}
+/**
+ * @category exception
+ */
+export declare class AmbiguousEventDefinitionError extends ContractError {
+    constructor(eventAddress: string, matchedEvents: Array<[
+        string,
+        string
+    ]>);
+}
+/**
+ * @category exception
+ */
+export declare class InvalidChecksumError extends CryptographyError {
+    constructor();
+}
+/**
+ * @category exception
+ */
+export declare class InvalidPasswordError extends CryptographyError {
+    constructor();
+}
+/**
+ * @category exception
+ */
+export declare class MerkleTreeHashMismatchError extends CryptographyError {
+    constructor();
+}
+/**
+ * @category exception
+ */
+export declare class MissingNodeInTreeError extends CryptographyError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class UnknownNodeLengthError extends CryptographyError {
+    constructor(nodeLength: number);
+}
+/**
+ * @category exception
+ */
+export declare class UnknownPathNibbleError extends CryptographyError {
+    constructor(nibble: number);
+}
+/**
+ * @category exception
+ */
+export declare class DuplicateNodeError extends NodeError {
+    constructor(name: string);
+}
+/**
+ * @category exception
+ */
+export declare class NodeNotFoundError extends NodeError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class DecodeError extends TransactionError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class PayloadLengthError extends TransactionError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class DryRunError extends TransactionError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class IllegalBidFeeError extends TransactionError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class InvalidSignatureError extends TransactionError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class InvalidTxParamsError extends TransactionError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class PrefixNotFoundError extends TransactionError {
+    constructor(tag: number);
+}
+/**
+ * @category exception
+ */
+export declare class SchemaNotFoundError extends TransactionError {
+    constructor(schemaName: string, key: string, version: number);
+}
+/**
+ * @category exception
+ */
+export declare class TagNotFoundError extends TransactionError {
+    constructor(prefix: string);
+}
+/**
+ * @category exception
+ */
+export declare class TxNotInChainError extends TransactionError {
+    constructor(txHash: string);
+}
+/**
+ * @category exception
+ */
+export declare class UnsupportedABIversionError extends TransactionError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class UnsupportedVMversionError extends TransactionError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class AlreadyConnectedError extends WalletError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class NoWalletConnectedError extends WalletError {
+    constructor(message: string);
+}
+/**
+ * @category exception
+ */
+export declare class RpcConnectionError extends WalletError {
+    constructor(message: string);
+}

package/types-legacy/ts4.2/utils/hd-wallet.d.ts

@@ -0,0 +1,65 @@
+import nacl from 'tweetnacl';
+import { CryptographyError } from './errors';
+/**
+ * @category exception
+ */
+export declare class DerivationError extends CryptographyError {
+    constructor(message: string);
+}
+interface KeyTreeNode {
+    secretKey: Uint8Array;
+    chainCode: Uint8Array;
+}
+interface HDWallet {
+    secretKey: string;
+    chainCode: string;
+}
+interface Account {
+    secretKey: string;
+    publicKey: string;
+}
+type Dec<N extends number> = [
+    -1,
+    0,
+    1,
+    2,
+    3,
+    4
+][N];
+type Bip32PathT<MaxLen extends number, H extends 'H' | 'h' | '\''> = MaxLen extends -1 ? `${number}${H}` : Bip32PathT<Dec<MaxLen>, H> | `${Bip32PathT<Dec<MaxLen>, H>}/${number}${H}`;
+type Bip32Path<MaxLen extends number> = '' | Bip32PathT<MaxLen, 'H'> | Bip32PathT<MaxLen, 'h'> | Bip32PathT<MaxLen, '\''>;
+/**
+ * @category hd-wallet
+ */
+export declare function deriveChild({ secretKey, chainCode }: KeyTreeNode, index: number): KeyTreeNode;
+/**
+ * @category hd-wallet
+ */
+export declare function derivePathFromKey(path: Bip32Path<5>, key: KeyTreeNode): KeyTreeNode;
+/**
+ * @category hd-wallet
+ */
+export declare function getMasterKeyFromSeed(seed: Uint8Array): KeyTreeNode;
+/**
+ * @category hd-wallet
+ */
+export declare function derivePathFromSeed(path: 'm' | `m/${Bip32Path<5>}`, seed: Uint8Array): KeyTreeNode;
+/**
+ * @category hd-wallet
+ */
+export declare function getKeyPair(secretKey: Uint8Array): nacl.SignKeyPair;
+/**
+ * @category hd-wallet
+ */
+export declare function generateSaveHDWalletFromSeed(seed: Uint8Array, password: string): HDWallet;
+/**
+ * @category hd-wallet
+ */
+export declare function getSaveHDWalletAccounts(saveHDWallet: HDWallet, password: string, accountCount: number): Account[];
+/**
+ * @category hd-wallet
+ */
+export declare const getHdWalletAccountFromSeed: (seed: Uint8Array, accountIdx: number) => Account & {
+    idx: number;
+};
+export {};

package/types-legacy/ts4.2/utils/json-big.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    stringify: (value: any, replacer?: (string | number)[] | null | undefined, space?: string | number | undefined) => string;
+    parse: (text: string, reviver?: ((this: any, key: string, value: any) => any) | undefined) => any;
+};
+export default _default;

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

@@ -0,0 +1,53 @@
+import nacl from 'tweetnacl';
+declare const DERIVED_KEY_FUNCTIONS: {
+    argon2id(pass: string | Uint8Array, salt: string | Uint8Array, params: Partial<Keystore['crypto']['kdf_params']>): Promise<Uint8Array>;
+};
+declare const CRYPTO_FUNCTIONS: {
+    'xsalsa20-poly1305': {
+        encrypt: nacl.secretbox;
+        decrypt(box: Uint8Array, nonce: Uint8Array, key: Uint8Array): Uint8Array;
+    };
+};
+export interface Keystore {
+    name: string;
+    version: 1;
+    public_key: string;
+    id: string;
+    crypto: {
+        secret_type: 'ed25519';
+        symmetric_alg: keyof typeof CRYPTO_FUNCTIONS;
+        ciphertext: string;
+        cipher_params: {
+            nonce: string;
+        };
+        kdf: keyof typeof DERIVED_KEY_FUNCTIONS;
+        kdf_params: {
+            memlimit_kib: number;
+            opslimit: number;
+            parallelism: number;
+            salt: string;
+        };
+    };
+}
+/**
+ * Recover plaintext private key from secret-storage key object.
+ * @category keystore
+ * @param password - Keystore object password.
+ * @param keystore - Keystore object.
+ * @returns Plaintext private key.
+ */
+export declare function recover(password: string | Uint8Array, { crypto }: Keystore): Promise<string>;
+/**
+ * Export private key to keystore secret-storage format.
+ * @category keystore
+ * @param name - Key name.
+ * @param password - User-supplied password.
+ * @param privateKey - Private key as hex-string or a Buffer.
+ * @param nonce - Randomly generated 24byte nonce.
+ * @param salt - Randomly generated 16byte salt.
+ * @param options - Encryption parameters.
+ * @param options.kdf - Key derivation function.
+ * @param options.kdf_params - KDF parameters.
+ */
+export declare function dump(name: string, password: string | Uint8Array, privateKey: string | Uint8Array, nonce?: Uint8Array, salt?: Uint8Array, options?: Partial<Keystore['crypto']>): Promise<Keystore>;
+export {};

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

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+export declare const pause: (duration: number) => Promise<void>;
+export declare const mapObject: <InputV, OutputV>(object: {
+    [k: string]: InputV;
+}, fn: (value: [
+    string,
+    InputV
+], index: number, array: [
+    string,
+    InputV
+][]) => [
+    string | number,
+    OutputV
+]) => {
+    [k: string]: OutputV;
+};
+export declare const concatBuffers: typeof Buffer.concat;
+/**
+ * Object key type guard
+ * @param key - Maybe object key
+ * @param object - Object
+ */
+export declare function isKeyOfObject<T extends object>(key: string | number | symbol, object: T): key is keyof T;
+/**
+ * Array item type guard
+ * @param item - Maybe array item
+ * @param array - Array
+ */
+export declare function isItemOfArray<T>(item: any, array: readonly T[]): item is T;
+export declare function isAccountNotFoundError(error: Error): boolean;
+export type UnionToIntersection<Union> = (Union extends any ? (k: Union) => void : never) extends ((k: infer Intersection) => void) ? Intersection : never;

package/types-legacy/ts4.2/utils/semver-satisfies.d.ts

@@ -0,0 +1 @@
+export default function semverSatisfies(version: string, geVersion: string, ltVersion: string): boolean;

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

@@ -0,0 +1,12 @@
+/**
+ * Convert string from snake_case to PascalCase
+ * @param s - String to convert
+ * @returns Converted string
+ */
+export declare function snakeToPascal(s: string): string;
+/**
+ * Convert string from PascalCase to snake_case
+ * @param s - String to convert
+ * @returns Converted string
+ */
+export declare function pascalToSnake(s: string): string;

package/types-legacy/ts4.5/AeSdk.d.ts

@@ -0,0 +1,41 @@
+import AeSdkBase from './AeSdkBase';
+import { OnAccount } from './AeSdkMethods';
+import AccountBase from './account/Base';
+import { Encoded } from './utils/encoder';
+export default class AeSdk extends AeSdkBase {
+    accounts: {
+        [key: Encoded.AccountAddress]: AccountBase;
+    };
+    selectedAddress?: Encoded.AccountAddress;
+    constructor({ accounts, ...options }?: {
+        accounts?: AccountBase[];
+    } & ConstructorParameters<typeof AeSdkBase>[0]);
+    _resolveAccount(account?: OnAccount): AccountBase;
+    /**
+     * Get accounts addresses
+     * @example addresses()
+     */
+    addresses(): Encoded.AccountAddress[];
+    /**
+     * Add specific account
+     * @param account - Account instance
+     * @param options - Options
+     * @param options.select - Select account
+     * @example addAccount(account)
+     */
+    addAccount(account: AccountBase, { select }?: {
+        select?: boolean;
+    }): void;
+    /**
+     * Remove specific account
+     * @param address - Address of account to remove
+     * @example removeAccount(address)
+     */
+    removeAccount(address: Encoded.AccountAddress): void;
+    /**
+     * Select specific account
+     * @param address - Address of account to select
+     * @example selectAccount('ak_xxxxxxxx')
+     */
+    selectAccount(address: Encoded.AccountAddress): void;
+}