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

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

@@ -0,0 +1,71 @@
+import AeSdkBase from './AeSdkBase';
+import { OnAccount } from './AeSdkMethods';
+import AccountBase from './account/Base';
+import { Encoded } from './utils/encoder';
+import { Accounts, WalletInfo, Network, WalletApi, AeppApi } from './aepp-wallet-communication/rpc/types';
+import RpcClient from './aepp-wallet-communication/rpc/RpcClient';
+import { METHODS, SUBSCRIPTION_TYPES } from './aepp-wallet-communication/schema';
+import BrowserConnection from './aepp-wallet-communication/connection/Browser';
+/**
+ * RPC handler for AEPP side
+ * Contain functionality for wallet interaction and connect it to sdk
+ * @category aepp wallet communication
+ */
+export default class AeSdkAepp extends AeSdkBase {
+    name: string;
+    onAddressChange: (a: Accounts) => void;
+    onDisconnect: (p: any) => void;
+    onNetworkChange: (a: Network) => void;
+    rpcClient?: RpcClient<WalletApi, AeppApi>;
+    _accounts?: Accounts;
+    /**
+     * @param options - Options
+     * @param options.name - Aepp name
+     * @param options.onAddressChange - Call-back function for update address event
+     * @param options.onDisconnect - Call-back function for disconnect event
+     * @param options.onNetworkChange - Call-back function for update network event
+     */
+    constructor({ name, onAddressChange, onDisconnect, onNetworkChange, ...other }: {
+        name: string;
+        onAddressChange?: (a: Accounts) => void;
+        onDisconnect?: (p: any) => void;
+        onNetworkChange?: (a: Network) => void;
+    } & ConstructorParameters<typeof AeSdkBase>[0]);
+    _resolveAccount(account?: OnAccount): AccountBase;
+    addresses(): Encoded.AccountAddress[];
+    /**
+     * Connect to wallet
+     * @param connection - Wallet connection object
+     * @param options - Options
+     * @param options.connectNode - Request wallet to bind node
+     * @param options.name - Node name
+     * @param options.select - Select this node as current
+     */
+    connectToWallet(connection: BrowserConnection, { connectNode, name, select }?: {
+        connectNode?: boolean;
+        name?: string;
+        select?: boolean;
+    }): Promise<WalletInfo>;
+    /**
+     * Disconnect from wallet
+     */
+    disconnectWallet(): void;
+    /**
+     * Ask addresses from wallet
+     * @returns Addresses from wallet
+     */
+    askAddresses(): Promise<Encoded.AccountAddress[]>;
+    /**
+     * Subscribe for addresses from wallet
+     * @param type - Subscription type
+     * @param value - Should be one of 'current' (the selected account), 'connected' (all)
+     * @returns Accounts from wallet
+     */
+    subscribeAddress(type: SUBSCRIPTION_TYPES, value: 'current' | 'connected'): Promise<ReturnType<WalletApi[METHODS.subscribeAddress]>>;
+    _ensureConnected(): asserts this is AeSdkAepp & {
+        rpcClient: NonNullable<AeSdkAepp['rpcClient']>;
+    };
+    _ensureAccountAccess(): asserts this is AeSdkAepp & {
+        rpcClient: NonNullable<AeSdkAepp['rpcClient']>;
+    };
+}

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

