@asichain/asi-wallet-sdk 0.1.5 → 1.0.0

package/dist/index.d.ts

@@ -1,10 +1,103 @@
-import { BIP32Interface } from 'bip32';
 import { AxiosRequestConfig, AxiosInstance } from 'axios';
+import { BIP32Interface } from 'bip32';
+
+declare const NATIVE_TOKEN_DECIMALS_AMOUNT: number;
+declare const DEFAULT_PHLO_LIMIT: number;
+declare const DEFAULT_PHLO_PRICE: number;
+declare const DEFAULT_NODE_STORAGE_DIR: string;
+declare const GasFee: {
+    MIN: bigint;
+    MAX: bigint;
+};
+declare const DEPLOY_STATUS_POLLING_TIMEOUT: number;
+declare const RESERVATION_EXPIRATION_TIME: number;
+
+type AssetId = string;
+type Assets = Map<AssetId, Asset>;
+
+interface IAssetOptions {
+    id: string;
+    name: string;
+    decimals?: number;
+    contractAddress?: string;
+}
+declare class Asset {
+    private readonly id;
+    private readonly name;
+    private readonly decimals;
+    private readonly contractAddress;
+    constructor({ id, name, decimals, contractAddress }: IAssetOptions);
+    getId(): string;
+    getName(): string;
+    getDecimals(): number;
+    getContractAddress(): string | null;
+}
+declare const DEFAULT_ASSET: Asset;
+
+interface IBip44PathOptions {
+    coinType: number;
+    account?: number;
+    change?: number;
+    index?: number;
+}
+declare class Bip44Path {
+    private static readonly BIP44_PURPOSE;
+    private static readonly MIN_CHANGE;
+    private static readonly MAX_CHANGE;
+    private static readonly PATH_COMPONENTS_COUNT;
+    private static readonly PURPOSE_INDEX;
+    private static readonly COIN_TYPE_INDEX;
+    private static readonly ACCOUNT_INDEX;
+    private static readonly CHANGE_INDEX;
+    private static readonly INDEX_COMPONENT_INDEX;
+    private static readonly DECIMAL_RADIX;
+    private coinType;
+    private account;
+    private change;
+    private index;
+    constructor({ coinType, account, change, index, }: IBip44PathOptions);
+    static parse(pathString: string): Bip44Path;
+    toString(): string;
+    getCoinType(): number;
+    getAccount(): number;
+    getChange(): number;
+    getIndex(): number;
+    setCoinType(value: number): void;
+    setAccount(value: number): void;
+    setChange(value: number): void;
+    setIndex(value: number): void;
+    static fromOptions(options: IBip44PathOptions): Bip44Path;
+    toOptions(): IBip44PathOptions;
+    clone(): Bip44Path;
+    nextIndex(): Bip44Path;
+}
 
