@fuel-ts/account 0.0.0-rc-1815-20240322115843 → 0.0.0-rc-1889-20240322122653

package/dist/index.d.ts

@@ -1,13 +1,904 @@
-import './test-utils.js';
-import './configs.js';
-export * from './account';
-export * from './wallet';
-export * from './hdwallet';
-export * from './mnemonic';
-export * from './wordlists';
-export * from './signer';
-export * from './wallet-manager';
-export * from './predicate';
-export * from './providers';
-export * from './connectors';
-//# sourceMappingURL=index.d.ts.map
+import { T as TransactionRequestLike, a as TransactionRequest, b as TransactionResultReceipt, G as GqlTransactionStatusesNames, c as TransactionStatus, d as GraphqlTransactionStatus, e as TransactionSummary, f as TransactionTypeName, O as OperationCoin, g as Operation, I as InputParam, R as ReceiptParam, h as InputOutputParam, i as GetOperationParams, j as RawPayloadParam, k as GetTransferOperationsParams, P as Provider, A as AbiMap, l as TransactionResult, m as GqlGetTransactionsByOwnerQueryVariables, n as GqlPageInfo, o as GqlGasCosts, p as GqlReceiptFragmentFragment, M as MintedAsset, B as BurnedAsset, q as GqlConsensusParameters, r as GqlFeeParameters, s as GqlDependentCost, t as TransactionRequestInput, N as NetworkEthereum, u as NetworkFuel, v as Asset, w as AssetEth, x as AssetFuel, y as Assets, W as WalletLocked, z as WalletUnlocked, F as FuelConnector, C as Network$1, D as Account } from './account-E9nGNf5X.js';
+export { bj as AccountEvent, bi as AccountsEvent, b7 as AddressType, bp as AssetsEvent, aF as BaseTransactionRequest, aE as BaseTransactionRequestLike, H as BaseWalletUnlocked, a0 as Block, ah as BlockHeader, b4 as BlockId, _ as CallResult, a2 as ChainInfo, b8 as ChainName, az as ChangeTransactionRequestOutput, Z as Coin, U as CoinQuantity, Q as CoinQuantityLike, at as CoinTransactionRequestInput, ax as CoinTransactionRequestOutput, bk as ConnectionEvent, bo as ConnectorEvent, bb as ConnectorMetadata, bn as ConnectorsEvent, aB as ContractCreatedTransactionRequestOutput, a1 as ContractResult, av as ContractTransactionRequestInput, ay as ContractTransactionRequestOutput, aH as CreateTransactionRequest, aG as CreateTransactionRequestLike, a6 as CursorPaginationArgs, aa as EstimatePredicateParams, a9 as EstimateTransactionParams, $ as EstimateTxDependenciesReturns, ao as ExcludeResourcesOption, a_ as FailureStatus, bg as FuelABI, be as FuelConnectorEventType, bd as FuelConnectorEventTypes, bq as FuelConnectorEvents, br as FuelConnectorEventsType, bc as FuelConnectorMethods, bh as FuelEventArg, J as GenerateOptions, aY as GqlTransaction, X as IAddAmountToAssetParams, ag as MerkleProof, ae as Message, af as MessageCoin, ai as MessageProof, aj as MessageStatus, au as MessageTransactionRequestInput, bl as NetworkEvent, bm as NetworksEvent, a3 as NodeInfo, a4 as NodeInfoAndConsensusParameters, b6 as OperationFunctionCall, b5 as OperationName, b9 as OperationTransactionAddress, ba as OutputParam, L as Predicate, K as PredicateParams, b2 as ProgramState, ac as ProviderCallParams, a7 as ProviderOptions, ad as ProviderSendTxParams, ak as RawCoin, al as RawMessage, am as RawResource, b1 as Reason, an as Resource, aJ as ScriptTransactionRequest, aI as ScriptTransactionRequestLike, S as Signer, b0 as SqueezedOutStatus, a$ as SubmittedStatus, aZ as SuccessStatus, b3 as Time, a5 as TransactionCost, ab as TransactionCostParams, aC as TransactionRequestOutput, aX as TransactionResponse, aW as TransactionResultBurnReceipt, aK as TransactionResultCallReceipt, aQ as TransactionResultLogDataReceipt, aP as TransactionResultLogReceipt, aU as TransactionResultMessageOutReceipt, aV as TransactionResultMintReceipt, aN as TransactionResultPanicReceipt, aM as TransactionResultReturnDataReceipt, aL as TransactionResultReturnReceipt, aO as TransactionResultRevertReceipt, aT as TransactionResultScriptResultReceipt, aS as TransactionResultTransferOutReceipt, aR as TransactionResultTransferReceipt, E as TxParamsType, a8 as UTXOValidationParams, aA as VariableTransactionRequestOutput, bf as Version, Y as addAmountToAsset, V as coinQuantityfy, aw as inputify, ar as isCoin, as as isMessage, ap as isRawCoin, aq as isRawMessage, aD as outputify } from './account-E9nGNf5X.js';
+import { BytesLike, AbstractAddress, AbstractScriptRequest } from '@fuel-ts/interfaces';
+import { EventEmitter } from 'events';
+import { Interface } from '@fuel-ts/abi-coder';
+import * as _fuel_ts_transactions from '@fuel-ts/transactions';
+import { Output, OutputType, OutputContractCreated, OutputCoin, OutputChange, OutputContract, OutputVariable, Input, InputType, InputCoin, InputMessage, InputContract, ReceiptType, TransactionType, Transaction, ReceiptRevert, ReceiptPanic, ReceiptCall, ReceiptReturn, ReceiptReturnData, ReceiptLog, ReceiptLogData, ReceiptTransfer, ReceiptTransferOut, ReceiptScriptResult, ReceiptMessageOut, ReceiptMint, ReceiptBurn } from '@fuel-ts/transactions';
+export { TransactionType } from '@fuel-ts/transactions';
+import { BN, BNInput } from '@fuel-ts/math';
+import '@fuel-ts/address';
+import 'ethers';
+import 'graphql';
+
+/**
+ * @hidden
+ *
+ * Calculates the predicate root for a given bytecode and chain ID.
+ *
+ * @param bytecode - The bytecode represented as a BytesLike object.
+ * @param chainId - The ID of the chain associated with the bytecode.
+ * @returns The predicate root as a string.
+ */
+declare const getPredicateRoot: (bytecode: BytesLike) => string;
+
+/**
+ * @hidden
+ */
+declare class ChangeOutputCollisionError extends Error {
+    name: string;
+    message: string;
+}
+/**
+ * @hidden
+ */
+declare class NoWitnessAtIndexError extends Error {
+    readonly index: number;
+    name: string;
+    constructor(index: number);
+}
+/**
+ * @hidden
+ */
+declare class NoWitnessByOwnerError extends Error {
+    readonly owner: AbstractAddress;
+    name: string;
+    constructor(owner: AbstractAddress);
+}
+
+/** @hidden */
+declare const returnZeroScript: AbstractScriptRequest<void>;
+/** @hidden */
+declare const withdrawScript: AbstractScriptRequest<void>;
+
+/** @hidden */
+declare const transactionRequestify: (obj: TransactionRequestLike) => TransactionRequest;
+
+/** @hidden */
+declare function getDecodedLogs<T = unknown>(receipts: Array<TransactionResultReceipt>, abiInterface: Interface): T[];
+
+/** @hidden */
+declare function getOutputsByType<T = Output>(outputs: Output[], type: OutputType): T[];
+/** @hidden */
+declare function getOutputsContractCreated(outputs: Output[]): OutputContractCreated[];
+/** @hidden */
+declare function getOutputsCoin(outputs: Output[]): OutputCoin[];
+/** @hidden */
+declare function getOutputsChange(outputs: Output[]): OutputChange[];
+/** @hidden */
+declare function getOutputsContract(outputs: Output[]): OutputContract[];
+/** @hidden */
+declare function getOutputsVariable(outputs: Output[]): OutputVariable[];
+
+/** @hidden */
+declare function getInputsByTypes<T = Input>(inputs: Input[], types: Array<InputType>): T[];
+/** @hidden */
+declare function getInputsByType<T = Input>(inputs: Input[], type: InputType): T[];
+/** @hidden */
+declare function getInputsCoin(inputs: Input[]): InputCoin[];
+/** @hidden */
+declare function getInputsMessage(inputs: Input[]): InputMessage[];
+/** @hidden */
+declare function getInputsCoinAndMessage(inputs: Input[]): (InputCoin | InputMessage)[];
+/** @hidden */
+declare function getInputsContract(inputs: Input[]): InputContract[];
+/** @hidden */
+declare function getInputFromAssetId(inputs: Input[], assetId: string): InputCoin | InputMessage | undefined;
+/** @hidden */
+declare function getInputContractFromIndex(inputs: Input[], inputIndex: number): InputContract | undefined;
+/** @hidden */
+declare function getInputAccountAddress(input: Input): string;
+
+/** @hidden */
+declare const getTransactionStatusName: (gqlStatus: GqlTransactionStatusesNames) => TransactionStatus;
+type IProcessGraphqlStatusResponse = Pick<TransactionSummary, 'time' | 'blockId' | 'isStatusPending' | 'isStatusSuccess' | 'isStatusFailure' | 'status'>;
+/** @hidden */
+declare const processGraphqlStatus: (gqlTransactionStatus?: GraphqlTransactionStatus) => IProcessGraphqlStatusResponse;
+
+/** @hidden */
+declare function getReceiptsByType<T = TransactionResultReceipt>(receipts: TransactionResultReceipt[], type: ReceiptType): T[];
+/** @hidden */
+declare function getTransactionTypeName(transactionType: TransactionType): TransactionTypeName;
+/** @hidden */
+declare function isType(transactionType: TransactionType, type: TransactionTypeName): boolean;
+/** @hidden */
+declare function isTypeMint(transactionType: TransactionType): boolean;
+/** @hidden */
+declare function isTypeCreate(transactionType: TransactionType): boolean;
+/** @hidden */
+declare function isTypeScript(transactionType: TransactionType): boolean;
+/** @hidden */
+declare function hasSameAssetId(a: OperationCoin): (b: OperationCoin) => boolean;
+/** @hidden */
+declare function getReceiptsCall(receipts: TransactionResultReceipt[]): _fuel_ts_transactions.ReceiptCall[];
+/** @hidden */
+declare function getReceiptsMessageOut(receipts: TransactionResultReceipt[]): _fuel_ts_transactions.ReceiptMessageOut[];
+/** @hidden */
+declare function addOperation(operations: Operation[], toAdd: Operation): Operation[];
+/** @hidden */
+declare function getReceiptsTransferOut(receipts: TransactionResultReceipt[]): _fuel_ts_transactions.ReceiptTransferOut[];
+/** @hidden */
+declare function getWithdrawFromFuelOperations({ inputs, receipts, }: InputParam & ReceiptParam): Operation[];
+/** @hidden */
+declare function getContractCallOperations({ inputs, outputs, receipts, abiMap, rawPayload, maxInputs, }: InputOutputParam & ReceiptParam & Pick<GetOperationParams, 'abiMap' | 'maxInputs'> & RawPayloadParam): Operation[];
+/** @hidden */
+declare function getTransferOperations({ inputs, outputs, receipts, }: GetTransferOperationsParams): Operation[];
+/** @hidden */
+declare function getPayProducerOperations(outputs: Output[]): Operation[];
+/** @hidden */
+declare function getContractCreatedOperations({ inputs, outputs }: InputOutputParam): Operation[];
+/** @hidden */
+declare function getOperations({ transactionType, inputs, outputs, receipts, abiMap, rawPayload, maxInputs, }: GetOperationParams): Operation[];
+
+/** @hidden */
+interface GetTransactionSummaryParams {
+    id: string;
+    provider: Provider;
+    abiMap?: AbiMap;
+}
+declare function getTransactionSummary<TTransactionType = void>(params: GetTransactionSummaryParams): Promise<TransactionResult>;
+interface GetTransactionSummaryFromRequestParams {
+    transactionRequest: TransactionRequest;
+    provider: Provider;
+    abiMap?: AbiMap;
+}
+/** @hidden */
+declare function getTransactionSummaryFromRequest<TTransactionType = void>(params: GetTransactionSummaryFromRequestParams): Promise<TransactionSummary<TTransactionType>>;
+interface GetTransactionsSummariesParams {
+    provider: Provider;
+    filters: GqlGetTransactionsByOwnerQueryVariables;
+    abiMap?: AbiMap;
+}
+interface GetTransactionsSummariesReturns {
+    transactions: TransactionResult[];
+    pageInfo: GqlPageInfo;
+}
+/** @hidden */
+declare function getTransactionsSummaries(params: GetTransactionsSummariesParams): Promise<GetTransactionsSummariesReturns>;
+
+interface AssembleTransactionSummaryParams {
+    gasPerByte: BN;
+    gasPriceFactor: BN;
+    transaction: Transaction;
+    id?: string;
+    transactionBytes: Uint8Array;
+    gqlTransactionStatus?: GraphqlTransactionStatus;
+    receipts: TransactionResultReceipt[];
+    abiMap?: AbiMap;
+    maxInputs: BN;
+    gasCosts: GqlGasCosts;
+}
+/** @hidden */
+declare function assembleTransactionSummary<TTransactionType = void>(params: AssembleTransactionSummaryParams): TransactionSummary<TTransactionType>;
+
+declare const processGqlReceipt: (gqlReceipt: GqlReceiptFragmentFragment) => TransactionResultReceipt;
+declare const extractMintedAssetsFromReceipts: (receipts: Array<TransactionResultReceipt>) => MintedAsset[];
+declare const extractBurnedAssetsFromReceipts: (receipts: Array<TransactionResultReceipt>) => BurnedAsset[];
+
+type FeeParams = Pick<GqlFeeParameters, 'gasPerByte' | 'gasPriceFactor'> | {
+    gasPerByte: BN | number;
+    gasPriceFactor: BN | number;
+};
+type CalculateTransactionFeeParams = {
+    gasUsed: BN;
+    rawPayload: string;
+    consensusParameters: Pick<GqlConsensusParameters, 'gasCosts'> & {
+        feeParams: FeeParams;
+    };
+};
+declare const calculateTransactionFee: (params: CalculateTransactionFeeParams) => {
+    fee: BN;
+    minFee: BN;
+    maxFee: BN;
+    feeFromGasUsed: BN;
+};
+
+/** @hidden */
+declare const getReceiptsWithMissingData: (receipts: Array<TransactionResultReceipt>) => {
+    missingOutputVariables: Array<ReceiptRevert>;
+    missingOutputContractIds: Array<ReceiptPanic>;
+};
+declare function assembleReceiptByType(receipt: GqlReceiptFragmentFragment): ReceiptCall | ReceiptReturn | ReceiptReturnData | ReceiptPanic | ReceiptRevert | ReceiptLog | ReceiptLogData | ReceiptTransfer | ReceiptTransferOut | ReceiptScriptResult | ReceiptMessageOut | ReceiptMint | ReceiptBurn;
+
+/**
+ * @hidden
+ *
+ * Builds a block explorer url based on and the given path, block explorer URL and provider URL
+ */
+declare const buildBlockExplorerUrl: (options?: {
+    blockExplorerUrl?: string;
+    path?: string;
+    providerUrl?: string;
+    address?: string;
+    txId?: string;
+    blockNumber?: number;
+}) => string;
+
+/** @hidden */
+declare const calculatePriceWithFactor: (gas: BN, gasPrice: BN, priceFactor: BN) => BN;
+/** @hidden */
+declare const getGasUsedFromReceipts: (receipts: Array<TransactionResultReceipt>) => BN;
+declare function resolveGasDependentCosts(byteSize: BNInput, gasDependentCost: GqlDependentCost): BN;
+declare function gasUsedByInputs(inputs: Array<TransactionRequestInput | Input>, txBytesSize: number, gasCosts: GqlGasCosts): BN;
+interface IGetMinGasParams {
+    inputs: Array<TransactionRequestInput | Input>;
+    gasCosts: GqlGasCosts;
+    txBytesSize: number;
+    metadataGas: BN;
+    gasPerByte: BN;
+}
+declare function getMinGas(params: IGetMinGasParams): BN;
+interface IGetMaxGasParams {
+    witnessesLength: number;
+    witnessLimit?: BN;
+    gasPerByte: BN;
+    minGas: BN;
+    gasLimit?: BN;
+}
+declare function getMaxGas(params: IGetMaxGasParams): BN;
+declare function calculateMetadataGasForTxCreate({ gasCosts, stateRootSize, txBytesSize, contractBytesSize, }: {
+    gasCosts: GqlGasCosts;
+    contractBytesSize: BN;
+    stateRootSize: number;
+    txBytesSize: number;
+}): BN;
+declare function calculateMetadataGasForTxScript({ gasCosts, txBytesSize, }: {
+    gasCosts: GqlGasCosts;
+    txBytesSize: number;
+}): BN;
+
+/**
+ * Stringify Transaction to a JSON object
+ * compatible with the Transaction class constructor.
+ */
+/** @hidden */
+declare function normalizeJSON(root: any): any;
+
+/** @hidden */
+declare function sleep(time: number): Promise<unknown>;
+
+type Network = NetworkEthereum | NetworkFuel;
+type NetworkTypes = NetworkEthereum['type'] | NetworkFuel['type'];
+type NetworkTypeToNetwork<T> = T extends 'ethereum' ? NetworkEthereum : T extends 'fuel' ? NetworkFuel : Network;
+/**
+ * Returns the default chainId for the given network
+*/
+declare const getDefaultChainId: (networkType: NetworkTypes) => number | undefined;
+type GetAssetNetworkParams<T extends NetworkTypes | undefined> = {
+    asset: Asset;
+    chainId?: number;
+    networkType: T;
+};
+/**
+ * Returns the asset's network on the given network
+ * eg. getAssetNetwork({ asset, chainId: 1, networkType: 'ethereum' }) will return the asset's details on Ethereum mainnet
+*/
+declare const getAssetNetwork: <T extends NetworkTypes | undefined>({ asset, chainId, networkType, }: GetAssetNetworkParams<T>) => NetworkTypeToNetwork<T>;
+/**
+ * Returns the asset's details on the given network alongwith the asset itself
+ * eg. getAssetWithNetwork({ asset, chainId: 1, networkType: 'ethereum' }) will return the asset's details on Ethereum mainnet and the asset itself
+*/
+declare const getAssetWithNetwork: <T extends NetworkTypes>({ asset, chainId, networkType, }: GetAssetNetworkParams<T>) => AssetEth | AssetFuel | undefined;
+/**
+ * Returns the asset's details on Ethereum
+*/
+declare const getAssetEth: (asset: Asset, chainId?: number) => AssetEth | undefined;
+/**
+ * Returns the asset's details on Fuel
+*/
+declare const getAssetFuel: (asset: Asset, chainId?: number) => AssetFuel | undefined;
+
+/**
+ * Returns the list of assets with the icon paths 'resolved'. eg. `./eth.svg` -> `https://some-url.com/eth.svg`
+ * @param assets - List of assets
+ * @param basePath - Base path for the icon URLs (default: './')
+ * @returns The assets with the icon paths resolved
+ */
+declare function resolveIconPaths(assets: Assets, basePath?: string): {
+    icon: string;
+    name: string;
+    symbol: string;
+    networks: (NetworkEthereum | NetworkFuel)[];
+}[];
+
+declare function urlJoin(baseUrl: string | undefined, ...paths: Array<string>): string;
+
+declare const assets: Assets;
+
+declare const CHAIN_IDS: {
+    eth: {
+        sepolia: number;
+        foundry: number;
+    };
+    fuel: {
+        beta5: number;
+        devnet: number;
+    };
+};
+
+/**
+ * `Wallet` provides methods to create locked and unlocked wallet instances.
+ */
+declare class Wallet {
+    /**
+     * Creates a locked wallet instance from an address and a provider.
+     *
+     * @param address - The address of the wallet.
+     * @param provider - A Provider instance (optional).
+     * @returns A locked wallet instance.
+     */
+    static fromAddress(address: string | AbstractAddress, provider?: Provider): WalletLocked;
+    /**
+     * Creates an unlocked wallet instance from a private key and a provider.
+     *
+     * @param privateKey - The private key of the wallet.
+     * @param provider - A Provider instance (optional).
+     * @returns An unlocked wallet instance.
+     */
+    static fromPrivateKey(privateKey: BytesLike, provider?: Provider): WalletUnlocked;
+    /**
+     * Generate a new Wallet Unlocked with a random key pair.
+     *
+     * @param generateOptions - Options to customize the generation process (optional).
+     * @returns An unlocked wallet instance.
+     */
+    static generate: typeof WalletUnlocked.generate;
+    /**
+     * Create a Wallet Unlocked from a seed.
+     *
+     * @param seed - The seed phrase.
+     * @param provider - A Provider instance (optional).
+     * @param path - The derivation path (optional).
+     * @returns An unlocked wallet instance.
+     */
+    static fromSeed: typeof WalletUnlocked.fromSeed;
+    /**
+     * Create a Wallet Unlocked from a mnemonic phrase.
+     *
+     * @param mnemonic - The mnemonic phrase.
+     * @param provider - A Provider instance (optional).
+     * @param path - The derivation path (optional).
+     * @param passphrase - The passphrase for the mnemonic (optional).
+     * @returns An unlocked wallet instance.
+     */
+    static fromMnemonic: typeof WalletUnlocked.fromMnemonic;
+    /**
+     * Create a Wallet Unlocked from an extended key.
+     *
+     * @param extendedKey - The extended key.
+     * @param provider - A Provider instance (optional).
+     * @returns An unlocked wallet instance.
+     */
+    static fromExtendedKey: typeof WalletUnlocked.fromExtendedKey;
+    /**
+     * Create a Wallet Unlocked from an encrypted JSON.
+     *
+     * @param jsonWallet - The encrypted JSON keystore.
+     * @param password - The password to decrypt the JSON.
+     * @param provider - A Provider instance (optional).
+     * @returns An unlocked wallet instance.
+     */
+    static fromEncryptedJson: typeof WalletUnlocked.fromEncryptedJson;
+}
+
+type WalletManagerAccount = {
+    address: AbstractAddress;
+    publicKey: string;
+    vaultId?: number;
+};
+type WalletManagerOptions = {
+    storage: StorageAbstract;
+};
+type VaultConfig = {
+    type: string;
+    title?: string;
+    secret?: string;
+};
+type VaultsState = Array<{
+    type: string;
+    title?: string;
+    data?: VaultConfig;
+    vault: Vault;
+}>;
+interface WalletManagerState {
+    vaults: VaultsState;
+}
+declare abstract class Vault<TOptions = {
+    secret?: string;
+}> {
+    static readonly type: string;
+    constructor(_options: TOptions);
+    serialize(): TOptions;
+    getAccounts(): WalletManagerAccount[];
+    addAccount(): WalletManagerAccount;
+    exportAccount(_address: AbstractAddress): string;
+    getWallet(_address: AbstractAddress): WalletUnlocked;
+}
+declare abstract class StorageAbstract {
+    abstract setItem(key: string, value: string): Promise<void>;
+    abstract getItem(key: string): Promise<string | null | undefined>;
+    abstract removeItem(key: string): Promise<void>;
+    abstract clear(): Promise<void>;
+}
+
+interface MnemonicVaultOptions {
+    secret?: string;
+    rootPath?: string;
+    numberOfAccounts?: number | null;
+}
+declare class MnemonicVault implements Vault<MnemonicVaultOptions> {
+    #private;
+    static readonly type = "mnemonic";
+    pathKey: string;
+    rootPath: string;
+    numberOfAccounts: number;
+    constructor(options: MnemonicVaultOptions);
+    getDerivePath(index: number): string;
+    serialize(): MnemonicVaultOptions;
+    getAccounts(): {
+        publicKey: string;
+        address: AbstractAddress;
+    }[];
+    addAccount(): {
+        publicKey: string;
+        address: AbstractAddress;
+    };
+    exportAccount(address: string | AbstractAddress): string;
+    getWallet(address: string | AbstractAddress): WalletUnlocked;
+}
+
+interface PkVaultOptions {
+    secret?: string;
+    accounts?: Array<string>;
+}
+declare class PrivateKeyVault implements Vault<PkVaultOptions> {
+    #private;
+    static readonly type = "privateKey";
+    /**
+     * If privateKey vault is initialized with a secretKey, it creates
+     * one account with the fallowing secret
+     */
+    constructor(options?: PkVaultOptions);
+    serialize(): PkVaultOptions;
+    getPublicAccount(privateKey: string): {
+        address: AbstractAddress;
+        publicKey: string;
+    };
+    getAccounts(): WalletManagerAccount[];
+    addAccount(): {
+        address: AbstractAddress;
+        publicKey: string;
+    };
+    exportAccount(address: string | AbstractAddress): string;
+    getWallet(address: string | AbstractAddress): WalletUnlocked;
+}
+
+/**
+ * WalletManager is a upper package to manage multiple vaults like mnemonic and privateKeys.
+ *
+ * - VaultTypes can be add to `WalletManager.Vaults` enabling to add custom Vault types.
+ * - Storage can be instantiate when initializing enabling custom storage types.
+ */
+declare class WalletManager extends EventEmitter {
+    #private;
+    /**
+     * Vaults
+     *
+     * Vaults are responsible to store secret keys and return an `Wallet` instance,
+     * to interact with the network.
+     *
+     * Each vault has access to its own state
+     *
+     */
+    static Vaults: (typeof MnemonicVault | typeof PrivateKeyVault)[];
+    /**
+     * Storage
+     *
+     * Persistent encrypted data. `The default storage works only on memory`.
+     */
+    readonly storage: StorageAbstract;
+    readonly STORAGE_KEY: string;
+    constructor(options?: WalletManagerOptions);
+    get isLocked(): boolean;
+    /**
+     * Return the vault serialized object containing all the privateKeys,
+     * the format of the return depends on the Vault type.
+     */
+    exportVault<T extends Vault>(vaultId: number): ReturnType<T['serialize']>;
+    /**
+     * List all vaults on the Wallet Manager, this function not return secret's
+     */
+    getVaults(): Array<{
+        title?: string;
+        type: string;
+        vaultId: number;
+    }>;
+    /**
+     * List all accounts on the Wallet Manager not vault information is revealed
+     */
+    getAccounts(): Array<WalletManagerAccount>;
+    /**
+     * Create a Wallet instance for the specific account
+     */
+    getWallet(address: string | AbstractAddress): WalletUnlocked;
+    /**
+     * Export specific account privateKey
+     */
+    exportPrivateKey(address: string | AbstractAddress): string;
+    /**
+     * Add account to a selected vault or on the first vault as default.
+     * If not vaults are adds it will return error
+     */
+    addAccount(options?: {
+        vaultId: number;
+    }): Promise<WalletManagerAccount>;
+    /**
+     * Remove vault by index, by remove the vault you also remove all accounts
+     * created by the vault.
+     */
+    removeVault(index: number): Promise<void>;
+    /**
+     * Add Vault, the `vaultConfig.type` will look for the Vaults supported if
+     * didn't found it will throw.
+     */
+    addVault(vaultConfig: VaultConfig): Promise<void>;
+    /**
+     * Lock wallet. It removes passphrase from class instance, encrypt and hide all address and
+     * secrets.
+     */
+    lock(): void;
+    /**
+     * Unlock wallet. It sets passphrase on WalletManger instance load all address from configured vaults.
+     * Vaults with secrets are not unlocked or instantiated on this moment.
+     */
+    unlock(passphrase: string): Promise<void>;
+    /**
+     * Update WalletManager encryption passphrase
+     */
+    updatePassphrase(oldpass: string, newpass: string): Promise<void>;
+    /**
+     * Retrieve and decrypt WalletManager state from storage
+     */
+    loadState(): Promise<void>;
+    /**
+     * Store encrypted WalletManager state on storage
+     */
+    private saveState;
+    /**
+     * Return a instantiable Class reference from `WalletManager.Vaults` supported list.
+     */
+    private getVaultClass;
+}
+
+declare class MemoryStorage implements StorageAbstract {
+    storage: Map<string, unknown>;
+    getItem<T>(key: string): Promise<T | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+
+declare class LocalStorage implements StorageAbstract {
+    private storage;
+    constructor(localStorage: Storage);
+    setItem(key: string, value: string): Promise<void>;
+    getItem(key: string): Promise<string | null | undefined>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+
+/**
+ * Target Object that represents the global event bus used by Fuel Connector Manager.
+ * On browser the default target is the window or document. For other environments
+ * the event bus should be provided.
+ */
+interface TargetObject {
+    on?: (event: string, callback: any) => void;
+    off?: (event: string, callback: any) => void;
+    emit?: (event: string, data: any) => void;
+    addEventListener?: (event: string, callback: any) => void;
+    removeEventListener?: (event: string, callback: any) => void;
+    postMessage?: (message: string) => void;
+}
+
+type FuelConfig = {
+    connectors?: Array<FuelConnector>;
+    storage?: StorageAbstract | null;
+    targetObject?: TargetObject;
+};
+type FuelConnectorSelectOptions = {
+    emitEvents?: boolean;
+};
+type Status = {
+    installed: boolean;
+    connected: boolean;
+};
+declare class Fuel extends FuelConnector {
+    static STORAGE_KEY: string;
+    static defaultConfig: FuelConfig;
+    private _storage?;
+    private _connectors;
+    private _targetObject;
+    private _unsubscribes;
+    private _targetUnsubscribe;
+    private _pingCache;
+    private _currentConnector?;
+    constructor(config?: FuelConfig);
+    /**
+     * Return the target object to listen for global events.
+     */
+    private getTargetObject;
+    /**
+     * Return the storage used.
+     */
+    private getStorage;
+    /**
+     * Setup the default connector from the storage.
+     */
+    private setDefaultConnector;
+    /**
+     * Start listener for all the events of the current
+     * connector and emit them to the Fuel instance
+     */
+    private setupConnectorEvents;
+    /**
+     * Call method from the current connector.
+     */
+    private callMethod;
+    /**
+     * Create a method for each method proxy that is available on the Common interface
+     * and call the method from the current connector.
+     */
+    private setupMethods;
+    /**
+     * Fetch the status of a connector and set the installed and connected
+     * status.
+     */
+    private fetchConnectorStatus;
+    /**
+     * Fetch the status of all connectors and set the installed and connected
+     * status.
+     */
+    private fetchConnectorsStatus;
+    /**
+     * Fetch the status of a connector and set the installed and connected
+     * status. If no connector is provided it will ping the current connector.
+     */
+    private pingConnector;
+    /**
+     * Setup a listener for the FuelConnector event and add the connector
+     * to the list of new connectors.
+     */
+    private setupConnectorListener;
+    /**
+     * Add a new connector to the list of connectors.
+     */
+    private addConnector;
+    private triggerConnectorEvents;
+    /**
+     * Get a connector from the list of connectors.
+     */
+    getConnector: (connector: FuelConnector | string) => FuelConnector | null;
+    /**
+     * Return the list of connectors with the status of installed and connected.
+     */
+    connectors(): Promise<Array<FuelConnector>>;
+    /**
+     * Set the current connector to be used.
+     */
+    selectConnector(connectorName: string, options?: FuelConnectorSelectOptions): Promise<boolean>;
+    /**
+     * Return the current selected connector.
+     */
+    currentConnector(): FuelConnector | null | undefined;
+    /**
+     * Return true if any connector is available.
+     */
+    hasConnector(): Promise<boolean>;
+    hasWallet(): Promise<boolean>;
+    /**
+     * Return a Fuel Provider instance with extends features to work with
+     * connectors.
+     *
+     * @deprecated getProvider is deprecated and is going to be removed in the future, use getWallet instead.
+     */
+    getProvider(providerOrNetwork?: Provider | Network$1): Promise<Provider>;
+    /**
+     * Return a Fuel Provider instance with extends features to work with
+     * connectors.
+     */
+    private _getProvider;
+    /**
+     * Return a Fuel Wallet Locked instance with extends features to work with
+     * connectors.
+     */
+    getWallet(address: string | AbstractAddress, providerOrNetwork?: Provider | Network$1): Promise<Account>;
+    /**
+     * Remove all open listeners this is useful when you want to
+     * remove the Fuel instance and avoid memory leaks.
+     */
+    unsubscribe(): void;
+    /**
+     * Clean all the data from the storage.
+     */
+    clean(): Promise<void>;
+    /**
+     * Removes all listeners and cleans the storage.
+     */
+    destroy(): Promise<void>;
+}
+
+type CacheFor = {
+    [key: string]: {
+        timeout: number;
+        value: unknown;
+    } | null;
+};
+type CacheForOptions = {
+    key: string;
+    cache: CacheFor;
+    cacheTime: number;
+};
+declare function cacheFor<F extends (...args: unknown[]) => Promise<unknown>>(fn: F, { cache, cacheTime, key }: CacheForOptions): F;
+
+/**
+ * Fuel Connector Event is a custom event that can be used by the connector to
+ * inform the Fuel Connector Manager that a new connector is available.
+ */
+declare function dispatchFuelConnectorEvent(connector: FuelConnector): void;
+
+type DeferPromise<R = unknown> = {
+    promise: Promise<R>;
+    resolve: (value: R) => void;
+    reject: (error: unknown) => void;
+};
+declare function deferPromise<R = unknown>(): DeferPromise<R>;
+declare function withTimeout<F extends Promise<unknown>, RT = Awaited<F>>(promise: F, timeout?: number): Promise<RT>;
+
+type HDWalletConfig = {
+    privateKey?: BytesLike;
+    publicKey?: BytesLike;
+    chainCode: BytesLike;
+    depth?: number;
+    index?: number;
+    parentFingerprint?: string;
+};
+declare class HDWallet {
+    depth: number;
+    index: number;
+    fingerprint: string;
+    parentFingerprint: string;
+    privateKey?: string;
+    publicKey: string;
+    chainCode: BytesLike;
+    /**
+     * HDWallet is a implementation of the BIP-0044 and BIP-0032, Multi-Account Hierarchy for Deterministic Wallets
+     *
+     * @param config - Wallet configurations
+     */
+    constructor(config: HDWalletConfig);
+    get extendedKey(): string;
+    /**
+     * Derive the current HDWallet instance navigating only on the index.
+     * `Ex.: m/44'/0 -> Ex.: m/44'/1 -> m/44'/2`. [Learn more](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki)
+     *
+     * @param index - Index of the child HDWallet.
+     * @returns A new instance of HDWallet on the derived index
+     */
+    deriveIndex(index: number): HDWallet;
+    /**
+     * Derive the current HDWallet instance to the path. [Learn more](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki)
+     *
+     * @param path - The string representation of the child HDWallet. `Ex.: m/44'/0'/0'/0/0`
+     * @returns A new instance of HDWallet on the derived path
+     */
+    derivePath(path: string): HDWallet;
+    /**
+     * Get the extendKey as defined on BIP-32 from the provided seed
+     *
+     * @param isPublic - enable to export public extendedKey, it not required when HDWallet didn't have the privateKey.
+     * @param testnet - Inform if should use testnet or mainnet prefix, default value is true (`mainnet`).
+     * @returns BIP-32 extended private key
+     */
+    toExtendedKey(isPublic?: boolean, testnet?: boolean): string;
+    /**
+     * Create HDWallet instance from seed
+     *
+     * @param seed - Seed
+     * @returns A new instance of HDWallet
+     */
+    static fromSeed(seed: string): HDWallet;
+    static fromExtendedKey(extendedKey: string): HDWallet;
+}
+
+type MnemonicPhrase = string | Array<string>;
+
+declare const MNEMONIC_SIZES: number[];
+declare class Mnemonic {
+    wordlist: Array<string>;
+    /**
+     *
+     * @param wordlist - Provide a wordlist with the list of words used to generate the mnemonic phrase. The default value is the English list.
+     * @returns Mnemonic instance
+     */
+    constructor(wordlist?: Array<string>);
+    /**
+     *
+     * @param phrase - Mnemonic phrase composed by words from the provided wordlist
+     * @returns Entropy hash
+     */
+    mnemonicToEntropy(phrase: MnemonicPhrase): string;
+    /**
+     *
+     * @param entropy - Entropy source to the mnemonic phrase.
+     * @returns Mnemonic phrase
+     */
+    entropyToMnemonic(entropy: BytesLike): string;
+    /**
+     *
+     * @param phrase - Mnemonic phrase composed by words from the provided wordlist
+     * @param wordlist - Provide a wordlist with the list of words used to generate the mnemonic phrase. The default value is the English list.
+     * @returns Mnemonic phrase
+     */
+    static mnemonicToEntropy(phrase: MnemonicPhrase, wordlist?: Array<string>): string;
+    /**
+     * @param entropy - Entropy source to the mnemonic phrase.
+     * @param testnet - Inform if should use testnet or mainnet prefix, default value is true (`mainnet`).
+     * @returns 64-byte array contains privateKey and chainCode as described on BIP39
+     */
+    static entropyToMnemonic(entropy: BytesLike, wordlist?: Array<string>): string;
+    /**
+     * @param phrase - Mnemonic phrase composed by words from the provided wordlist
+     * @param passphrase - Add additional security to protect the generated seed with a memorized passphrase. `Note: if the owner forgot the passphrase, all wallets and accounts derive from the phrase will be lost.`
+     * @returns 64-byte array contains privateKey and chainCode as described on BIP39
+     */
+    static mnemonicToSeed(phrase: MnemonicPhrase, passphrase?: BytesLike): string;
+    /**
+     * @param phrase - Mnemonic phrase composed by words from the provided wordlist
+     * @param passphrase - Add additional security to protect the generated seed with a memorized passphrase. `Note: if the owner forgot the passphrase, all wallets and accounts derive from the phrase will be lost.`
+     * @returns 64-byte array contains privateKey and chainCode as described on BIP39
+     */
+    static mnemonicToMasterKeys(phrase: MnemonicPhrase, passphrase?: BytesLike): Uint8Array;
+    /**
+     * Validates if given mnemonic is  valid
+     * @param phrase - Mnemonic phrase composed by words from the provided wordlist
+     * @returns true if phrase is a valid mnemonic
+     */
+    static isMnemonicValid(phrase: string): boolean;
+    static binarySearch(target: string): boolean;
+    /**
+     * @param seed - BIP39 seed
+     * @param testnet - Inform if should use testnet or mainnet prefix, the default value is true (`mainnet`).
+     * @returns 64-byte array contains privateKey and chainCode as described on BIP39
+     */
+    static masterKeysFromSeed(seed: string): Uint8Array;
+    /**
+     * Get the extendKey as defined on BIP-32 from the provided seed
+     *
+     * @param seed - BIP39 seed
+     * @param testnet - Inform if should use testnet or mainnet prefix, default value is true (`mainnet`).
+     * @returns BIP-32 extended private key
+     */
+    static seedToExtendedKey(seed: string, testnet?: boolean): string;
+    /**
+     *  Create a new mnemonic using a randomly generated number as entropy.
+     *  As defined in BIP39, the entropy must be a multiple of 32 bits, and its size must be between 128 and 256 bits.
+     *  Therefore, the possible values for `strength` are 128, 160, 192, 224, and 256.
+     *  If not provided, the default entropy length will be set to 256 bits.
+     *  The return is a list of words that encodes the generated entropy.
+     *
+     *
+     * @param size - Number of bytes used as an entropy
+     * @param extraEntropy - Optional extra entropy to increase randomness
+     * @returns A randomly generated mnemonic
+     */
+    static generate(size?: number, extraEntropy?: BytesLike): string;
+}
+
+declare const english: string[];
+
+declare enum Language {
+    'english' = "english"
+}
+
+export { AbiMap, Account, type AssembleTransactionSummaryParams, Asset, AssetEth, AssetFuel, Assets, BurnedAsset, CHAIN_IDS, type CacheFor, type CalculateTransactionFeeParams, ChangeOutputCollisionError, type DeferPromise, Fuel, type FuelConfig, FuelConnector, type FuelConnectorSelectOptions, type GetAssetNetworkParams, GetOperationParams, type GetTransactionSummaryFromRequestParams, type GetTransactionSummaryParams, type GetTransactionsSummariesParams, type GetTransactionsSummariesReturns, GetTransferOperationsParams, GqlTransactionStatusesNames, GraphqlTransactionStatus, HDWallet, type IGetMaxGasParams, type IGetMinGasParams, InputOutputParam, InputParam, Language, LocalStorage, MNEMONIC_SIZES, MemoryStorage, MintedAsset, Mnemonic, type MnemonicPhrase, MnemonicVault, type MnemonicVaultOptions, Network$1 as Network, NetworkEthereum, NetworkFuel, type NetworkTypes, NoWitnessAtIndexError, NoWitnessByOwnerError, Operation, OperationCoin, type PkVaultOptions, PrivateKeyVault, Provider, RawPayloadParam, ReceiptParam, type Status, StorageAbstract, type TargetObject, TransactionRequest, TransactionRequestInput, TransactionRequestLike, TransactionResult, TransactionResultReceipt, TransactionStatus, TransactionSummary, TransactionTypeName, Vault, type VaultConfig, type VaultsState, Wallet, WalletLocked, WalletManager, type WalletManagerAccount, type WalletManagerOptions, type WalletManagerState, WalletUnlocked, addOperation, assembleReceiptByType, assembleTransactionSummary, assets, buildBlockExplorerUrl, cacheFor, calculateMetadataGasForTxCreate, calculateMetadataGasForTxScript, calculatePriceWithFactor, calculateTransactionFee, deferPromise, dispatchFuelConnectorEvent, english, extractBurnedAssetsFromReceipts, extractMintedAssetsFromReceipts, gasUsedByInputs, getAssetEth, getAssetFuel, getAssetNetwork, getAssetWithNetwork, getContractCallOperations, getContractCreatedOperations, getDecodedLogs, getDefaultChainId, getGasUsedFromReceipts, getInputAccountAddress, getInputContractFromIndex, getInputFromAssetId, getInputsByType, getInputsByTypes, getInputsCoin, getInputsCoinAndMessage, getInputsContract, getInputsMessage, getMaxGas, getMinGas, getOperations, getOutputsByType, getOutputsChange, getOutputsCoin, getOutputsContract, getOutputsContractCreated, getOutputsVariable, getPayProducerOperations, getPredicateRoot, getReceiptsByType, getReceiptsCall, getReceiptsMessageOut, getReceiptsTransferOut, getReceiptsWithMissingData, getTransactionStatusName, getTransactionSummary, getTransactionSummaryFromRequest, getTransactionTypeName, getTransactionsSummaries, getTransferOperations, getWithdrawFromFuelOperations, hasSameAssetId, isType, isTypeCreate, isTypeMint, isTypeScript, normalizeJSON, processGqlReceipt, processGraphqlStatus, resolveGasDependentCosts, resolveIconPaths, returnZeroScript, sleep, transactionRequestify, urlJoin, withTimeout, withdrawScript };