@@ -0,0 +1,91 @@
+import Node from './Node';
+import AccountBase from './account/Base';
+import { Encoded } from './utils/encoder';
+import CompilerBase from './contract/compiler/Base';
+import AeSdkMethods, { OnAccount } from './AeSdkMethods';
+type NodeInfo = Awaited<ReturnType<Node['getNodeInfo']>> & {
+    name: string;
+};
+/**
+ * Basic AeSdk class implements:
+ * - node selector,
+ * - integrated compiler support,
+ * - wrappers of account methods mapped to the current account.
+ */
+export default class AeSdkBase extends AeSdkMethods {
+    pool: Map<string, Node>;
+    selectedNodeName?: string;
+    /**
+     * @param options - Options
+     * @param options.nodes - Array of nodes
+     */
+    constructor({ nodes, ...options }?: ConstructorParameters<typeof AeSdkMethods>[0] & {
+        nodes?: Array<{
+            name: string;
+            instance: Node;
+        }>;
+    });
+    get compilerApi(): CompilerBase;
+    get api(): Node;
+    /**
+     * Add Node
+     * @param name - Node name
+     * @param node - Node instance
+     * @param select - Select this node as current
+     * @example
+     * ```js
+     * // add and select new node with name 'testNode'
+     * aeSdkBase.addNode('testNode', new Node({ url }), true)
+     * ```
+     */
+    addNode(name: string, node: Node, select?: boolean): void;
+    /**
+     * Select Node
+     * @param name - Node name
+     * @example
+     * nodePool.selectNode('testNode')
+     */
+    selectNode(name: string): void;
+    /**
+     * Check if you have selected node
+     * @example
+     * nodePool.isNodeConnected()
+     */
+    isNodeConnected(): this is AeSdkBase & {
+        selectedNodeName: string;
+    };
+    protected ensureNodeConnected(): asserts this is AeSdkBase & {
+        selectedNodeName: string;
+    };
+    /**
+     * Get information about node
+     * @example
+     * ```js
+     * nodePool.getNodeInfo() // { name, version, networkId, protocol, ... }
+     * ```
+     */
+    getNodeInfo(): Promise<NodeInfo>;
+    /**
+     * Get array of available nodes
+     * @example
+     * nodePool.getNodesInPool()
+     */
+    getNodesInPool(): Promise<NodeInfo[]>;
+    addresses(): Encoded.AccountAddress[];
+    get address(): Encoded.AccountAddress;
+    sign(data: string | Uint8Array, { onAccount, ...options }?: {
+        onAccount?: OnAccount;
+    }): Promise<Uint8Array>;
+    signTransaction(tx: Encoded.Transaction, { onAccount, ...options }?: {
+        onAccount?: OnAccount;
+    } & Parameters<AccountBase['signTransaction']>[1]): Promise<Encoded.Transaction>;
+    signMessage(message: string, { onAccount, ...options }?: {
+        onAccount?: OnAccount;
+    } & Parameters<AccountBase['signMessage']>[1]): Promise<Uint8Array>;
+    _getOptions(): {
+        onNode: Node;
+        onAccount: AccountBase;
+        onCompiler: CompilerBase;
+    };
+}
+export {};

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