-declare class FeeService {
-    static generateRandomGasFee: () => string;
-    static getGasFeeAsNumber: () => number;
-    static formatGasFee: (fee?: string) => string;
+interface IPasswordCredentials {
+    password: string;
+}
+interface IPrivateKeyCredentials {
+    privateKey: Uint8Array;
+}
+interface ISeedCredentials {
+    seed: string;
+}
+interface IPrivateKeyWithCredentials extends IPasswordCredentials {
+    privateKey: Uint8Array;
+}
+interface IHDSecret extends ISeedCredentials {
+    rootHDPath: Bip44Path;
+}
+interface IHDSecretRecord extends ISeedCredentials {
+    rootHDPath: string;
+}
+interface IAccountHDData extends ISeedCredentials {
+    path: string;
+}
+type TSecretsProviderInterface = () => any;
+declare class SecretsProvider {
+    #private;
+    constructor(providerInterface: TSecretsProviderInterface);
+    getSecret(): any;
 }
 
 declare const enum KeyUsage {
@@ -12,7 +105,7 @@ declare const enum KeyUsage {
     DECRYPT = "decrypt",
     DERIVATION = "deriveKey"
 }
-interface CryptoConfig {
+type CryptoConfig = {
     readonly VERSION: number;
     readonly IV_LENGTH: number;
     readonly SALT_LENGTH: number;
@@ -23,173 +116,248 @@ interface CryptoConfig {
     readonly KEY_IMPORT_USAGE: KeyUsage[];
     readonly HASH_FUNCTION: string;
     readonly ALGORITHM: string;
-}
-interface EncryptedData {
+};
+type EncryptedData = {
     data: string;
     salt: string;
     iv: string;
     version: number;
-}
+};
 declare class CryptoService {
     static encryptWithPassword(data: string, password: string): Promise<EncryptedData>;
     static decryptWithPassword(payload: EncryptedData, passphrase: string): Promise<string>;
+    static decryptSignerData(signerData: EncryptedData, passwordProvider: SecretsProvider): Promise<IHDSecret | IPrivateKeyCredentials>;
     static deriveKey(password: string, salt: Uint8Array): Promise<CryptoKey>;
 }
 
-type AssetId = string;
-type Assets = Map<AssetId, Asset>;
-
-declare class Asset {
-    private id;
-    private name;
-    private decimals;
-    constructor(id: string, name: string, decimals?: number);
+declare enum WalletTypes {
+    PRIVATE_KEY = "private-key",
+    HD = "hd"
+}
+interface ISignerOptions {
+    id: string;
+    encryptedSecret: EncryptedData;
+}
+type TPKSigningContext = {
+    passwordProvider: SecretsProvider;
+};
+type THDSigningContext = {
+    passwordProvider: SecretsProvider;
+    index: number;
+};
+type ISignedMessageResponse = {
+    signature: Uint8Array;
+    publicKey: Uint8Array;
+};
+type TSigningContext = TPKSigningContext | THDSigningContext;
+interface ISignerRecord {
+    id: string;
+    type: WalletTypes;
+    encryptedData: EncryptedData;
+}
+declare abstract class Signer {
+    protected readonly id: string;
+    protected encryptedSecret: EncryptedData;
+    constructor({ id, encryptedSecret }: ISignerOptions);
     getId(): string;
-    getName(): string;
-    getDecimals(): number;
+    getEncryptedSecret(): EncryptedData;
+    abstract sign(payload: string, signingContext: TSigningContext): Promise<ISignedMessageResponse>;
 }
 
-type AddressBrand = {
-    readonly __brand: unique symbol;
+declare class ItemManager<T> {
+    protected readonly items: Map<string, T>;
+    constructor(items?: Map<string, T>);
+    add(id: string, item: T): void;
+    remove(id: string): T;
+    get(id: string): T | null;
+    hasByFilter(filter: (item: T) => boolean): boolean;
+    has(id: string): boolean;
+    getAll(): T[];
+    getMap(): Map<string, T>;
+    clear(): void;
+}
+
+interface ICreatedAccountData {
+    accountId: string;
+    account: Account;
+}
+declare class AccountManager extends ItemManager<Account> {
+    private activeAccount;
+    constructor(accounts?: Map<string, Account>, activeAccount?: Account | null);
+    create(payload: TCreateAccountPayload, secretProvider: SecretsProvider): Promise<ICreatedAccountData>;
+    remove(id: string): Account;
+    update(id: string, payload: TEditableAccountOptions): void;
+    setActiveAccount(id: string): void;
+    getActiveAccount(): Account | null;
+    getAccounts(): Account[];
+    getAccountsMap(): Map<string, Account>;
+    getAccount(id: string): Account | null;
+}
+
+type TAxiosClientConfig = {
+    baseUrl: string;
+    axiosConfig?: AxiosRequestConfig;
 };
-type Address = `1111${string & AddressBrand}`;
-interface StoredWalletMeta {
-    name: string;
-    address: Address;
-    encryptedPrivateKey: string;
-    masterNodeId: string | null;
-    index: string | null;
-}
-type StringifiedWalletMeta = string;
-type WalletMemory = Map<string, string>;
-declare enum WalletMemoryKeys {
-    PRIVATE_KEY = "private_key",
-    CRYPTO_SALT = "crypto_salt",
-    CRYPTO_IV = "crypto_iv",
-    CRYPTO_VERSION = "crypto version"
-}
-interface SigningCapability {
-    signDigest(digest: Uint8Array): Promise<Uint8Array>;
-    getPublicKey(): Uint8Array;
+declare abstract class BaseHttpClient {
+    protected readonly client: AxiosInstance;
+    constructor(config: TAxiosClientConfig);
+    protected get<T>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    protected post<T>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<T>;
 }
-declare class Wallet {
-    private static unsafeRawKeyExportEnabled;
-    private name;
-    private address;
-    private privateKey;
-    private isLocked;
-    private assets;
-    private masterNodeId;
-    private index;
-    private constructor();
-    static fromPrivateKey(name: string, privateKey: Uint8Array, password: string, masterNodeId?: string | null, index?: number | null): Promise<Wallet>;
-    static fromEncryptedData(name: string, address: Address, encryptedPrivateKey: EncryptedData, masterNodeId: string | null, index: number | null): Wallet;
-    /**
-     * @deprecated Raw key export is disabled by default. Prefer `withSigningCapability()`.
-     * Enable only for legacy migration by calling `Wallet.enableUnsafeRawKeyExportForLegacyInterop()`.
-     */
-    decrypt(password: string): Promise<Uint8Array>;
-    static enableUnsafeRawKeyExportForLegacyInterop(): void;
-    static disableUnsafeRawKeyExport(): void;
-    static isUnsafeRawKeyExportEnabled(): boolean;
-    private decryptPrivateKey;
-    withSigningCapability<T>(password: string, callback: (signingCapability: SigningCapability) => Promise<T> | T): Promise<T>;
-    getEncryptedPrivateKey(): EncryptedData;
-    registerAsset(asset: Asset): void;
-    getAddress(): Address;
-    getName(): string;
-    getIndex(): number | null;
-    getAssets(): Assets;
-    isWalletLocked(): boolean;
-    toString(): StringifiedWalletMeta;
-    private static encryptPrivateKey;
+
+declare class BaseGraphQLClient {
+    private readonly client;
+    constructor(config: TAxiosClientConfig);
+    query<T>(query: string, variables?: Record<string, unknown>): Promise<T>;
 }
 
-interface CreateWalletOptions {
-    name?: string;
+/**
+ * Important: This isn't pure UI pagination. It's SDK application layer pagination. It affects what data is retrieved during database queries.
+ */
+type Pagination = Partial<{
+    offset: number;
+    limit: number;
+}>;
+
+type NetworkName = "Dev" | "MainNet" | "TestNet" | "DevNet";
+interface INetworkConfig {
+    ValidatorURL: string;
+    ReadOnlyURL: string;
+    IndexerURL: string;
 }
-interface WalletMeta {
-    address: string;
-    privateKey: Uint8Array;
-    publicKey?: Uint8Array;
-    mnemonic?: string;
+type TNetworksConfig = Record<NetworkName, INetworkConfig>;
+
+interface ITableRecord {
+    id: string;
+    [key: string]: any;
 }
-declare class WalletsService {
-    static createWallet(privateKey?: Uint8Array, options?: CreateWalletOptions): WalletMeta;
-    static createWalletFromMnemonic(mnemonic?: string, index?: number): Promise<WalletMeta>;
-    static deriveAddressFromPrivateKey(privateKey: Uint8Array): Address;
-    static deriveAddressFromPublicKey(publicKey: Uint8Array): Address;
+interface ITableService<T extends ITableRecord> {
+    createTable(tableName: string, keyPath?: string): Promise<void>;
+    insert(tableName: string, record: T): Promise<void>;
+    insertMany(tableName: string, records: T[]): Promise<void>;
+    getById(tableName: string, id: string | number): Promise<T | null>;
+    getAll(tableName: string): Promise<T[]>;
+    update(tableName: string, id: string | number, data: Partial<T>): Promise<void>;
+    delete(tableName: string, id: string | number): Promise<void>;
+    deleteMany(tableName: string, ids: (string | number)[]): Promise<void>;
+    clearTable(tableName: string): Promise<void>;
+    dropTable(tableName: string): Promise<void>;
+    tableExists(tableName: string): Promise<boolean>;
+    close: () => Promise<void>;
+    init(): Promise<any>;
+    isInitialized(): boolean;
 }
 
-declare enum MnemonicStrength {
-    TWELVE_WORDS = 128,
-    TWENTY_FOUR_WORDS = 256
+type TransactionStatus = "pending" | "confirmed" | "failed";
+interface Transaction {
+    id: string;
+    timestamp: Date;
+    type: "send" | "receive" | "deploy";
+    from: string;
+    to?: string;
+    amount?: string;
+    deployId?: string;
+    blockHash?: string;
+    gasCost?: string;
+    status: TransactionStatus;
+    contractCode?: string;
+    note?: string;
+    networkName: NetworkName;
+    detectedBy?: "balance_change" | "manual" | "auto";
 }
-declare class MnemonicService {
-    static generateMnemonic(strength?: MnemonicStrength): string;
-    static generateMnemonicArray(strength?: MnemonicStrength): string[];
-    static isMnemonicValid(mnemonic: string): boolean;
-    static mnemonicToWordArray(mnemonic: string): string[];
-    static wordArrayToMnemonic(words: string[]): string;
+interface ITransactionReservationPrivateData {
+    timestamp: Date;
+    accountAddress: string;
+    pendingAmount: string;
+    deployId: string;
+    expirationTime: number;
+}
+interface ITransactionReservation extends ITransactionReservationPrivateData, ITableRecord {
+    networkName: NetworkName;
 }
 
-interface Bip44PathOptions {
-    coinType: number;
-    account?: number;
-    change?: number;
-    index?: number;
+interface TransactionHistoryQueryData {
+    transfers?: RawTransfer[];
 }
-declare class KeyDerivationService {
-    static buildBip44Path({ coinType, account, change, index, }: Bip44PathOptions): string;
-    static derivePrivateKey(masterNode: BIP32Interface, path: string): Uint8Array;
-    static mnemonicToSeed(mnemonicWords: string[] | string, passphrase?: string): Promise<Uint8Array>;
-    static seedToMasterNode(seed: any): BIP32Interface;
-    static deriveKeyFromMnemonic(mnemonicWords: string[], options?: Bip44PathOptions): Promise<Uint8Array>;
-    static deriveNextKeyFromMnemonic(mnemonicWords: string[], currentIndex: number, options?: Omit<Bip44PathOptions, "index">): Promise<Uint8Array>;
+interface RawTransfer {
+    deploy_id: string;
+    block_number?: number | string;
+    block_hash?: string;
+    from_address?: string;
+    to_address?: string;
+    amount_asi?: number | string;
+    timestamp?: number | string;
+    from_public_key?: string;
+    network_name?: string;
 }
 
-interface KeyPair {
-    privateKey: Uint8Array;
-    publicKey: Uint8Array;
+declare class IndexerClient extends BaseGraphQLClient {
+    getTransactionHistory(address: string, pagination?: Pagination): Promise<TransactionHistoryQueryData>;
 }
-declare class KeysManager {
-    static generateRandomKey(length?: number): Uint8Array;
-    static generateKeyPair(keyLength?: number): KeyPair;
-    static getKeyPairFromPrivateKey(privateKey: Uint8Array): KeyPair;
-    static getPublicKeyFromPrivateKey(privateKey: Uint8Array): Uint8Array;
-    static convertKeyToHex(key: Uint8Array): string;
-    static deriveKeyFromMnemonic(mnemonicWords: string[], options?: Bip44PathOptions): Promise<Uint8Array>;
-    static generateMpcKeyPair(): any;
-}
-
-declare enum RecoverableDeployErrors {
-    READ_ONLY_NODE = "READ_ONLY_NODE",
-    CASPER_INSTANCE_UNAVAILABLE = "CASPER_INSTANCE_UNAVAILABLE",
-    INVALID_DEPLOY_ID = "INVALID_DEPLOY_ID",
-    INVALID_BLOCK_NUMBER = "INVALID_BLOCK_NUMBER"
-}
-declare enum FatalDeployErrors {
-    INSUFFICIENT_BALANCE = "INSUFFICIENT_BALANCE",
-    WRONG_NETWORK = "WRONG_NETWORK",
-    PARSING_ERROR = "PARSING_ERROR",
-    LOW_PHLO_PRICE = "LOW_PHLO_PRICE",
-    SIGNATURE_ERROR = "SIGNATURE_ERROR",
-    STORAGE_RETRIEVAL_ERROR = "STORAGE_RETRIEVAL_ERROR",
-    UNKNOWN_ERROR = "UNKNOWN_ERROR",
-    DEPLOY_SUBMIT_TIMEOUT = "DEPLOY_SUBMIT_TIMEOUT",
-    BLOCK_INCLUSION_TIMEOUT = "BLOCK_INCLUSION_TIMEOUT",
-    FINALIZATION_TIMEOUT = "FINALIZATION_TIMEOUT"
-}
-type DeploymentErrorType = RecoverableDeployErrors | FatalDeployErrors;
-declare const deploymentErrorMessages: Record<DeploymentErrorType, string>;
-declare function getDeploymentErrorMessage(errorType: DeploymentErrorType): string;
-
-declare class DeploymentErrorHandler {
-    parseDeploymentError(errorMessage: string): DeploymentErrorType;
-    isDeploymentErrorRecoverable(errorType: DeploymentErrorType): boolean;
-    isDeploymentErrorFatal(errorType: DeploymentErrorType): boolean;
-    isPollingErrorRecoverable(errorMessage: string): boolean;
-    getErrorMessageByErrorType(errorType: DeploymentErrorType): string;
+
+interface IBalanceResponse {
+    balance: number;
+}
+interface IBlockDto {
+    blockInfo: string;
+    blockNumber: number;
+}
+type TBlocksView = "summary" | "full";
+interface IGetBlocksParams {
+    start?: number;
+    end?: number;
+    view?: TBlocksView;
+}
+declare class ObserverClient extends BaseHttpClient {
+    getDeploy(deployHash: string): Promise<unknown>;
+    getBlock(blockHash: string): Promise<IBlockDto>;
+    getBlocks(params?: IGetBlocksParams): Promise<IBlockDto[]>;
+}
+
+declare class ValidatorClient extends BaseHttpClient {
+    submitDeploy(deploy: any): Promise<unknown>;
+    submitExploratoryDeploy(rholangCode: string): Promise<any>;
+    getStatus(): Promise<unknown>;
+}
+
+interface IApiClients {
+    validator: ValidatorClient;
+    observer: ObserverClient;
+    indexer: IndexerClient;
+}
+declare class ApiClientManager {
+    private static instance;
+    private readonly networkConfigProvider;
+    private validatorClient;
+    private observerClient;
+    private indexerClient;
+    private currentNetwork;
+    private isInitialized;
+    private constructor();
+    static getInstance(): ApiClientManager;
+    initialize(networksConfig: TNetworksConfig, network?: NetworkName): void;
+    switchNetwork(network: NetworkName): void;
+    getValidatorClient(): ValidatorClient;
+    getObserverClient(): ObserverClient;
+    getIndexerClient(): IndexerClient;
+    getClients(): {
+        validator: ValidatorClient;
+        observer: ObserverClient;
+        indexer: IndexerClient;
+    };
+    getNetwork(): NetworkName;
+    getNetworkNames(): NetworkName[];
+    isReady(): boolean;
+    close(): void;
+}
+
+interface DeployData {
+    term: string;
+    phloLimit: number;
+    phloPrice: number;
+    validAfterBlockNumber: number;
+    timestamp: number;
+    shardId?: string;
 }
 
 interface SigningRequest {
@@ -202,7 +370,9 @@ interface SignedResult {
     signature: string;
     sigAlgorithm: string;
 }
-type PasswordProvider = () => Promise<string>;
+declare class SignerService {
+    static readonly deployDataProtobufSerialize: (deployData: DeployData) => Uint8Array;
+}
 
 declare enum DeployStatus {
     DEPLOYING = "Deploying",
@@ -210,127 +380,249 @@ declare enum DeployStatus {
     FINALIZED = "Finalized",
     CHECK_ERROR = "CheckingError"
 }
-type DeployStatusResult = {
-    status: Exclude<DeployStatus, DeployStatus.CHECK_ERROR>;
+type IDeployStatusResult = {
+    status: DeployStatus.DEPLOYING | DeployStatus.INCLUDED_IN_BLOCK | DeployStatus.FINALIZED;
 } | {
     status: DeployStatus.CHECK_ERROR;
     errorMessage: string;
 };
-type GatewayClientConfig = {
-    baseUrl: string;
-    axiosConfig?: AxiosRequestConfig;
-};
-interface BlockchainGatewayConfig {
-    validator: GatewayClientConfig;
-    indexer: GatewayClientConfig;
-}
-declare class BlockchainGateway {
-    private static instance;
-    private validatorClient;
-    private indexerClient;
-    private constructor();
-    private static createHttpClient;
-    changeValidator(config: GatewayClientConfig): this;
-    changeIndexer(config: GatewayClientConfig): this;
-    static init(config: BlockchainGatewayConfig): BlockchainGateway;
-    static isInitialized(): boolean;
-    static getInstance(): BlockchainGateway;
-    getValidatorClientUrl(): string;
-    submitDeploy(deployData: SignedResult): Promise<string | undefined>;
-    submitExploratoryDeploy(rholangCode: string): Promise<any>;
+declare class DeployService {
+    private readonly apiClientManager;
+    constructor(apiClientManager?: ApiClientManager);
+    private extractDeployId;
+    submitSignedDeploy(deploy: SignedResult): Promise<string | undefined>;
     exploreDeployData(rholangCode: string): Promise<any>;
     getDeploy(deployHash: string): Promise<any>;
     isDeployFinalized(deploy: any): Promise<boolean>;
-    getDeployStatus(deployHash: string): Promise<DeployStatusResult>;
-    getBlock(blockHash: string): Promise<any>;
+    getDeployStatus(deployHash: string): Promise<IDeployStatusResult>;
+}
+
+declare class BlockService {
+    private readonly apiClientManager;
+    constructor(apiClientManager?: ApiClientManager);
+    getBlock(blockHash: string): Promise<string>;
+    getLatestBlock(): Promise<IBlockDto>;
     getLatestBlockNumber(): Promise<number>;
     isValidatorActive(): Promise<boolean>;
-    private getGatewayErrorMessage;
-    private validateBlocksResponse;
-    private getLatestBlock;
 }
 
-interface NodeProvider {
-    connectDefaultNode(): Promise<void>;
-    connectActiveRandomNode(): Promise<void>;
-    deactivateCurrentNode(): void;
-    isInitialized(): boolean;
-    getRetriesLeft(): number;
+interface ITransferDetails {
+    to: Address;
+    amount: bigint;
+    asset: Asset;
+    phloLimit?: number;
+    phloPrice?: number;
+    shardId?: string;
 }
-interface ResubmitConfig {
-    phloPrice: number;
-    useRandomNode: boolean;
-    deployValiditySeconds: number;
-    nodeSelectionAttempts: number;
-    deployRetries: number;
-    deployIntervalSeconds: number;
-    pollingIntervalSeconds: number;
-}
-interface ErrorDetail {
-    blockchainError?: {
-        type: DeploymentErrorType;
-        message: string;
-    };
-    exceededTimeout?: FatalDeployErrors.DEPLOY_SUBMIT_TIMEOUT | FatalDeployErrors.BLOCK_INCLUSION_TIMEOUT;
+interface ITransferPayload {
+    walletType: WalletTypes;
+    account: Account;
+    signer: Signer;
+    details: ITransferDetails;
+    passwordProvider: SecretsProvider;
 }
-interface ResubmitResult {
-    success: boolean;
-    deployId?: string;
-    deployStatus?: DeployStatus;
-    error?: ErrorDetail;
-}
-
-declare class DeployResubmitter {
-    private readonly config;
-    private readonly nodeManager;
-    private readonly errorHandler;
-    private startSubmissionTime;
-    constructor(config: ResubmitConfig, availableNodesUrls: string[]);
-    private isDeployExpired;
-    private sleep;
-    private retryDeployToOneNode;
-    private retryDeployToRandomNodes;
-    private pollDeployStatus;
-    /**
-
-     * Main resubmit function
-     * Executes the complete resubmit algorithm for deploy
-     * NOT FOR "READ-ONLY" DEPLOYS (exploratory deploys)
-     */
-    resubmit(rholangCode: string, wallet: Wallet, passwordProvider: PasswordProvider, phloLimit?: number): Promise<ResubmitResult>;
-}
-
-declare class NodeManager implements NodeProvider {
-    private static instance;
-    private retriesLeft;
-    private readonly availableNodesUrls;
-    private readonly useRandomNode;
-    private readonly inactiveNodesUrls;
-    private currentNodeUrl;
+declare class TransactionService {
+    private readonly deployService;
+    private readonly blockService;
+    constructor(deployService: DeployService, blockService: BlockService);
+    private signDeploy;
+    transfer({ walletType, account, signer, details, passwordProvider, }: ITransferPayload): Promise<string>;
+}
+
+type AddressBrand = {
+    readonly __brand: unique symbol;
+};
+type Address = `1111${string & AddressBrand}`;
+interface IWalletOptions {
+    id?: string;
+    type: WalletTypes;
+    signer: Signer;
+    accounts: Map<string, Account>;
+    activeAccount?: Account;
+}
+type TCreateHDPathWalletOptions = {
+    customHDPath: Bip44Path;
+} | {
+    index: number;
+};
+interface ICreateHDWalletOptions {
+    mnemonic: string;
+    pathOptions: TCreateHDPathWalletOptions;
+    accountOptions: TCreateAccountPayload;
+}
+interface IRestoreWalletPayload {
+    signerRecord: ISignerRecord;
+    accountRecords: IAccountRecord[];
+}
+declare class Wallet {
+    private readonly id;
+    private readonly type;
+    private readonly signer;
+    private readonly accountManager;
     private constructor();
-    static initialize(availableNodesUrls: string[], nodeSelectionAttempts?: number, useRandomNode?: boolean): NodeManager;
-    connectDefaultNode(): Promise<void>;
-    private connectNode;
-    static getInstance(): NodeManager;
-    isInitialized(): boolean;
-    private markNodeInactive;
-    deactivateCurrentNode(): void;
-    private deactivateNode;
-    private getAvailableNodesUrls;
-    getRetriesLeft(): number;
-    private getRandomAvailableNodeUrl;
-    connectActiveRandomNode(): Promise<void>;
+    getId(): string;
+    getType(): WalletTypes;
+    getSigner(): Signer;
+    getAccounts(): Account[];
+    getAccountsMap(): Map<string, Account>;
+    getActiveAccount(): Account | null;
+    setActiveAccount(id: string): void;
+    private getDerivationIndex;
+    deriveAccount(payload: Omit<TCreateAccountPayload, "index">, passwordProvider: SecretsProvider): Promise<ICreatedAccountData>;
+    removeAccount(id: string): Account;
+    updateAccount(id: string, payload: TEditableAccountOptions): void;
+    static createPk(accountOptions: TCreateAccountPayload, secretProvider: SecretsProvider): Promise<Wallet>;
+    static createHD(options: ICreateHDWalletOptions, passwordProvider: SecretsProvider): Promise<Wallet>;
+    static restore(payload: IRestoreWalletPayload, passwordProvider: SecretsProvider): Promise<Wallet>;
+    transfer(payload: ITransferDetails, passwordProvider: SecretsProvider): Promise<string>;
 }
 
-declare class SignerService {
-    static sign(request: SigningRequest, passwordProvider: PasswordProvider): Promise<SignedResult>;
-    private static readonly deployDataProtobufSerialize;
+interface IPortfolioOptions {
+    assets?: Assets;
+    primaryAsset?: Asset;
+}
+interface IAccountOptions {
+    id?: string;
+    name: string;
+    index: number | null;
+    address: Address;
+    portfolioOptions?: IPortfolioOptions;
+}
+type TEditableAccountOptions = Partial<Pick<IAccountOptions, "name">>;
+type TCreateAccountPayload = Omit<IAccountOptions, "address" | "index"> & {
+    index?: number;
+};
+interface IAccountRecord {
+    id: string;
+    signerId: string;
+    name: string;
+    index: number | null;
+}
+declare class Account {
+    private readonly id;
+    private readonly index;
+    private readonly address;
+    private name;
+    private assets;
+    private primaryAsset;
+    constructor({ id, name, index, portfolioOptions, address, }: IAccountOptions);
+    getId(): string;
+    getName(): string;
+    getIndex(): number | null;
+    listAssets(): Asset[];
+    getAddress(): Address;
+    getAsset(id: Asset["id"]): Asset | null;
+    registerAsset(asset: Asset): void;
+    setPrimaryAsset(id: Asset["id"]): void;
+    static create(accountOptions: TCreateAccountPayload, secretProvider: SecretsProvider): Promise<Account>;
+    update(options: TEditableAccountOptions): void;
+    getBalance(): Promise<IBalanceData>;
+    getTransactionsHistory(networkName?: NetworkName, pagination?: Pagination): Promise<Transaction[]>;
+}
+
+interface IStorageFabricOptions {
+    nodeStorageDir?: string;
 }
 
+declare const ACCOUNTS_DATA_KEY: string;
+interface IPublicWalletRecord extends ITableRecord {
+    name: string;
+    type: WalletTypes;
+}
+interface IWalletRecordEncryptedFields {
+    keyData: string;
+    depth: number | null;
+    HDPath: string | null;
+}
+interface IFullWalletRecord extends IPublicWalletRecord, ITableRecord {
+    encryptedData: EncryptedData;
+    createdAt: number;
+    updatedAt?: number;
+}
+interface IAccountStorageRecord extends ITableRecord {
+    signerId: string;
+    name: string;
+    index: number | null;
+    createdAt: number;
+    updatedAt?: number;
+}
+declare class AccountsStorageRepository {
+    private static instance;
+    private storageInterface;
+    private isInitialized;
+    private initPromise;
+    constructor(options?: IStorageFabricOptions);
+    static getInstance(options?: IStorageFabricOptions): AccountsStorageRepository;
+    initialize(): Promise<void>;
+    private doInitialize;
+    private ensureInitialized;
+    getRawDB(): ITableService<ITableRecord>;
+    saveAccount(accountId: string, signerId: string, name: string, index: number | null): Promise<void>;
+    saveAccounts(accounts: IAccountStorageRecord[]): Promise<void>;
+    getAccount(id: string): Promise<IAccountStorageRecord | null>;
+    getAllAccounts(): Promise<IAccountStorageRecord[]>;
+    updateAccount(accountId: string, updates: Partial<IAccountStorageRecord>): Promise<void>;
+    deleteAccount(accountId: string): Promise<void>;
+    deleteMultipleAccounts(accountIds: string[]): Promise<void>;
+    hasAccount(accountId: string): Promise<boolean>;
+    getAccountsCount(): Promise<number>;
+    clearAllData(): Promise<void>;
+    clearTable(tableName: string): Promise<void>;
+    isReady(): boolean;
+    getTablesList(): Promise<string[]>;
+    close(): void;
+}
+
+declare class AccountDataService {
+    private readonly apiClientManager;
+    constructor(apiClientManager?: ApiClientManager);
+    getTransactionHistory(address: string, networkName?: NetworkName, pagination?: Pagination): Promise<Transaction[]>;
+}
+
+interface IBalanceData {
+    amount: bigint;
+    asset: Asset;
+}
 declare class AssetsService {
-    private getBlockchainGateway;
-    transfer(fromAddress: Address, toAddress: Address, amount: bigint, wallet: Wallet, passwordProvider: PasswordProvider, phloLimit?: number): Promise<string | undefined>;
-    getASIBalance(address: Address): Promise<bigint>;
+    private readonly deployService;
+    constructor(deployService: DeployService);
+    getBalance(address: Address, asset: Asset): Promise<IBalanceData>;
+}
+
+interface IDeployConfirmedResult {
+    deployId: string;
+    blockHash?: string;
+}
+interface IDeployWatchCallbacks {
+    onConfirmed?: (result: IDeployConfirmedResult) => void;
+    onError?: (error: Error) => void;
+    onStatus?: (status: IDeployStatusResult, deployId: string) => void;
+}
+interface IDeployWatchOptions {
+    intervalMs?: number;
+    timeoutMs?: number;
+}
+interface IDeployWatchHandle {
+    cancel: () => void;
+    done: Promise<IDeployConfirmedResult>;
+}
+declare class DeployStatusPoller {
+    private readonly deployService;
+    constructor(deployService: DeployService);
+    watch(deployId: string, callbacks?: IDeployWatchCallbacks, { intervalMs, timeoutMs, }?: IDeployWatchOptions): IDeployWatchHandle;
+    waitFor(deployId: string, options?: IDeployWatchOptions): Promise<IDeployConfirmedResult>;
+}
+
+declare class ApiServiceRegistry {
+    private static instance;
+    readonly deploy: DeployService;
+    readonly blocks: BlockService;
+    readonly accountData: AccountDataService;
+    readonly assets: AssetsService;
+    readonly transactions: TransactionService;
+    readonly poller: DeployStatusPoller;
+    private constructor();
+    static getInstance(apiClientManager?: ApiClientManager): ApiServiceRegistry;
 }
 
 declare class BinaryWriterService {
@@ -342,127 +634,404 @@ declare class BinaryWriterService {
     getResultBuffer(): Uint8Array;
 }
 
-declare class EncryptedRecord {
-    private encryptedSeedData;
-    static createAndEncrypt(data: string, password: string): Promise<EncryptedRecord>;
-    static createFromEncryptedData(encryptedData: EncryptedData): EncryptedRecord;
-    static createFromStringifiedEncryptedData(data: string): EncryptedRecord;
-    private constructor();
-    decrypt(password: string): Promise<string>;
-    toString(): string;
+declare class BrowserStorage implements ITableService<ITableRecord> {
+    private static instance;
+    private readonly name;
+    private storageInterface;
+    constructor(name?: string);
+    static getInstance(name?: string): BrowserStorage;
+    init(): Promise<IDBDatabase>;
+    createTable(tableName: string, keyPath?: string): Promise<void>;
+    insert(tableName: string, record: ITableRecord): Promise<void>;
+    insertMany(tableName: string, records: ITableRecord[]): Promise<void>;
+    getById(tableName: string, id: string | number): Promise<ITableRecord | null>;
+    getAll(tableName: string): Promise<ITableRecord[]>;
+    update(tableName: string, id: string | number, data: Partial<ITableRecord>): Promise<void>;
+    delete(tableName: string, id: string | number): Promise<void>;
+    deleteMany(tableName: string, ids: (string | number)[]): Promise<void>;
+    clearTable(tableName: string): Promise<void>;
+    dropTable(tableName: string): Promise<void>;
+    tableExists(tableName: string): Promise<boolean>;
+    getVersion(): number;
+    getDatabaseName(): string;
+    getTableNamesList(): string[];
+    private executeTransaction;
+    isInitialized(): boolean;
+    close(): Promise<void>;
 }
 
-type Wallets = Map<Address, Wallet>;
-type Seeds = Map<string, EncryptedRecord>;
-type VaultRawData = string;
-type StoredWalletsMetaRecords = Record<Address, StringifiedWalletMeta>;
-type StoredSeedsMetaRecords = Record<string, string>;
-declare const DEFAULT_STORAGE_KEY = "0";
-declare class Vault {
-    private static vaultPrefix;
-    private isLocked;
-    private wallets;
-    private seeds;
-    private encryptedVaultData;
-    constructor(VaultData?: VaultRawData);
-    static getSavedVaultKeys(): string[];
-    static getVaultDataFromStorage(vaultKey: string): VaultRawData | null;
-    isVaultLocked(): boolean;
-    save(vaultKey?: string): void;
-    lock(password: string): Promise<void>;
-    unlock(password: string): Promise<void>;
-    isEmpty(): boolean;
-    getWallets(): Wallet[];
-    getWalletsCount(): number;
-    getWalletAddresses(): Address[];
-    addWallet(wallet: Wallet): void;
-    removeWallet(address: Address): void;
-    getWallet(address: Address): Wallet | undefined;
-    hasWallet(address: Address): boolean;
-    hasSeed(seedId: string): boolean;
-    private metaToWallets;
-    private metaToSeeds;
-    getSeeds(): EncryptedRecord[];
-    getSeed(id: string): EncryptedRecord | undefined;
-    addSeed(id: string, seed: EncryptedRecord): void;
-    removeSeed(id: string): void;
-    getSeedsIds(): string[];
-    toString(): string;
-    private ensureUnlocked;
-    private static ensureBrowserEnvironment;
+declare enum MnemonicStrength {
+    TWELVE_WORDS = 128,
+    TWENTY_FOUR_WORDS = 256
+}
+declare class MnemonicService {
+    static generateMnemonic(strength?: MnemonicStrength): string;
+    static generateMnemonicArray(strength?: MnemonicStrength): string[];
+    static isMnemonicValid(mnemonic: string): boolean;
+    static mnemonicToWordArray(mnemonic: string): string[];
+    static wordArrayToMnemonic(words: string[]): string;
+    static mnemonicToSeed(mnemonic: string | string[], passphrase?: string): Promise<Uint8Array>;
+}
+
+interface IAccountMetadata {
+    id: string;
+    name: string;
+    index: number | null;
+}
+interface IWalletMetadata {
+    signerId: string;
+    type: WalletTypes;
+    accounts: IAccountMetadata[];
+}
+interface ICreateHDWalletParams {
+    mnemonic: string;
+    accountName: string;
+    index?: number;
+}
+interface IDerivedAccount {
+    accountId: string;
+    account: Account;
+}
+declare class WalletManager extends ItemManager<Wallet> {
+    createHD({ mnemonic, accountName, index }: ICreateHDWalletParams, passwordProvider: SecretsProvider): Promise<Wallet>;
+    createPrivateKey(accountName: string, secretProvider: SecretsProvider): Promise<Wallet>;
+    unlock(signerId: string, passwordProvider: SecretsProvider): Promise<Wallet>;
+    delete(id: string): Promise<Wallet>;
+    deriveAccount(walletId: string, accountName: string, passwordProvider: SecretsProvider): Promise<IDerivedAccount>;
+    removeAccount(walletId: string, accountId: string): Promise<Account>;
+    renameAccount(walletId: string, accountId: string, name: string): Promise<void>;
+    setActiveAccount(walletId: string, accountId: string): void;
+    getPublicWalletsMetadata(): Promise<IWalletMetadata[]>;
+    count(): Promise<number>;
+    countInStorage(): Promise<number>;
+    private persist;
+}
+
+interface IInsensitiveCacheRecord extends ITableRecord {
+    address: string;
 }
 
-interface ClientOptions {
-    vault?: Vault;
-    password?: string;
+interface IUnlockedWallet {
+    id: string;
+    signerId: string;
+    type: WalletTypes;
+    accounts: Account[];
+    activeAccountId: string | null;
+}
+interface ICreateHDWalletPayload {
+    mnemonic: string;
+    accountName: string;
+    index?: number;
+}
+interface ICreatePrivateKeyWalletPayload {
+    privateKey: Uint8Array;
+    accountName: string;
+}
+interface ITransferRequest {
+    walletId: string;
+    accountId: string;
+    to: Address;
+    amount: bigint;
+}
+interface IClientEventDispatcher {
+    onWalletsChanged?(wallets: Wallet[]): void;
+    onAccountsChanged?(walletId: string, accounts: Account[]): void;
+    onNetworkChanged?(networkName: NetworkName): void;
+    onReservationsChanged?(walletId: string, reservations: ITransactionReservation[]): void;
+}
+interface ICreateClientFlags {
+    withInsensitiveCacheStorage?: boolean;
+}
+interface ICreateClientOptions {
+    networksConfig: TNetworksConfig;
+    defaultNetwork?: NetworkName;
+    storageOptions?: IStorageFabricOptions;
+    eventDispatcher?: IClientEventDispatcher;
+    flags?: ICreateClientFlags;
 }
 declare class Client {
-    private readonly vault;
-    private activeWalletAddress?;
+    private readonly walletManager;
+    private readonly reservationAdapterManager;
+    private readonly eventDispatcher?;
+    private readonly flags?;
     private constructor();
-    static create(options?: ClientOptions): Promise<Client>;
-    createWallet(name: string, privateKey: Uint8Array, password: string): Promise<Wallet>;
-    selectActiveWallet(walletAddress: Address): boolean;
-    getActiveWallet(): Wallet | undefined;
-    getWallets(): Wallet[];
+    static create({ networksConfig, defaultNetwork, storageOptions, eventDispatcher, flags, }: ICreateClientOptions): Promise<Client>;
+    getWalletManager(): WalletManager;
+    getInsensitiveAccountsData(): Promise<IInsensitiveCacheRecord[]>;
+    clearPersistence(): Promise<void>;
+    close(): void;
+    generateMnemonic(strength?: MnemonicStrength): string;
+    generatePrivateKey(): Uint8Array;
+    createHDWallet({ mnemonic, accountName, index }: ICreateHDWalletPayload, password: string): Promise<Wallet>;
+    createPrivateKeyWallet({ privateKey, accountName }: ICreatePrivateKeyWalletPayload, password: string): Promise<Wallet>;
+    removeWallet(walletId: string): Promise<void>;
+    unlockWallet(signerId: string, password: string): Promise<Wallet>;
+    deriveAccount(walletId: string, accountName: string, password: string): Promise<ICreatedAccountData>;
+    removeAccount(walletId: string, accountId: string): Promise<void>;
+    renameAccount(walletId: string, accountId: string, name: string): Promise<void>;
+    setActiveAccount(walletId: string, accountId: string): void;
+    getNetworksNames(): NetworkName[];
+    getCurrentNetwork(): NetworkName;
+    setNetwork(networkName: NetworkName): void;
+    getBalance(address: Address): Promise<bigint>;
+    getAvailableBalance(walletId: string, accountId: string): Promise<bigint>;
+    getReservations(walletId: string): Promise<ITransactionReservation[]>;
+    transfer({ walletId, accountId, to, amount }: ITransferRequest, password: string): Promise<string>;
+    toDisplayAmount(atomicAmount: bigint): string;
+    toAtomicAmount(amount: number | string): bigint;
+    private getUnlockedWallet;
+    private getAccount;
+    private createPasswordProvider;
+    private emitAccountsChanged;
+    private emitWalletsChanged;
 }
 
-interface HttpClient {
-    get<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
-    post<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
-    getBaseUrl(): string | undefined;
+declare class NetworkConfigProvider {
+    private networksConfig;
+    initialize(config: TNetworksConfig): void;
+    get(network: NetworkName): INetworkConfig;
+    getNetworkNames(): NetworkName[];
+    isReady(): boolean;
 }
-declare class AxiosHttpClient implements HttpClient {
-    private readonly client;
-    constructor(client: AxiosInstance);
-    get<T>(url: string): Promise<T>;
-    post<T>(url: string, data?: any): Promise<T>;
-    getBaseUrl(): string | undefined;
-}
-
-interface Storage {
-    write: (id: string, data: string) => void;
-    read: (id: string) => string | null;
-    delete: (id: string) => void;
-    has: (id: string) => boolean;
-    isEmpty: () => boolean;
-    clear: () => void;
-}
-declare class BrowserStorage implements Storage {
-    private prefix;
-    constructor(prefix?: string);
-    write(id: string, data: string): void;
-    read(id: string): string | null;
-    delete(id: string): void;
-    has(id: string): boolean;
-    isEmpty(): boolean;
+
+declare class NodeStorage implements ITableService<ITableRecord> {
+    private static instance;
+    private readonly storageDir;
+    private storageInterface;
+    constructor(storageDir?: string);
+    static getInstance(storageDir?: string): NodeStorage;
+    init(): Promise<void>;
+    private getTableKey;
+    private getTable;
+    private saveTable;
+    createTable(tableName: string, _keyPath: string): Promise<void>;
+    insert(tableName: string, record: ITableRecord): Promise<void>;
+    insertMany(tableName: string, records: ITableRecord[]): Promise<void>;
+    getById(tableName: string, id: string | number): Promise<ITableRecord | null>;
+    getAll(tableName: string): Promise<ITableRecord[]>;
+    update(tableName: string, id: string | number, data: Partial<ITableRecord>): Promise<void>;
+    delete(tableName: string, id: string | number): Promise<void>;
+    deleteMany(tableName: string, ids: (string | number)[]): Promise<void>;
+    clearTable(tableName: string): Promise<void>;
+    dropTable(tableName: string): Promise<void>;
+    isInitialized(): boolean;
+    getKeys(): Promise<string[]>;
+    tableExists(tableName: string): Promise<boolean>;
+    close(): Promise<void>;
+}
+
+declare const SIGNERS_DATA_KEY: string;
+interface IPrivateKeySignerEncryptedFields {
+    keyData: Uint8Array;
+}
+interface IHDSignerEncryptedFields {
+    seed: string;
+    rootHDPath: string;
+}
+interface ISignerStorageRecord extends ITableRecord {
+    type: WalletTypes;
+    encryptedData: EncryptedData;
+    createdAt: number;
+    updatedAt?: number;
+}
+declare class SignersStorageRepository {
+    private static instance;
+    private storageInterface;
+    private isInitialized;
+    private initPromise;
+    constructor(options?: IStorageFabricOptions);
+    static getInstance(options?: IStorageFabricOptions): SignersStorageRepository;
+    initialize(): Promise<void>;
+    private doInitialize;
+    private ensureInitialized;
+    getRawDB(): ITableService<ITableRecord>;
+    saveSigner(signerId: string, type: WalletTypes, encryptedData: EncryptedData): Promise<void>;
+    getSigner(id: string): Promise<ISignerStorageRecord | null>;
+    getAllSigners(): Promise<ISignerStorageRecord[]>;
+    updateSigner(signerId: string, updates: Partial<ISignerStorageRecord>): Promise<void>;
+    deleteSigner(signerId: string): Promise<void>;
+    deleteMultipleSigners(signerIds: string[]): Promise<void>;
+    hasSigner(signerId: string): Promise<boolean>;
+    getSignersCount(): Promise<number>;
+    clearAllData(): Promise<void>;
+    clearTable(tableName: string): Promise<void>;
+    isReady(): boolean;
+    getTablesList(): Promise<string[]>;
+    close(): void;
+}
+
+declare const TRANSACTION_RESERVATIONS_DATA_KEY: string;
+interface ITransactionReservationsStorageRecord extends ITableRecord {
+    networkName: NetworkName;
+    signerId: string;
+    encryptedData: EncryptedData;
+    createdAt: number;
+    updatedAt?: number;
+}
+declare class TransactionReservationsStorageRepository {
+    private static instance;
+    private storageInterface;
+    private isInitialized;
+    private initPromise;
+    constructor(options?: IStorageFabricOptions);
+    static getInstance(options?: IStorageFabricOptions): TransactionReservationsStorageRepository;
+    initialize(): Promise<void>;
+    private doInitialize;
+    private ensureInitialized;
+    getRawDB(): ITableService<ITableRecord>;
+    saveTransactionReservation(id: string, networkName: NetworkName, signerId: string, encryptedData: EncryptedData): Promise<void>;
+    getTransactionReservations(id: string): Promise<ITransactionReservationsStorageRecord | null>;
+    getAllTransactionReservations(): Promise<ITransactionReservationsStorageRecord[]>;
+    updateTransactionReservation(id: string, updates: Partial<ITransactionReservationsStorageRecord>): Promise<void>;
+    deleteTransactionReservation(id: string): Promise<void>;
+    deleteMultipleTransactionReservations(ids: string[]): Promise<void>;
+    hasTransactionReservations(id: string): Promise<boolean>;
+    getTransactionReservationsCount(): Promise<number>;
+    clearAllData(): Promise<void>;
+    clearTable(tableName: string): Promise<void>;
+    isReady(): boolean;
+    getTablesList(): Promise<string[]>;
+    close(): void;
+}
+
+interface IDisposable {
+    dispose(): void;
+}
+declare class DisposableItemManager<T extends IDisposable> extends ItemManager<T> {
+    add(id: string, item: T): void;
+    remove(id: string): T;
     clear(): void;
-    private getIds;
-    private createKey;
 }
 
-interface WalletClientConfig {
-    mode: string;
+interface ITransactionReservationsManagerOptions {
+    onConfirmed?: (reservation: ITransactionReservation) => void;
+    onExpired?: (reservation: ITransactionReservation) => void;
+    onFailed?: (reservation: ITransactionReservation, error: Error) => void;
+    watchCallbacks?: IDeployWatchCallbacks;
+    watchOptions?: IDeployWatchOptions;
 }
-declare enum WalletClientModes {
-    LOCAL = "local",
-    MPC = "mpc"
+
+declare class ReservationAdapter {
+    private readonly reservationsManager;
+    constructor(reservations: ITransactionReservation[], reservationsManagerOptions?: Omit<ITransactionReservationsManagerOptions, "onConfirmed" | "onExpired">);
+    static create(wallet: Wallet, passwordProvider: SecretsProvider, reservationsManagerOptions?: Omit<ITransactionReservationsManagerOptions, "onConfirmed" | "onExpired">): Promise<ReservationAdapter>;
+    private getReservedAmount;
+    getBalance(account: Account): Promise<IBalanceData>;
+    getReservations(): ITransactionReservation[];
+    dispose(): void;
+    private persistReservation;
+    validateSufficientBalance(account: Account, amount: bigint): Promise<boolean>;
+    transfer(wallet: Wallet, details: ITransferDetails, passwordProvider: SecretsProvider): Promise<string>;
 }
-declare const DEFAULT_CLIENT_CONFIG: WalletClientConfig;
-declare const DEFAULT_AXIOS_TIMEOUT_MS: number;
-declare const MAX_WALLETS_PER_ACCOUNT: number;
-declare const DEFAULT_DECIMALS_AMOUNT: number;
-declare const DEFAULT_PHLO_LIMIT: number;
-declare const DEFAULT_RESUBMIT_CONFIG: ResubmitConfig;
 
-declare const encodeBase58: (hex: string) => string;
-declare const decodeBase58: (value: string) => Uint8Array;
-declare const decodeBase16: (hex: string) => Uint8Array;
-declare const encodeBase16: (bytes: Uint8Array) => string;
-declare const arrayBufferToBase64: (buffer: ArrayBuffer) => string;
-declare const base64ToArrayBuffer: (base64: string) => ArrayBuffer;
-declare const bufferToBigInt: (buffer: Uint8Array) => bigint;
-declare const bigIntToBuffer: (num: bigint) => Uint8Array;
+declare class ReservationAdapterManager extends DisposableItemManager<ReservationAdapter> {
+    create(wallet: Wallet, passwordProvider: SecretsProvider): Promise<ReservationAdapter>;
+}
+
+declare class KeyDerivationService {
+    static deriveKeyFromMnemonic(mnemonic: string | string[], bip44path: string | Bip44Path): Promise<Uint8Array>;
+    static derivePrivateKey(masterNode: BIP32Interface, path: Bip44Path): Uint8Array;
+    static mnemonicToSeed(mnemonicWords: string[] | string, passphrase?: string): Promise<Uint8Array>;
+    static seedToMasterNode(seed: any): BIP32Interface;
+    static deriveNextKeyFromMnemonic(mnemonicWords: string[], currentIndex: number, options?: Omit<IBip44PathOptions, "index">): Promise<Uint8Array>;
+}
+
+type KeyPair = {
+    privateKey: Uint8Array;
+    publicKey: Uint8Array;
+};
+interface IBaseHDWalletPrivateKeyData {
+    path: Bip44Path;
+    privateKey: Uint8Array;
+}
+interface IHDWalletPrivateKeyDataFromMnemonic extends IBaseHDWalletPrivateKeyData {
+    seed: Uint8Array;
+}
+interface IHDWalletPrivateKeyDataFromSeed extends IBaseHDWalletPrivateKeyData {
+    index: number;
+}
+declare class KeysManager {
+    static generateRandomKey(length?: number): Uint8Array;
+    static generateKeyPair(keyLength?: number): KeyPair;
+    static getKeyPairFromPrivateKey(privateKey: Uint8Array): KeyPair;
+    static getPublicKeyFromPrivateKey(privateKey: Uint8Array): Uint8Array;
+    static convertKeyToHex(key: Uint8Array): string;
+    static getInitialHDPathFromOptions(hdWalletOptions: TCreateHDPathWalletOptions): Promise<Bip44Path>;
+    static getPrivateDataFromSeed(seed: Uint8Array, path: Bip44Path): Promise<IHDWalletPrivateKeyDataFromSeed>;
+}
+
+interface ISaveSignerToStorageOptions {
+    id: string;
+    type: WalletTypes;
+    signer: Signer;
+}
+interface ISaveAccountToStorageOptions {
+    id: string;
+    account: Account;
+    signerId: string;
+}
+interface ISaveWalletToStorageOptions {
+    signerId: string;
+    wallet: Wallet;
+}
+interface IGetWalletFromStorageOptions {
+    signerId: string;
+    passwordProvider: SecretsProvider;
+}
+interface IWalletStorageData {
+    signer: ISignerRecord;
+    accounts: IAccountRecord[];
+}
+interface ISaveTransactionReservationsOptions {
+    id: string;
+    networkName: NetworkName;
+    signerId: string;
+    encryptedData: EncryptedData;
+}
+declare class StorageManager {
+    static init: (options?: IStorageFabricOptions) => Promise<void>;
+    static saveSigner: ({ id, type, signer, }: ISaveSignerToStorageOptions) => Promise<void>;
+    static saveSigners: (signersOptions: ISaveSignerToStorageOptions[]) => Promise<void[]>;
+    static getSigner: (id: string) => Promise<ISignerRecord>;
+    static getSigners: () => Promise<ISignerRecord[]>;
+    static updateSigner: (id: string, updates: Partial<ISignerRecord>) => Promise<void>;
+    static deleteSigner: (id: string) => Promise<void>;
+    static deleteMultipleSigners: (ids: string[]) => Promise<void>;
+    static saveAccount: ({ id, account, signerId, }: ISaveAccountToStorageOptions) => Promise<void>;
+    static saveAccounts: (accountsOptions: ISaveAccountToStorageOptions[]) => Promise<void>;
+    static getAccount: (id: string) => Promise<IAccountRecord>;
+    static getAccounts: () => Promise<IAccountRecord[]>;
+    static updateAccount: (id: string, updates: Partial<IAccountRecord>) => Promise<void>;
+    static deleteAccount: (id: string) => Promise<void>;
+    static deleteMultipleAccounts: (ids: string[]) => Promise<void>;
+    static saveWallet: ({ signerId, wallet, }: ISaveWalletToStorageOptions) => Promise<void>;
+    static saveWallets: (walletsOptions: ISaveWalletToStorageOptions[]) => Promise<void[]>;
+    static getWallet: ({ signerId, passwordProvider, }: IGetWalletFromStorageOptions) => Promise<Wallet>;
+    static getWallets: () => Promise<IWalletStorageData[]>;
+    static saveTransactionReservation: ({ id, networkName, signerId, encryptedData, }: ISaveTransactionReservationsOptions) => Promise<void>;
+    static getTransactionReservationsBySignerId: (signerId: string, networkName: NetworkName) => Promise<ITransactionReservationsStorageRecord[]>;
+    static updateTransactionReservation: (id: string, updates: Partial<ITransactionReservationsStorageRecord>) => Promise<void>;
+    static deleteTransactionReservation: (id: string) => Promise<void>;
+    static deleteMultipleTransactionReservations: (ids: string[]) => Promise<void>;
+    static clear: () => Promise<void>;
+    static close: () => void;
+}
+
+interface CreateWalletOptions {
+    name?: string;
+}
+interface WalletMeta {
+    address: string;
+    privateKey: Uint8Array;
+    publicKey?: Uint8Array;
+    mnemonic?: string;
+}
+declare class WalletsService {
+    static createWallet(privateKey?: Uint8Array, options?: CreateWalletOptions): WalletMeta;
+    static createFirstWalletWithMnemonic(mnemonic?: string, index?: number): Promise<WalletMeta>;
+    static deriveAddressFromPrivateKey(privateKey: Uint8Array): Address;
+    static deriveAddressFromPublicKey(publicKey: Uint8Array): Address;
+}
 
 declare const PRIVATE_KEY_LENGTH = 32;
 declare const ASI_CHAIN_PREFIX: {
@@ -471,13 +1040,6 @@ declare const ASI_CHAIN_PREFIX: {
 };
 declare const ASI_COIN_TYPE = 60;
 declare const ASI_DECIMALS = 8;
-declare const GasFee: {
-    BASE_FEE: number;
-    VARIATION_RANGE: number;
-    LABEL: string;
-    TRANSFER: string;
-    DEPLOY: string;
-};
 declare const HEX_RADIX: number;
 declare const HEX_BYTE_PADDING: number;
 declare const POWER_BASE: number;
@@ -491,14 +1053,34 @@ declare const DEFAULT_BIP_44_PATH_OPTIONS: {
     index: number;
 };
 
-declare const toAtomicAmount: (amount: number | string) => bigint;
-declare const fromAtomicAmountToString: (atomicAmount: bigint) => string;
-declare const fromAtomicAmountToNumber: (atomicAmount: bigint) => number;
-declare const fromAtomicAmount: (atomicAmount: bigint) => string;
-declare const genRandomHex: (size: number) => string;
-
 declare const setupBufferPolyfill: () => void;
 
+declare const encodeBase58: (hex: string) => string;
+declare const decodeBase58: (value: string) => Uint8Array;
+declare const decodeBase16: (hex: string) => Uint8Array;
+declare const encodeBase16: (bytes: Uint8Array) => string;
+declare const arrayBufferToBase64: (buffer: ArrayBuffer) => string;
+declare const base64ToArrayBuffer: (base64: string) => ArrayBuffer;
+declare const bufferToBigInt: (buffer: Uint8Array) => bigint;
+declare const bigIntToBuffer: (num: bigint) => Uint8Array;
+
+declare const genRandomHex: (size: number) => string;
+declare const generateRandomId: () => string;
+declare const toAtomicAmount: (amount: number | string, decimals: number) => bigint;
+declare const fromAtomicAmountToNumber: (atomicAmount: bigint, decimals: number) => number;
+declare const fromAtomicAmount: (atomicAmount: bigint, decimals: number) => string;
+declare const toUint8Array: (value: unknown) => Uint8Array;
+type IUrlValue = string | number | boolean | undefined;
+interface IUrlParams {
+    path?: Record<string, IUrlValue>;
+    query?: Record<string, IUrlValue | undefined | null>;
+}
+declare const buildUrl: (pathPrefix: string, params?: IUrlParams) => string;
+/**
+ * @returns address in the format accepted within the SDK application
+ */
+declare function normalizeAddress(address: string | undefined): string;
+
 declare const validateAccountName: (name: string, maxLength?: number) => {
     isValid: boolean;
     error?: string;
@@ -520,5 +1102,5 @@ interface AddressValidationResult {
 declare const validateAddress: (address: string) => AddressValidationResult;
 declare const isAddress: (address: string) => address is Address;
 
-export { ASI_BASE_UNIT, ASI_CHAIN_PREFIX, ASI_COIN_TYPE, ASI_DECIMALS, AddressValidationErrorCode, Asset, AssetsService, AxiosHttpClient, BinaryWriterService as BinaryWriter, BlockchainGateway, Client, CryptoService, DEFAULT_AXIOS_TIMEOUT_MS, DEFAULT_BIP_44_PATH_OPTIONS, DEFAULT_CLIENT_CONFIG, DEFAULT_DECIMALS_AMOUNT, DEFAULT_PHLO_LIMIT, DEFAULT_RESUBMIT_CONFIG, DEFAULT_STORAGE_KEY, DeployResubmitter, DeployStatus, DeploymentErrorHandler, EncryptedRecord, FAULT_TOLERANCE_THRESHOLD, FatalDeployErrors, FeeService, GasFee, HEX_BYTE_PADDING, HEX_RADIX, INVALID_BLOCK_NUMBER, KeyDerivationService, KeysManager, MAX_WALLETS_PER_ACCOUNT, MnemonicService, MnemonicStrength, POWER_BASE, PRIVATE_KEY_LENGTH, RecoverableDeployErrors, NodeManager as ResubmitNodeManager, BrowserStorage as SecureStorage, SignerService, Vault, Wallet, WalletClientModes, WalletMemoryKeys, WalletsService, arrayBufferToBase64, base64ToArrayBuffer, bigIntToBuffer, bufferToBigInt, decodeBase16, decodeBase58, deploymentErrorMessages, encodeBase16, encodeBase58, fromAtomicAmount, fromAtomicAmountToNumber, fromAtomicAmountToString, genRandomHex, getDeploymentErrorMessage, isAddress, setupBufferPolyfill, toAtomicAmount, validateAccountName, validateAddress };
-export type { Address, AddressValidationResult, AssetId, Assets, Bip44PathOptions, BlockchainGatewayConfig, ClientOptions, CreateWalletOptions, CryptoConfig, DeployStatusResult, DeploymentErrorType, EncryptedData, HttpClient, KeyPair, PasswordProvider, ResubmitConfig, ResubmitResult, Seeds, SignedResult, SigningCapability, SigningRequest, StoredSeedsMetaRecords, StoredWalletMeta, StoredWalletsMetaRecords, StringifiedWalletMeta, VaultRawData, WalletClientConfig, WalletMemory, WalletMeta, Wallets };
+export { ACCOUNTS_DATA_KEY, ASI_BASE_UNIT, ASI_CHAIN_PREFIX, ASI_COIN_TYPE, ASI_DECIMALS, Account, AccountDataService, AccountManager, AccountsStorageRepository, AddressValidationErrorCode, ApiClientManager, ApiServiceRegistry, Asset, AssetsService, BaseGraphQLClient, BaseHttpClient, BinaryWriterService as BinaryWriter, Bip44Path, BlockService, BrowserStorage, Client, CryptoService as Crypto, DEFAULT_ASSET, DEFAULT_BIP_44_PATH_OPTIONS, DEFAULT_NODE_STORAGE_DIR, DEFAULT_PHLO_LIMIT, DEFAULT_PHLO_PRICE, DEPLOY_STATUS_POLLING_TIMEOUT, DeployService, DeployStatus, DeployStatusPoller, DisposableItemManager, FAULT_TOLERANCE_THRESHOLD, GasFee, HEX_BYTE_PADDING, HEX_RADIX, INVALID_BLOCK_NUMBER, IndexerClient, ItemManager, KeyDerivationService as KeyDerivation, KeysManager, MnemonicService as Mnemonic, MnemonicStrength, NATIVE_TOKEN_DECIMALS_AMOUNT, NetworkConfigProvider, NodeStorage, ObserverClient, POWER_BASE, PRIVATE_KEY_LENGTH, RESERVATION_EXPIRATION_TIME, ReservationAdapterManager, SIGNERS_DATA_KEY, SecretsProvider, Signer, SignerService, SignersStorageRepository, StorageManager, TRANSACTION_RESERVATIONS_DATA_KEY, TransactionReservationsStorageRepository, TransactionService, ValidatorClient, Wallet, WalletManager, WalletTypes, WalletsService as Wallets, arrayBufferToBase64, base64ToArrayBuffer, bigIntToBuffer, bufferToBigInt, buildUrl, decodeBase16, decodeBase58, encodeBase16, encodeBase58, fromAtomicAmount, fromAtomicAmountToNumber, genRandomHex, generateRandomId, isAddress, normalizeAddress, setupBufferPolyfill, toAtomicAmount, toUint8Array, validateAccountName, validateAddress };
+export type { Address, AddressValidationResult, AssetId, Assets, CreateWalletOptions, CryptoConfig, DeployData, EncryptedData, IAccountHDData, IAccountMetadata, IAccountOptions, IAccountRecord, IAccountStorageRecord, IApiClients, IAssetOptions, IBalanceData, IBalanceResponse, IBaseHDWalletPrivateKeyData, IBip44PathOptions, IBlockDto, IClientEventDispatcher, ICreateClientFlags, ICreateClientOptions, ICreateHDWalletOptions, ICreateHDWalletParams, ICreateHDWalletPayload, ICreatePrivateKeyWalletPayload, ICreatedAccountData, IDeployConfirmedResult, IDeployStatusResult, IDeployWatchCallbacks, IDeployWatchHandle, IDeployWatchOptions, IDerivedAccount, IDisposable, IFullWalletRecord, IGetBlocksParams, IGetWalletFromStorageOptions, IHDSecret, IHDSecretRecord, IHDSignerEncryptedFields, IHDWalletPrivateKeyDataFromMnemonic, IHDWalletPrivateKeyDataFromSeed, INetworkConfig, IPasswordCredentials, IPortfolioOptions, IPrivateKeyCredentials, IPrivateKeySignerEncryptedFields, IPrivateKeyWithCredentials, IPublicWalletRecord, IRestoreWalletPayload, ISaveAccountToStorageOptions, ISaveSignerToStorageOptions, ISaveTransactionReservationsOptions, ISaveWalletToStorageOptions, ISeedCredentials, ISignedMessageResponse, ISignerOptions, ISignerRecord, ISignerStorageRecord, ITableRecord, ITableService, ITransactionReservation, ITransactionReservationPrivateData, ITransactionReservationsStorageRecord, ITransferDetails, ITransferPayload, ITransferRequest, IUnlockedWallet, IUrlParams, IUrlValue, IWalletMetadata, IWalletOptions, IWalletRecordEncryptedFields, IWalletStorageData, KeyPair, NetworkName, SignedResult, SigningRequest, TAxiosClientConfig, TBlocksView, TCreateAccountPayload, TCreateHDPathWalletOptions, TEditableAccountOptions, THDSigningContext, TNetworksConfig, TPKSigningContext, TSecretsProviderInterface, TSigningContext, Transaction, WalletMeta };