@@ -0,0 +1,140 @@
+import * as chainMethods from './chain';
+import * as aensMethods from './aens';
+import * as spendMethods from './spend';
+import * as oracleMethods from './oracle';
+import Contract, { ContractMethodsBase } from './contract/Contract';
+import * as contractGaMethods from './contract/ga';
+import { _buildTx } from './tx';
+import { UnionToIntersection } from './utils/other';
+import Node from './Node';
+import { Tag } from './tx/builder/constants';
+import AccountBase from './account/Base';
+import { Encoded } from './utils/encoder';
+import CompilerBase from './contract/compiler/Base';
+export type OnAccount = Encoded.AccountAddress | AccountBase | undefined;
+export declare function getValueOrErrorProxy<Value extends object>(valueCb: () => Value): Value;
+declare const methods: {
+    readonly createGeneralizedAccount: typeof contractGaMethods.createGeneralizedAccount;
+    readonly buildAuthTxHash: typeof contractGaMethods.buildAuthTxHash;
+    readonly pollForQueries: typeof oracleMethods.pollForQueries;
+    readonly pollForQueryResponse: typeof oracleMethods.pollForQueryResponse;
+    readonly getQueryObject: typeof oracleMethods.getQueryObject;
+    readonly postQueryToOracle: typeof oracleMethods.postQueryToOracle;
+    readonly extendOracleTtl: typeof oracleMethods.extendOracleTtl;
+    readonly respondToQuery: typeof oracleMethods.respondToQuery;
+    readonly getOracleObject: typeof oracleMethods.getOracleObject;
+    readonly registerOracle: typeof oracleMethods.registerOracle;
+    readonly send: typeof spendMethods.send;
+    readonly spend: typeof spendMethods.spend;
+    readonly transferFunds: typeof spendMethods.transferFunds;
+    readonly payForTransaction: typeof spendMethods.payForTransaction;
+    readonly aensRevoke: typeof aensMethods.aensRevoke;
+    readonly aensUpdate: typeof aensMethods.aensUpdate;
+    readonly aensTransfer: typeof aensMethods.aensTransfer;
+    readonly aensQuery: typeof aensMethods.aensQuery;
+    readonly aensClaim: typeof aensMethods.aensClaim;
+    readonly aensPreclaim: typeof aensMethods.aensPreclaim;
+    readonly aensBid: typeof aensMethods.aensBid;
+    readonly _getPollInterval: typeof chainMethods._getPollInterval;
+    readonly getHeight: typeof chainMethods.getHeight;
+    readonly poll: typeof chainMethods.poll;
+    readonly awaitHeight: typeof chainMethods.awaitHeight;
+    readonly waitForTxConfirm: typeof chainMethods.waitForTxConfirm;
+    readonly sendTransaction: typeof chainMethods.sendTransaction;
+    readonly getAccount: typeof chainMethods.getAccount;
+    readonly getBalance: typeof chainMethods.getBalance;
+    readonly getCurrentGeneration: typeof chainMethods.getCurrentGeneration;
+    readonly getGeneration: typeof chainMethods.getGeneration;
+    readonly getMicroBlockTransactions: typeof chainMethods.getMicroBlockTransactions;
+    readonly getKeyBlock: typeof chainMethods.getKeyBlock;
+    readonly getMicroBlockHeader: typeof chainMethods.getMicroBlockHeader;
+    readonly txDryRun: typeof chainMethods.txDryRun;
+    readonly getContractByteCode: typeof chainMethods.getContractByteCode;
+    readonly getContract: typeof chainMethods.getContract;
+    readonly getName: typeof chainMethods.getName;
+    readonly resolveName: typeof chainMethods.resolveName;
+};
+type Decrement<Number extends number> = [
+    -1,
+    0,
+    1,
+    2,
+    3,
+    4,
+    5
+][Number];
+type GetMethodsOptions<Methods extends {
+    [key: string]: Function;
+}> = {
+    [Name in keyof Methods]: Methods[Name] extends (...args: infer Args) => any ? Args[Decrement<Args['length']>] : never;
+};
+type MethodsOptions = GetMethodsOptions<typeof methods>;
+interface AeSdkMethodsOptions extends Partial<UnionToIntersection<MethodsOptions[keyof MethodsOptions]>> {
+    nodes?: Array<{
+        name: string;
+        instance: Node;
+    }>;
+}
+/**
+ * AeSdkMethods is the composition of:
+ * - chain methods
+ * - tx methods
+ * - aens methods
+ * - spend methods
+ * - oracle methods
+ * - contract methods
+ * - contract ga methods
+ *
+ * While these methods can be used separately, this class provides a handy way to store
+ * their context (current account, network, and compiler to use).
+ */
+declare class AeSdkMethods {
+    _options: AeSdkMethodsOptions;
+    /**
+     * @param options - Options
+     */
+    constructor(options?: AeSdkMethodsOptions);
+    /**
+     * Resolves an account
+     * @param account - ak-address, instance of AccountBase, or keypair
+     */
+    _resolveAccount(account?: OnAccount): AccountBase;
+    _getOptions(): AeSdkMethodsOptions & {
+        onAccount: AccountBase;
+    };
+    buildTx<TxType extends Tag>(txType: TxType, options: Omit<Parameters<any>[1], 'onNode'> & {
+        onNode?: Node;
+    }): Promise<Encoded.Transaction>;
+    initializeContract<Methods extends ContractMethodsBase>(options?: Omit<Parameters<typeof Contract.initialize>[0], 'onNode'> & {
+        onNode?: Node;
+    }): Promise<Contract<Methods>>;
+}
+type RequiredKeys<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
+}[keyof T];
+type OptionalIfNotRequired<T extends [
+    any
+]> = RequiredKeys<T[0]> extends never ? T | [
+] : T;
+type MakeOptional<Options> = OptionalIfNotRequired<[
+    Omit<Options, 'onNode' | 'onCompiler' | 'onAccount'> & {
+        onNode?: Node;
+        onCompiler?: CompilerBase;
+        onAccount?: OnAccount;
+    }
+]>;
+type TransformMethods<Methods extends {
+    [key: string]: Function;
+}> = {
+    [Name in keyof Methods]: Methods[Name] extends (...args: [
+        ...infer Args,
+        infer Options
+    ]) => infer Ret ? (...args: [
+        ...Args,
+        ...MakeOptional<Options>
+    ]) => Ret : never;
+};
+interface AeSdkMethodsTransformed extends TransformMethods<typeof methods> {
+}
+declare const _default: new (options?: ConstructorParameters<typeof AeSdkMethods>[0]) => AeSdkMethods & AeSdkMethodsTransformed;
+export default _default;

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

@@ -0,0 +1,90 @@
+import AeSdk from './AeSdk';
+import RpcClient from './aepp-wallet-communication/rpc/RpcClient';
+import { METHODS, RPC_STATUS, WALLET_TYPE } from './aepp-wallet-communication/schema';
+import AccountBase from './account/Base';
+import BrowserConnection from './aepp-wallet-communication/connection/Browser';
+import { Accounts, AeppApi, Network, WalletApi, WalletInfo } from './aepp-wallet-communication/rpc/types';
+import { Encoded } from './utils/encoder';
+type RpcClientWallet = RpcClient<AeppApi, WalletApi>;
+type OnConnection = (clientId: string, params: Omit<Parameters<WalletApi[METHODS.connect]>[0], 'version'>, origin: string) => void;
+type OnSubscription = (clientId: string, params: Parameters<WalletApi[METHODS.subscribeAddress]>[0], origin: string) => void;
+type OnDisconnect = (clientId: string, params: Parameters<WalletApi[METHODS.closeConnection]>[0]) => void;
+type OnAskAccounts = (clientId: string, params: undefined, origin: string) => void;
+interface RpcClientsInfo {
+    id: string;
+    status: RPC_STATUS;
+    connectNode: boolean;
+    addressSubscription: Set<'connected' | 'current'>;
+    rpc: RpcClientWallet;
+}
+/**
+ * Contain functionality for aepp interaction and managing multiple aepps
+ * @category aepp wallet communication
+ */
+export default class AeSdkWallet extends AeSdk {
+    id: string;
+    _type: WALLET_TYPE;
+    name: string;
+    _clients: Map<string, RpcClientsInfo>;
+    onConnection: OnConnection;
+    onSubscription: OnSubscription;
+    onDisconnect: OnDisconnect;
+    onAskAccounts: OnAskAccounts;
+    /**
+     * @param options - Options
+     * @param options.name - Wallet name
+     * @param options.id - Wallet id
+     * @param options.type - Wallet type
+     * @param options.onConnection - Call-back function for incoming AEPP connection
+     * @param options.onSubscription - Call-back function for incoming AEPP account subscription
+     * @param options.onAskAccounts - Call-back function for incoming AEPP get address request
+     * @param options.onDisconnect - Call-back function for disconnect event
+     */
+    constructor({ name, id, type, onConnection, onSubscription, onDisconnect, onAskAccounts, ...options }: {
+        id: string;
+        type: WALLET_TYPE;
+        name: string;
+        onConnection: OnConnection;
+        onSubscription: OnSubscription;
+        onDisconnect: OnDisconnect;
+        onAskAccounts: OnAskAccounts;
+    } & ConstructorParameters<typeof AeSdk>[0]);
+    _pushAccountsToApps(): void;
+    selectAccount(address: Encoded.AccountAddress): void;
+    addAccount(account: AccountBase, options?: Parameters<AeSdk['addAccount']>[1]): void;
+    _getNode(): {
+        node: Network['node'];
+    };
+    selectNode(name: string): Promise<void>;
+    _getClient(clientId: string): RpcClientsInfo;
+    _isRpcClientSubscribed(clientId: string): boolean;
+    _isRpcClientConnected(clientId: string): boolean;
+    _disconnectRpcClient(clientId: string): void;
+    /**
+     * Remove specific RpcClient by ID
+     * @param id - Client ID
+     */
+    removeRpcClient(id: string): void;
+    /**
+     * Add new client by AEPP connection
+     * @param clientConnection - AEPP connection object
+     * @returns Client ID
+     */
+    addRpcClient(clientConnection: BrowserConnection): string;
+    /**
+     * Send shareWalletInfo message to notify AEPP about wallet
+     * @param clientId - ID of RPC client send message to
+     */
+    shareWalletInfo(clientId: string): Promise<void>;
+    /**
+     * Get Wallet info object
+     * @returns Object with wallet information
+     */
+    getWalletInfo(): Promise<WalletInfo>;
+    /**
+     * Get Wallet accounts
+     * @returns Object with accounts information (\{ connected: Object, current: Object \})
+     */
+    getAccounts(): Accounts;
+}
+export {};

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

@@ -0,0 +1,78 @@
+import { Node as NodeApi, NodeOptionalParams } from './apis/node';
+import { Encoded } from './utils/encoder';
+import { ConsensusProtocolVersion } from './tx/builder/constants';
+declare const bigIntPropertyNames: readonly [
+    "balance",
+    "queryFee",
+    "fee",
+    "amount",
+    "nameFee",
+    "channelAmount",
+    "initiatorAmount",
+    "responderAmount",
+    "channelReserve",
+    "initiatorAmountFinal",
+    "responderAmountFinal",
+    "gasPrice",
+    "deposit"
+];
+declare const numberPropertyNames: readonly [
+    "time",
+    "gas",
+    "gasUsed",
+    "nameSalt",
+    "nonce",
+    "nextNonce",
+    "height",
+    "blockHeight",
+    "topBlockHeight",
+    "ttl",
+    "nameTtl",
+    "clientTtl",
+    "inbound",
+    "outbound",
+    "peerCount",
+    "pendingTransactionsCount",
+    "effectiveAtHeight",
+    "version",
+    "solutions",
+    "round"
+];
+type BigIntPropertyNames = typeof bigIntPropertyNames[number];
+type NumberPropertyNames = typeof numberPropertyNames[number];
+type PreserveOptional<NewType, OrigType> = OrigType extends undefined ? NewType | undefined : NewType;
+export type TransformNodeType<Type> = Type extends (...args: infer Args) => infer Ret ? (...args: TransformNodeType<Args>) => TransformNodeType<Ret> : Type extends [
+    infer Item,
+    ...infer Rest
+] ? [
+    TransformNodeType<Item>,
+    ...TransformNodeType<Rest>
+] : Type extends Array<infer Item> ? Array<TransformNodeType<Item>> : Type extends Promise<infer T> ? Promise<TransformNodeType<T>> : Type extends {
+    [P in any]: any;
+} ? {
+    [Property in keyof Type]: Property extends BigIntPropertyNames ? PreserveOptional<bigint, Type[Property]> : Property extends NumberPropertyNames ? PreserveOptional<number, Type[Property]> : Property extends 'txHash' ? PreserveOptional<Encoded.TxHash, Type[Property]> : Property extends 'bytecode' ? PreserveOptional<Encoded.ContractBytearray, Type[Property]> : TransformNodeType<Type[Property]>;
+} : Type;
+type NodeTransformedApi = new (...args: ConstructorParameters<typeof NodeApi>) => {
+    [Name in keyof InstanceType<typeof NodeApi>]: Name extends 'pipeline' | 'sendRequest' | 'sendOperationRequest' ? NodeApi[Name] : TransformNodeType<NodeApi[Name]>;
+};
+export interface NodeInfo {
+    url: string;
+    nodeNetworkId: string;
+    version: string;
+    consensusProtocolVersion: ConsensusProtocolVersion;
+}
+declare const Node_base: NodeTransformedApi;
+export default class Node extends Node_base {
+    #private;
+    /**
+     * @param url - Url for node API
+     * @param options - Options
+     * @param options.ignoreVersion - Don't check node version
+     */
+    constructor(url: string, { ignoreVersion, ...options }?: NodeOptionalParams & {
+        ignoreVersion?: boolean;
+    });
+    getNetworkId(): Promise<string>;
+    getNodeInfo(): Promise<NodeInfo>;
+}
+export {};

package/types-legacy/ts4.5/account/Base.d.ts

@@ -0,0 +1,52 @@
+import { Encoded } from '../utils/encoder';
+import Node from '../Node';
+import CompilerBase from '../contract/compiler/Base';
+/**
+ * Account is one of the three basic building blocks of an
+ * {@link AeSdk} and provides access to a signing key pair.
+ */
+export default abstract class AccountBase {
+    /**
+     * Sign encoded transaction
+     * @param tx - Transaction to sign
+     * @param options - Options
+     * @param options.innerTx - Sign as inner transaction for PayingFor
+     * @param options.authData - Object with gaMeta params
+     * @returns Signed transaction
+     */
+    abstract signTransaction(tx: Encoded.Transaction, options: {
+        innerTx?: boolean;
+        networkId?: string;
+        authData?: {
+            gasLimit?: number;
+            callData?: Encoded.ContractBytearray;
+            sourceCode?: string;
+            args?: any[];
+        };
+        onNode?: Node;
+        onCompiler?: CompilerBase;
+        aeppOrigin?: string;
+        aeppRpcClientId?: string;
+    }): Promise<Encoded.Transaction>;
+    /**
+     * Sign message
+     * @param message - Message to sign
+     * @param options - Options
+     * @returns Signature as hex string of Uint8Array
+     */
+    abstract signMessage(message: string, options?: {
+        aeppOrigin?: string;
+        aeppRpcClientId?: string;
+    }): Promise<Uint8Array>;
+    /**
+     * Sign data blob
+     * @param data - Data blob to sign
+     * @param options - Options
+     * @returns Signed data blob
+     */
+    abstract sign(data: string | Uint8Array, options?: any): Promise<Uint8Array>;
+    /**
+     * Account address
+     */
+    readonly address: Encoded.AccountAddress;
+}

package/types-legacy/ts4.5/account/Generalized.d.ts

@@ -0,0 +1,16 @@
+import AccountBase from './Base';
+import { Encoded } from '../utils/encoder';
+/**
+ * Generalized account class
+ */
+export default class AccountGeneralized extends AccountBase {
+    #private;
+    readonly address: Encoded.AccountAddress;
+    /**
+     * @param address - Address of generalized account
+     */
+    constructor(address: Encoded.AccountAddress);
+    sign(): Promise<Uint8Array>;
+    signMessage(): Promise<Uint8Array>;
+    signTransaction(tx: Encoded.Transaction, { authData, onCompiler, onNode }: Parameters<AccountBase['signTransaction']>[1]): Promise<Encoded.Transaction>;
+}

package/types-legacy/ts4.5/account/Ledger.d.ts

@@ -0,0 +1,28 @@
+import type Transport from '@ledgerhq/hw-transport';
+import AccountBase from './Base';
+import { Encoded } from '../utils/encoder';
+export declare const CLA = 224;
+export declare const GET_ADDRESS = 2;
+export declare const SIGN_TRANSACTION = 4;
+export declare const GET_APP_CONFIGURATION = 6;
+export declare const SIGN_PERSONAL_MESSAGE = 8;
+/**
+ * Ledger wallet account class
+ */
+export default class AccountLedger extends AccountBase {
+    readonly transport: Transport;
+    readonly address: Encoded.AccountAddress;
+    readonly index: number;
+    /**
+     * @param transport - Connection to Ledger to use
+     * @param index - Index of account
+     * @param address - Address of account
+     */
+    constructor(transport: Transport, index: number, address: Encoded.AccountAddress);
+    sign(): Promise<Uint8Array>;
+    signTransaction(tx: Encoded.Transaction, { innerTx, networkId }?: {
+        innerTx?: boolean;
+        networkId?: string;
+    }): Promise<Encoded.Transaction>;
+    signMessage(messageStr: string): Promise<Uint8Array>;
+}

package/types-legacy/ts4.5/account/LedgerFactory.d.ts

@@ -0,0 +1,39 @@
+import type Transport from '@ledgerhq/hw-transport';
+import AccountLedger from './Ledger';
+import { Encoded } from '../utils/encoder';
+import Node from '../Node';
+/**
+ * A factory class that generates instances of AccountLedger based on provided transport.
+ */
+export default class AccountLedgerFactory {
+    readonly transport: Transport;
+    private readonly versionCheckPromise;
+    /**
+     * @param transport - Connection to Ledger to use
+     */
+    constructor(transport: Transport);
+    /**
+     * @returns the version of app installed on Ledger wallet
+     */
+    getAppConfiguration(): Promise<{
+        version: string;
+    }>;
+    /**
+     * Get `ak_`-prefixed address for a given account index.
+     * @param accountIndex - Index of account
+     * @param verify - Ask user to confirm address by showing it on the device screen
+     */
+    getAddress(accountIndex: number, verify?: boolean): Promise<Encoded.AccountAddress>;
+    /**
+     * Get an instance of AccountLedger for a given account index.
+     * @param accountIndex - Index of account
+     */
+    initialize(accountIndex: number): Promise<AccountLedger>;
+    /**
+     * Discovers accounts on Ledger that already have been used (has any on-chain transactions).
+     * It returns an empty array if none of accounts been used.
+     * If a used account is preceded by an unused account then it would be ignored.
+     * @param node - Instance of Node to get account information from
+     */
+    discover(node: Node): Promise<AccountLedger[]>;
+}

package/types-legacy/ts4.5/account/Memory.d.ts

@@ -0,0 +1,22 @@
+import AccountBase from './Base';
+import { Encoded } from '../utils/encoder';
+/**
+ * In-memory account class
+ */
+export default class AccountMemory extends AccountBase {
+    readonly address: Encoded.AccountAddress;
+    /**
+     * @param secretKey - Secret key
+     */
+    constructor(secretKey: string | Uint8Array);
+    /**
+     * Generates a new AccountMemory using a random secret key
+     */
+    static generate(): AccountMemory;
+    sign(data: string | Uint8Array, options?: any): Promise<Uint8Array>;
+    signTransaction(tx: Encoded.Transaction, { innerTx, networkId, ...options }?: {
+        innerTx?: boolean;
+        networkId?: string;
+    }): Promise<Encoded.Transaction>;
+    signMessage(message: string, options?: any): Promise<Uint8Array>;
+}

package/types-legacy/ts4.5/account/Rpc.d.ts

@@ -0,0 +1,25 @@
+import AccountBase from './Base';
+import { Encoded } from '../utils/encoder';
+import RpcClient from '../aepp-wallet-communication/rpc/RpcClient';
+import { AeppApi, WalletApi } from '../aepp-wallet-communication/rpc/types';
+/**
+ * Account provided by wallet
+ * @param params - Params
+ * @param params.rpcClient - RpcClient instance
+ * @param params.address - RPC account address
+ * @returns AccountRpc instance
+ */
+export default class AccountRpc extends AccountBase {
+    _rpcClient: RpcClient<WalletApi, AeppApi>;
+    readonly address: Encoded.AccountAddress;
+    constructor(rpcClient: RpcClient<WalletApi, AeppApi>, address: Encoded.AccountAddress);
+    sign(): Promise<Uint8Array>;
+    /**
+     * @returns Signed transaction
+     */
+    signTransaction(tx: Encoded.Transaction, { innerTx, networkId }?: Parameters<AccountBase['signTransaction']>[1]): Promise<Encoded.Transaction>;
+    /**
+     * @returns Signed message
+     */
+    signMessage(message: string): Promise<Uint8Array>;
+}