@asichain/asi-wallet-sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,504 @@
+import { BIP32Interface } from 'bip32';
+import { AxiosRequestConfig, AxiosInstance } from 'axios';
+
+declare class FeeService {
+    static generateRandomGasFee: () => string;
+    static getGasFeeAsNumber: () => number;
+    static formatGasFee: (fee?: string) => string;
+}
+
+declare const enum KeyUsage {
+    ENCRYPT = "encrypt",
+    DECRYPT = "decrypt",
+    DERIVATION = "deriveKey"
+}
+interface CryptoConfig {
+    readonly VERSION: number;
+    readonly IV_LENGTH: number;
+    readonly SALT_LENGTH: number;
+    readonly KEY_SIZE_BITS: number;
+    readonly KEY_IMPORT_FORMAT: "raw" | "pkcs8" | "spki";
+    readonly KEY_DERIVATION_ITERATIONS: number;
+    readonly KEY_DERIVATION_FUNCTION: string;
+    readonly KEY_IMPORT_USAGE: KeyUsage[];
+    readonly HASH_FUNCTION: string;
+    readonly ALGORITHM: string;
+}
+interface 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 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);
+    getId(): string;
+    getName(): string;
+    getDecimals(): number;
+}
+
+type AddressBrand = {
+    readonly __brand: unique symbol;
+};
+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 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;
+}
+
+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 createWalletFromMnemonic(mnemonic?: string, index?: number): Promise<WalletMeta>;
+    static deriveAddressFromPrivateKey(privateKey: Uint8Array): Address;
+    static deriveAddressFromPublicKey(publicKey: Uint8Array): Address;
+}
+
+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;
+}
+
+interface Bip44PathOptions {
+    coinType: number;
+    account?: number;
+    change?: number;
+    index?: number;
+}
+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 KeyPair {
+    privateKey: Uint8Array;
+    publicKey: Uint8Array;
+}
+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 SigningRequest {
+    wallet: Wallet;
+    data: any;
+}
+interface SignedResult {
+    data: any;
+    deployer: string;
+    signature: string;
+    sigAlgorithm: string;
+}
+type PasswordProvider = () => Promise<string>;
+
+declare enum DeployStatus {
+    DEPLOYING = "Deploying",
+    INCLUDED_IN_BLOCK = "IncludedInBlock",
+    FINALIZED = "Finalized",
+    CHECK_ERROR = "CheckingError"
+}
+type DeployStatusResult = {
+    status: Exclude<DeployStatus, DeployStatus.CHECK_ERROR>;
+} | {
+    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>;
+    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>;
+    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 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 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;
+    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>;
+}
+
+declare class SignerService {
+    static sign(request: SigningRequest, passwordProvider: PasswordProvider): Promise<SignedResult>;
+    private static readonly deployDataProtobufSerialize;
+}
+
+declare class AssetsService {
+    transfer(fromAddress: Address, toAddress: Address, amount: bigint, wallet: Wallet, passwordProvider: PasswordProvider, phloLimit?: number): Promise<string | undefined>;
+    getASIBalance(address: Address): Promise<bigint>;
+}
+
+declare class BinaryWriterService {
+    private buffer;
+    writeString(fieldNumber: number, value: string): void;
+    writeInt64(fieldNumber: number, value: number): void;
+    private writeInteger;
+    private writeInteger64;
+    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;
+}
+
+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;
+}
+
+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 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;
+    clear(): void;
+    private getIds;
+    private createKey;
+}
+
+interface WalletClientConfig {
+    mode: string;
+}
+declare enum WalletClientModes {
+    LOCAL = "local",
+    MPC = "mpc"
+}
+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 PRIVATE_KEY_LENGTH = 32;
+declare const ASI_CHAIN_PREFIX: {
+    coinId: string;
+    version: string;
+};
+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 POWER_BASE: number;
+declare const ASI_BASE_UNIT: bigint;
+declare const FAULT_TOLERANCE_THRESHOLD: number;
+declare const INVALID_BLOCK_NUMBER = -1;
+declare const DEFAULT_BIP_44_PATH_OPTIONS: {
+    coinType: number;
+    account: number;
+    change: number;
+    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 validateAccountName: (name: string, maxLength?: number) => {
+    isValid: boolean;
+    error?: string;
+};
+declare enum AddressValidationErrorCode {
+    INVALID_PREFIX = "INVALID_PREFIX",
+    INVALID_LENGTH = "INVALID_LENGTH",
+    INVALID_ALPHABET = "INVALID_ALPHABET",
+    INVALID_BASE58 = "INVALID_BASE58",
+    INVALID_HEX_LENGTH = "INVALID_HEX_LENGTH",
+    INVALID_CHAIN_PREFIX = "INVALID_CHAIN_PREFIX",
+    INVALID_CHECKSUM = "INVALID_CHECKSUM",
+    NON_CANONICAL = "NON_CANONICAL"
+}
+interface AddressValidationResult {
+    isValid: boolean;
+    errorCode?: AddressValidationErrorCode;
+}
+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, 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, 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, decodeBase16, decodeBase58, deploymentErrorMessages, encodeBase16, encodeBase58, fromAtomicAmount, fromAtomicAmountToNumber, fromAtomicAmountToString, genRandomHex, getDeploymentErrorMessage, isAddress, setupBufferPolyfill, toAtomicAmount, validateAccountName, validateAddress };
+export type { Address, AddressValidationResult, AssetId, Assets, Bip44PathOptions, BlockchainGatewayConfig, CreateWalletOptions, CryptoConfig, DeployStatusResult, DeploymentErrorType, EncryptedData, HttpClient, KeyPair, PasswordProvider, ResubmitConfig, ResubmitResult, Seeds, SignedResult, SigningCapability, SigningRequest, StoredSeedsMetaRecords, StoredWalletMeta, StoredWalletsMetaRecords, StringifiedWalletMeta, VaultRawData, WalletClientConfig, WalletMemory, WalletMeta, Wallets };

package/dist/index.esm.js

@@ -0,0 +1 @@
+import e from"bs58";import*as t from"bip39";import{mnemonicToSeed as r}from"bip39";import{Buffer as n}from"buffer";import*as a from"tiny-secp256k1";import{BIP32Factory as s}from"bip32";import{getPublicKey as i,utils as o,sign as c}from"@noble/secp256k1";import l from"blakejs";import d from"js-sha3";import u from"axios";const h=32,y={coinId:"000000",version:"00"},p=60,g=8,m={BASE_FEE:.0025,VARIATION_RANGE:.1,LABEL:"ASI",TRANSFER:"0.0025",DEPLOY:"0.0025"},f=10,w=BigInt(10)**BigInt(8),E=.99,I=-1,N={coinType:60,account:0,change:0,index:0};var A;class v{}A=v,v.generateRandomGasFee=()=>{const e=2*(Math.random()-.5)*m.VARIATION_RANGE;return(m.BASE_FEE*(1+e)).toFixed(4)},v.getGasFeeAsNumber=()=>m.BASE_FEE,v.formatGasFee=e=>`${e||A.generateRandomGasFee()} ${m.LABEL}`;const R=t=>{const r=S(t);return e.encode(r)},b=t=>e.decode(t),S=e=>{const t=new Uint8Array(e.length/2);for(let r=0;r<e.length;r+=2)t[r/2]=parseInt(e.substr(r,2),16);return t},D=e=>Array.from(e,e=>e.toString(16).padStart(2,"0")).join(""),L=e=>{const t=new Uint8Array(e);let r="";for(let e=0;e<t.byteLength;e++)r+=String.fromCharCode(t[e]);return btoa(r)},_=e=>{const t=atob(e),r=new Uint8Array(t.length);for(let e=0;e<t.length;e++)r[e]=t.charCodeAt(e);return r.buffer},O=2,C=12,T=16,P=256,k="AES-GCM",U="SHA-256",K="raw",V="PBKDF2",B=1e5;class M{static async encryptWithPassword(e,t){const r=crypto.getRandomValues(new Uint8Array(T)),n=crypto.getRandomValues(new Uint8Array(C)),a=await this.deriveKey(t,r),s=await crypto.subtle.encrypt({name:k,iv:n},a,(new TextEncoder).encode(e));return{data:L(s),salt:L(r.buffer),iv:L(n.buffer),version:O}}static async decryptWithPassword(e,t){if(e.version!==O)throw new Error(`Unsupported version ${e.version}`);const r=new Uint8Array(_(e.salt)),n=new Uint8Array(_(e.iv)),a=await this.deriveKey(t,r),s=await crypto.subtle.decrypt({name:k,iv:n},a,_(e.data));return(new TextDecoder).decode(s)}static async deriveKey(e,t){const r=await crypto.subtle.importKey(K,(new TextEncoder).encode(e),V,!1,["deriveKey"]);return crypto.subtle.deriveKey({name:V,salt:new Uint8Array(t),iterations:B,hash:U},r,{name:k,length:P},!1,["encrypt","decrypt"])}}const x=()=>{"undefined"==typeof window||window.Buffer||(window.Buffer=n)};var W;x(),function(e){e[e.TWELVE_WORDS=128]="TWELVE_WORDS",e[e.TWENTY_FOUR_WORDS=256]="TWENTY_FOUR_WORDS"}(W||(W={}));class F{static generateMnemonic(e=W.TWELVE_WORDS){return t.generateMnemonic(e)}static generateMnemonicArray(e=W.TWELVE_WORDS){return this.mnemonicToWordArray(this.generateMnemonic(e))}static isMnemonicValid(e){return t.validateMnemonic(e)}static mnemonicToWordArray(e){return e.trim().split(" ")}static wordArrayToMnemonic(e){return e.join(" ")}}x();class ${static buildBip44Path({coinType:e=60,account:t=0,change:r=0,index:n=0}){return`m/44'/${e}'/${t}'/${r}/${n}`}static derivePrivateKey(e,t){const r=e.derivePath(t);if(!r.privateKey)throw new Error("No private key at derived node");return new Uint8Array(r.privateKey)}static async mnemonicToSeed(e,t=""){return"string"==typeof e?await r(e,t):await r(F.wordArrayToMnemonic(e),t)}static seedToMasterNode(e){return s(a).fromSeed(e)}static async deriveKeyFromMnemonic(e,t=N){const r=this.buildBip44Path(t),n=await $.mnemonicToSeed(e),a=$.seedToMasterNode(n);return $.derivePrivateKey(a,r)}static async deriveNextKeyFromMnemonic(e,t,r=N){const n=t+1;return await this.deriveKeyFromMnemonic(e,{...r,index:n})}}const{randomBytes:G,bytesToHex:H}=o;class z{static generateRandomKey(e=32){if(!e||e<0||!Number.isInteger(e))throw new Error("PrivateKeyLength must be a positive integer");return G(e)}static generateKeyPair(e=32){if(!e||e<0||!Number.isInteger(e))throw new Error("PrivateKeyLength must be a positive integer");const t=G(e);return{privateKey:t,publicKey:i(t)}}static getKeyPairFromPrivateKey(e){return{privateKey:e,publicKey:i(e)}}static getPublicKeyFromPrivateKey(e){return i(e)}static convertKeyToHex(e){return H(e)}static async deriveKeyFromMnemonic(e,t){return await $.deriveKeyFromMnemonic(e,t)}static generateMpcKeyPair(){throw new Error("MPC key generation is not implemented yet.")}}const{blake2bHex:Y}=l,{keccak256:j}=d;class J{static createWallet(e,t){let r;r=e?z.getKeyPairFromPrivateKey(e):z.generateKeyPair();return{address:this.deriveAddressFromPublicKey(r.publicKey),publicKey:r.publicKey,privateKey:r.privateKey}}static async createWalletFromMnemonic(e,t){const r=e?F.mnemonicToWordArray(e):F.generateMnemonicArray(),n=F.wordArrayToMnemonic(r);if(!n||!F.isMnemonicValid(n))throw new Error("WalletsService.createWalletFromMnemonic: Recovery mnemonic is missing or invalid");const a=await $.mnemonicToSeed(r),s=$.seedToMasterNode(a),i=$.buildBip44Path({coinType:60,account:0,change:0,index:t||0}),o=$.derivePrivateKey(s,i);return{...this.createWallet(o),mnemonic:n}}static deriveAddressFromPrivateKey(e){const t=z.getKeyPairFromPrivateKey(e);return this.deriveAddressFromPublicKey(t.publicKey)}static deriveAddressFromPublicKey(e){const t=j(e.slice(1)),r=S(t.slice(-40)),n=j(r),a=`${y.coinId}${y.version}${n}`,s=S(a),i=Y(s,void 0,32).slice(0,8);return R(`${a}${i}`)}}function X(e,t,r,n,a,s){function i(e){if(void 0!==e&&"function"!=typeof e)throw new TypeError("Function expected");return e}for(var o,c=n.kind,l="getter"===c?"get":"setter"===c?"set":"value",d=!t&&e?n.static?e:e.prototype:null,u=t||(d?Object.getOwnPropertyDescriptor(d,n.name):{}),h=!1,y=r.length-1;y>=0;y--){var p={};for(var g in n)p[g]="access"===g?{}:n[g];for(var g in n.access)p.access[g]=n.access[g];p.addInitializer=function(e){if(h)throw new TypeError("Cannot add initializers after decoration has completed");s.push(i(e||null))};var m=(0,r[y])("accessor"===c?{get:u.get,set:u.set}:u[l],p);if("accessor"===c){if(void 0===m)continue;if(null===m||"object"!=typeof m)throw new TypeError("Object expected");(o=i(m.get))&&(u.get=o),(o=i(m.set))&&(u.set=o),(o=i(m.init))&&a.unshift(o)}else(o=i(m))&&("field"===c?a.unshift(o):u[l]=o)}d&&Object.defineProperty(d,n.name,u),h=!0}var Z,q;"function"==typeof SuppressedError&&SuppressedError,function(e){e.READ_ONLY_NODE="READ_ONLY_NODE",e.CASPER_INSTANCE_UNAVAILABLE="CASPER_INSTANCE_UNAVAILABLE",e.INVALID_DEPLOY_ID="INVALID_DEPLOY_ID",e.INVALID_BLOCK_NUMBER="INVALID_BLOCK_NUMBER"}(Z||(Z={})),function(e){e.INSUFFICIENT_BALANCE="INSUFFICIENT_BALANCE",e.WRONG_NETWORK="WRONG_NETWORK",e.PARSING_ERROR="PARSING_ERROR",e.LOW_PHLO_PRICE="LOW_PHLO_PRICE",e.SIGNATURE_ERROR="SIGNATURE_ERROR",e.STORAGE_RETRIEVAL_ERROR="STORAGE_RETRIEVAL_ERROR",e.UNKNOWN_ERROR="UNKNOWN_ERROR",e.DEPLOY_SUBMIT_TIMEOUT="DEPLOY_SUBMIT_TIMEOUT",e.BLOCK_INCLUSION_TIMEOUT="BLOCK_INCLUSION_TIMEOUT",e.FINALIZATION_TIMEOUT="FINALIZATION_TIMEOUT"}(q||(q={}));const Q={[Z.READ_ONLY_NODE]:"Node is read-only. Trying another node...",[Z.CASPER_INSTANCE_UNAVAILABLE]:"Casper instance not available. Trying another node...",[Z.INVALID_DEPLOY_ID]:"Invalid deploy ID. Please try again.",[Z.INVALID_BLOCK_NUMBER]:"Invalid block number. Please try again.",[q.INSUFFICIENT_BALANCE]:"Insufficient balance. Please top up your account.",[q.WRONG_NETWORK]:"Wrong network. Please contact technical support.",[q.PARSING_ERROR]:"Parsing error. Please contact technical support.",[q.LOW_PHLO_PRICE]:"Phlo price too low. Please rebuild the transaction with a higher phlo price.",[q.SIGNATURE_ERROR]:"Signature verification failed. Please try again.",[q.STORAGE_RETRIEVAL_ERROR]:"Storage retrieval error. Please try again later.",[q.UNKNOWN_ERROR]:"An unknown error occurred. Please try again.",[q.DEPLOY_SUBMIT_TIMEOUT]:"Deploy submission timed out. Please try again.",[q.BLOCK_INCLUSION_TIMEOUT]:"Deploy was not included in a block within the expected time.",[q.FINALIZATION_TIMEOUT]:"Block finalization polling timed out."};function ee(e){return Q[e]??"An unknown error occurred. Please try again."}function te(e,t){return function(...t){return"string"==typeof t[0]&&(t[0]=t[0].toLowerCase()),e.apply(this,t)}}let re=(()=>{var e;let t,r,n=[];return e=class{parseDeploymentError(e){return e.includes("read only")?Z.READ_ONLY_NODE:e.includes("casper instance")?Z.CASPER_INSTANCE_UNAVAILABLE:e.includes("invalid deploy ID")?Z.INVALID_DEPLOY_ID:e.includes("invalid block number")?Z.INVALID_BLOCK_NUMBER:e.includes("insufficient balance")?q.INSUFFICIENT_BALANCE:e.includes("wrong network")?q.WRONG_NETWORK:e.includes("parsing error")?q.PARSING_ERROR:e.includes("low")&&e.includes("phlo")?q.LOW_PHLO_PRICE:e.includes("signature")||e.includes("sign")||e.includes("invalid signature")?q.SIGNATURE_ERROR:e.includes("storage")||e.includes("retrieval")?q.STORAGE_RETRIEVAL_ERROR:q.UNKNOWN_ERROR}isDeploymentErrorRecoverable(e){return Object.values(Z).includes(e)}isDeploymentErrorFatal(e){return Object.values(q).includes(e)}isPollingErrorRecoverable(e){return e.includes("casper instance")||e.includes("storage")||e.includes("parsing")}getErrorMessageByErrorType(e){return Q[e]??Q[q.UNKNOWN_ERROR]}constructor(){!function(e,t,r){for(var n=arguments.length>2,a=0;a<t.length;a++)r=n?t[a].call(e,r):t[a].call(e)}(this,n)}},(()=>{const a="function"==typeof Symbol&&Symbol.metadata?Object.create(null):void 0;t=[te],r=[te],X(e,null,t,{kind:"method",name:"parseDeploymentError",static:!1,private:!1,access:{has:e=>"parseDeploymentError"in e,get:e=>e.parseDeploymentError},metadata:a},null,n),X(e,null,r,{kind:"method",name:"isPollingErrorRecoverable",static:!1,private:!1,access:{has:e=>"isPollingErrorRecoverable"in e,get:e=>e.isPollingErrorRecoverable},metadata:a},null,n),a&&Object.defineProperty(e,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:a})})(),e})();class ne{constructor(e){this.client=e}async get(e){return(await this.client.get(e)).data}async post(e,t){return(await this.client.post(e,t)).data}getBaseUrl(){return this.client.defaults.baseURL}}var ae,se;!function(e){e.DEPLOYING="Deploying",e.INCLUDED_IN_BLOCK="IncludedInBlock",e.FINALIZED="Finalized",e.CHECK_ERROR="CheckingError"}(ae||(ae={}));class ie{constructor(e,t){this.validatorClient=e,this.indexerClient=t}static createHttpClient(e){const t=u.create({baseURL:e.baseUrl,...e.axiosConfig});return new ne(t)}changeValidator(e){return this.validatorClient=ie.createHttpClient(e),this}changeIndexer(e){return this.indexerClient=ie.createHttpClient(e),this}static init(e){return ie.instance=new ie(this.createHttpClient(e.validator),this.createHttpClient(e.indexer)),ie.instance}static isInitialized(){return void 0!==ie?.instance}static getInstance(){if(!ie.isInitialized())throw new Error("BlockchainGateway is not initialized. Call BlockchainGateway.init() first.");return ie.instance}getValidatorClientUrl(){return this.validatorClient.getBaseUrl()??""}async submitDeploy(e){try{const t=await this.validatorClient.post("/api/deploy",e,{headers:{"Content-Type":"application/json"}});if(console.log("BlockchainGateway.submitDeploy: Deploy result:",t),"string"==typeof t){const e=/DeployId is:\s*([a-fA-F0-9]+)/.exec(t);return e?e[1]:t}return t.signature||t.deployId||t}catch(e){const t="BlockchainGateway.submitDeploy: "+this.getGatewayErrorMessage(e);throw new Error(t)}}async submitExploratoryDeploy(e){try{return await this.indexerClient.post("/api/explore-deploy",e)}catch(e){const t="BlockchainGateway.submitExploratoryDeploy: "+this.getGatewayErrorMessage(e);throw new Error(t)}}async exploreDeployData(e){try{return(await this.submitExploratoryDeploy(e)).expr}catch(e){const t="BlockchainGateway.exploreDeployData: "+this.getGatewayErrorMessage(e);throw console.error(t),new Error(t)}}async getDeploy(e){return await this.indexerClient.get(`/api/deploy/${e}`)}async isDeployFinalized(e){return e.faultTolerance>=.99}async getDeployStatus(e){try{let t;if(t=await this.getDeploy(e),!t?.blockHash)return{status:ae.DEPLOYING};return{status:await this.isDeployFinalized(t)?ae.FINALIZED:ae.INCLUDED_IN_BLOCK}}catch(e){const t="BlockchainGateway.getDeployStatus: "+this.getGatewayErrorMessage(e);return{status:ae.CHECK_ERROR,errorMessage:t}}}async getBlock(e){const t=await this.indexerClient.get(`/api/block/${e}`);return t?.blockInfo}async getLatestBlockNumber(){try{const e=await this.getLatestBlock();return e?.blockNumber??-1}catch(e){const t="BlockchainGateway.getLatestBlockNumber: "+this.getGatewayErrorMessage(e);return console.error(t),-1}}async isValidatorActive(){try{return await this.validatorClient.get("/status"),!0}catch(e){return console.error("BlockchainGateway.isValidatorActive: Node health check failed:",e),!1}}getGatewayErrorMessage(e){if(u.isAxiosError(e)){const t=e.response?.status??e.code,r=e.response?.statusText??"";return`Axios error while requesting "${e.config?.url??""}": [${t}] ${r} - ${e.message}`}return e instanceof Error?e.message:String(e)}validateBlocksResponse(e){if(!e?.length){throw new Error("BlockchainGateway.validateBlocksResponse: No blocks returned from /api/blocks endpoint")}}async getLatestBlock(){const e=await this.indexerClient.get("/api/blocks/1");return this.validateBlocksResponse(e),e[0]}}!function(e){e.LOCAL="local",e.MPC="mpc"}(se||(se={}));const oe={mode:se.LOCAL},ce=3e4,le=20,de=8,ue=5e5,he={phloPrice:1,useRandomNode:!0,deployValiditySeconds:80,nodeSelectionAttempts:3,deployRetries:3,deployIntervalSeconds:5,pollingIntervalSeconds:3};class ye{constructor(e,t,r){if(this.inactiveNodesUrls=new Set,this.currentNodeUrl="",!e?.length)throw new Error("At least one node URL must be provided");this.availableNodesUrls=e,this.useRandomNode=r,this.retriesLeft=t}static initialize(e,t=he.nodeSelectionAttempts,r=he.useRandomNode){const n=r?Math.max(1,t):0,a=new ye(e,n,r);return ye.instance=a,a}async connectDefaultNode(){if(this.useRandomNode)throw new Error("NodeManager.connectDefaultNode: Random node selection is enabled, cannot connect to default node");await this.connectNode(this.availableNodesUrls[0])}async connectNode(e){ie.getInstance().getValidatorClientUrl()!==e&&ie.getInstance().changeValidator({baseUrl:e});if(!await ie.getInstance().isValidatorActive()){this.deactivateNode(e);const t=`NodeManager.connectNode: Node ${e} is not active`;throw console.error(t),new Error(t)}this.currentNodeUrl=e}static getInstance(){if(!ye.instance)throw new Error("NodeManager is not initialized. Call NodeManager.initialize() first.");return ye.instance}isInitialized(){return!!this.currentNodeUrl}markNodeInactive(e){this.inactiveNodesUrls.add(e)}deactivateCurrentNode(){this.isInitialized()&&this.deactivateNode(this.currentNodeUrl)}deactivateNode(e){this.retriesLeft--,this.markNodeInactive(e),this.currentNodeUrl===e&&(this.currentNodeUrl="")}getAvailableNodesUrls(){return this.availableNodesUrls.filter(e=>!this.inactiveNodesUrls.has(e))}getRetriesLeft(){return this.retriesLeft}getRandomAvailableNodeUrl(){const e=this.getAvailableNodesUrls();if(!e?.length)throw console.error("NodeManager.getRandomAvailableNodeUrl: No available node URLs to select"),new Error("NodeManager: no available node URLs");return e[Math.floor(Math.random()*e.length)]}async connectActiveRandomNode(){if(!this.useRandomNode)throw new Error("NodeManager.connectActiveRandomNode: Random node selection is disabled, connect to default node");for(;this.retriesLeft>0;){const e=this.getRandomAvailableNodeUrl();if(console.log(`NodeManager.connectActiveRandomNode: Attempting to connect to node ${e}. Retries left: ${this.retriesLeft}`),e){try{await this.connectNode(e)}catch(e){continue}return}}throw new Error("NodeManager.connectActiveRandomNode: No active node URL found after all attempts")}}const pe=127;class ge{constructor(){this.buffer=[]}writeString(e,t){if(!t)return;const r=e<<3|2;this.writeInteger(r);const n=(new TextEncoder).encode(t);this.writeInteger(n.length),this.buffer.push(...Array.from(n))}writeInt64(e,t){if(!t)return;const r=e<<3;this.writeInteger(r),this.writeInteger64(t)}writeInteger(e){for(;e>pe;)this.buffer.push(e&pe|128),e>>>=7;this.buffer.push(e)}writeInteger64(e){for(;e>pe;)this.buffer.push(e&pe|128),e=Math.floor(e/128);this.buffer.push(e)}getResultBuffer(){return new Uint8Array(this.buffer)}}const{blake2bHex:me}=l;class fe{static async sign(e,t){const{wallet:r,data:n}=e;try{const e=await t();return await r.withSigningCapability(e,async e=>{const t=this.deployDataProtobufSerialize(n),r=me(t,void 0,32),a=Uint8Array.from(Buffer.from(r,"hex")),s=await e.signDigest(a),i=e.getPublicKey();return{data:{term:n.term,timestamp:n.timestamp,phloPrice:n.phloPrice,phloLimit:n.phloLimit,validAfterBlockNumber:n.validAfterBlockNumber,shardId:n.shardId},deployer:D(i),signature:D(s),sigAlgorithm:"secp256k1"}})}catch(e){const t=`SignerService.sign: ${e.message}`;throw new Error(t)}}}fe.deployDataProtobufSerialize=e=>{const{term:t,timestamp:r,phloPrice:n,phloLimit:a,validAfterBlockNumber:s,shardId:i=""}=e,o=new ge;return o.writeString(2,t),o.writeInt64(3,r),o.writeInt64(7,n),o.writeInt64(8,a),o.writeInt64(10,s),o.writeString(11,i),o.getResultBuffer()};const we=/[,\s]+/g,Ee=/^\d+(?:\.\d+)?$/,Ie=/(\.\d*?[1-9])0+$/,Ne=/\.0+$/,Ae=e=>{const t=w.toString().length-1;if("number"==typeof e){if(!Number.isFinite(e))throw new Error("Invalid number");e=String(e)}let r=String(e).trim();if(!r.length)throw new Error("Cannot process empty amount");let n=!1;if(r.startsWith("-")&&(n=!0,r=r.slice(1)),r=r.replace(we,""),!Ee.test(r))throw new Error("Invalid amount format");const[a,s=""]=r.split("."),i=a||"0";let o=s;o.length>t&&(console.warn(`Fraction ${o} has more than allowed decimals; truncating`),o=o.slice(0,t)),o=o.padEnd(t,"0");const c=BigInt(i)*w+BigInt(o||"0");return n?-c:c},ve=e=>{const t=e/w,r=e%w,n=w.toString().length-1,a=r.toString().padStart(n,"0");return`${t.toString()}.${a}`.replace(Ie,"$1").replace(Ne,"")},Re=e=>{const t=e/w,r=e%w;return t>BigInt(Number.MAX_SAFE_INTEGER)?(console.warn("Integer part exceeds Number.MAX_SAFE_INTEGER; returning imprecise Number"),Number(ve(e))):Number(t)+Number(r)/Number(w)},be=ve,Se=e=>[...Array(e)].map(()=>Math.floor(16*Math.random()).toString(16)).join(""),{blake2bHex:De}=l,Le=/[<>:"/\\|?*]/,_e=(e,t=30)=>e&&0!==e.trim().length?e.length>t?{isValid:!1,error:`Account name must be ${t} characters or less`}:Le.test(e)?{isValid:!1,error:"Account name contains invalid characters"}:{isValid:!0}:{isValid:!1,error:"Account name is required"},Oe=/^[a-zA-Z0-9]+$/,Ce=/^[1-9A-HJ-NP-Za-km-z]+$/,Te=`${y.coinId}${y.version}`;var Pe;!function(e){e.INVALID_PREFIX="INVALID_PREFIX",e.INVALID_LENGTH="INVALID_LENGTH",e.INVALID_ALPHABET="INVALID_ALPHABET",e.INVALID_BASE58="INVALID_BASE58",e.INVALID_HEX_LENGTH="INVALID_HEX_LENGTH",e.INVALID_CHAIN_PREFIX="INVALID_CHAIN_PREFIX",e.INVALID_CHECKSUM="INVALID_CHECKSUM",e.NON_CANONICAL="NON_CANONICAL"}(Pe||(Pe={}));const ke=e=>({isValid:!1,errorCode:e}),Ue=e=>{if(!e.startsWith("1111"))return ke(Pe.INVALID_PREFIX);if(e.length<50||e.length>54)return ke(Pe.INVALID_LENGTH);if(!Oe.test(e))return ke(Pe.INVALID_ALPHABET);if(!Ce.test(e))return ke(Pe.INVALID_BASE58);const t=D(b(e));if(80!==t.length)return ke(Pe.INVALID_HEX_LENGTH);if(R(t)!==e)return ke(Pe.NON_CANONICAL);const r=t.slice(0,72),n=t.slice(72);if(!r.startsWith(Te))return ke(Pe.INVALID_CHAIN_PREFIX);const a=De(S(r),void 0,32).slice(0,8);return 8!==n.length||n!==a?ke(Pe.INVALID_CHECKSUM):{isValid:!0}},Ke=e=>Ue(e).isValid;class Ve{constructor(e,t){if(this.startSubmissionTime=0,this.config=e,this.nodeManager=ye.initialize(t,e.nodeSelectionAttempts,e.useRandomNode),this.errorHandler=new re,!ie.isInitialized())throw new Error("BlockchainGateway is not initialized")}isDeployExpired(){return Date.now()-this.startSubmissionTime>=1e3*this.config.deployValiditySeconds}sleep(e){return new Promise(t=>setTimeout(t,1e3*e))}async retryDeployToOneNode(e,t,r,n){let a=this.config.deployRetries,s={success:!1};for(;a>0&&!this.isDeployExpired();){try{const a=ie.getInstance(),i=await a.getLatestBlockNumber();if(-1===i)throw new Error("DeployResubmitter.retryDeployToOneNode: Invalid block number");const o={term:e,phloLimit:n||ue,phloPrice:1,validAfterBlockNumber:i-1,timestamp:Date.now(),shardId:"root"},c=await fe.sign({wallet:t,data:o},r),l=await a.submitDeploy(c);if("string"!=typeof l){throw new Error("Invalid deploy ID received: "+l)}return s={success:!0,deployId:l},s}catch(e){const t="DeployResubmitter.retryDeployToOneNode:"+e.message,r=this.errorHandler.parseDeploymentError(t);if(console.error(t),s.error={blockchainError:{type:r,message:t}},this.errorHandler.isDeploymentErrorFatal(r))break;a--}await this.sleep(this.config.deployIntervalSeconds)}return this.isDeployExpired()&&(s.error=s?.error||{},s.error.exceededTimeout=q.DEPLOY_SUBMIT_TIMEOUT),{success:!1,error:s.error}}async retryDeployToRandomNodes(e,t,r,n){let a={success:!1};for(;!this.isDeployExpired()&&this.nodeManager.getRetriesLeft()>0&&(await this.nodeManager.connectActiveRandomNode(),a=await this.retryDeployToOneNode(e,t,r,n),!a.success)&&(this.nodeManager.deactivateCurrentNode(),a.error?.blockchainError?.type)&&!this.errorHandler.isDeploymentErrorFatal(a.error?.blockchainError?.type););return a}async pollDeployStatus(e){let t;for(;!this.isDeployExpired();){const r=await ie.getInstance().getDeployStatus(e),n=r.status;if(n===ae.CHECK_ERROR){const e=`DeployResubmitter.pollDeployStatus: ${"errorMessage"in r?r.errorMessage:"Unknown error"}`,n=this.errorHandler.parseDeploymentError(e);console.error(e);const a={type:n,message:e};if(this.errorHandler.isDeploymentErrorFatal(n)&&!e.includes("Bad Request"))return{success:!1,deployStatus:ae.CHECK_ERROR,error:{blockchainError:a}};t=a}if(console.log("DeployResubmitter.pollDeployStatus: current deploy status:",n),n==ae.INCLUDED_IN_BLOCK||n==ae.FINALIZED)return{success:!0,deployStatus:r.status};await this.sleep(this.config.pollingIntervalSeconds)}return{success:!1,deployStatus:t?ae.CHECK_ERROR:ae.DEPLOYING,error:{...t,exceededTimeout:q.BLOCK_INCLUSION_TIMEOUT}}}async resubmit(e,t,r,n){let a;if(console.log("DeployResubmitter: starting deploy submission with resubmission logic"),this.startSubmissionTime=Date.now(),this.config.useRandomNode?a=await this.retryDeployToRandomNodes(e,t,r,n):(await this.nodeManager.connectDefaultNode(),a=await this.retryDeployToOneNode(e,t,r,n)),!a.success||!a?.deployId)return a;console.log(`DeployResubmitter: deploy submitted successfully with ID: ${a.deployId}. Starting to poll for status...`);const s=await this.pollDeployStatus(a.deployId);return console.log(`DeployResubmitter: finished polling deploy status. Final status: ${s.deployStatus}, success: ${s.success}`),s}}const Be=e=>e.replace(/\\/g,"\\\\").replace(/"/g,'\\"').replace(/\n/g,"\\n").replace(/\r/g,"\\r").replace(/\t/g,"\\t");class Me{async transfer(e,t,r,n,a,s=5e5){try{const i=Ue(e);if(!i.isValid)throw new Error(`AssetsService.transfer: Invalid 'fromAddress': ${i.errorCode??"UNKNOWN"}`);const o=Ue(t);if(!o.isValid)throw new Error(`AssetsService.transfer: Invalid 'toAddress': ${o.errorCode??"UNKNOWN"}`);if(r<=0n)throw new Error("AssetsService.transfer: Transfer amount must be greater than zero");const c=ie.getInstance(),l=((e,t,r)=>{if(r<=0n)throw new Error("Transfer amount must be greater than zero");const n=Be(e),a=Be(t),s=r.toString();return`\n        new \n            deployerId(\`rho:rchain:deployerId\`),\n            stdout(\`rho:io:stdout\`),\n            rl(\`rho:registry:lookup\`),\n            ASIVaultCh,\n            vaultCh,\n            toVaultCh,\n            asiVaultkeyCh,\n            resultCh\n        in {\n            rl!(\`rho:rchain:asiVault\`, *ASIVaultCh) |\n            for (@(_, ASIVault) <- ASIVaultCh) {\n            @ASIVault!("findOrCreate", "${n}", *vaultCh) |\n            @ASIVault!("findOrCreate", "${a}", *toVaultCh) |\n            @ASIVault!("deployerAuthKey", *deployerId, *asiVaultkeyCh) |\n            for (@(true, vault) <- vaultCh; key <- asiVaultkeyCh; @(true, toVault) <- toVaultCh) {\n                @vault!("transfer", "${a}", ${s}, *key, *resultCh) |\n                for (@result <- resultCh) {\n                match result {\n                    (true, Nil) => {\n                    stdout!(("Transfer successful:", ${s}, "ASI"))\n                    }\n                    (false, reason) => {\n                    stdout!(("Transfer failed:", reason))\n                    }\n                }\n                }\n            } |\n            for (@(false, errorMsg) <- vaultCh) {\n                stdout!(("Sender vault error:", errorMsg))\n            } |\n            for (@(false, errorMsg) <- toVaultCh) {\n                stdout!(("Destination vault error:", errorMsg))\n            }\n            }\n        }\n    `})(e,t,r),d=await c.getLatestBlockNumber();if(-1===d)throw new Error("AssetsService.transfer: Invalid block number");const u={term:l,phloLimit:s,phloPrice:1,validAfterBlockNumber:d-1,timestamp:Date.now(),shardId:"root"},h=await fe.sign({wallet:n,data:u},a);return await c.submitDeploy(h)}catch(e){const t="AssetsService.transfer: "+e.message;throw new Error(t)}}async getASIBalance(e){const t=Ue(e);if(!t.isValid)throw new Error(`AssetsService.getASIBalance: Invalid address: ${t.errorCode??"UNKNOWN"}`);const r=ie.getInstance(),n=(e=>`\n    new return, rl(\`rho:registry:lookup\`), ASIVaultCh, vaultCh in {\n        rl!(\`rho:rchain:asiVault\`, *ASIVaultCh) |\n        for (@(_, ASIVault) <- ASIVaultCh) {\n            @ASIVault!("findOrCreate", "${Be(e)}", *vaultCh) |\n            for (@maybeVault <- vaultCh) {\n                match maybeVault {\n                (true, vault) => @vault!("balance", *return)\n                (false, err)  => return!(err)\n                }\n            }\n        }\n    }\n`)(e);try{const e=await r.exploreDeployData(n);if(e&&e.length>0){const t=e[0];if(t?.ExprInt?.data)return BigInt(t.ExprInt.data);if(t?.ExprString?.data)throw new Error("Balance check error:")}return BigInt(0)}catch(e){return BigInt(0)}}}class xe{constructor(e,t,r=8){this.id=e,this.name=t,this.decimals=r}getId(){return this.id}getName(){return this.name}getDecimals(){return this.decimals}}class We{static async createAndEncrypt(e,t){const r=await M.encryptWithPassword(e,t);return new We(r)}static createFromEncryptedData(e){return new We(e)}static createFromStringifiedEncryptedData(e){return new We(JSON.parse(e))}constructor(e){this.encryptedSeedData=e}async decrypt(e){return await M.decryptWithPassword(this.encryptedSeedData,e)}toString(){return JSON.stringify(this.encryptedSeedData)}}var Fe;!function(e){e.PRIVATE_KEY="private_key",e.CRYPTO_SALT="crypto_salt",e.CRYPTO_IV="crypto_iv",e.CRYPTO_VERSION="crypto version"}(Fe||(Fe={}));class $e{constructor(e,t,r,n,a){this.name=e,this.index=a,this.masterNodeId=n,this.address=t,this.privateKey=r,this.assets=new Map,this.isLocked=!0}static async fromPrivateKey(e,t,r,n=null,a=null){const s=J.deriveAddressFromPrivateKey(t),i=await this.encryptPrivateKey(t,r);return new $e(e,s,i,n,a)}static fromEncryptedData(e,t,r,n,a){const s=Ue(t);if(!s.isValid)throw new Error(`Invalid address format: ${s.errorCode??"UNKNOWN"}`);return new $e(e,t,r,n,a)}async decrypt(e){if(!$e.unsafeRawKeyExportEnabled)throw new Error("Wallet.decrypt is disabled by default for security. Use withSigningCapability() instead.");return await this.decryptPrivateKey(e)}static enableUnsafeRawKeyExportForLegacyInterop(){$e.unsafeRawKeyExportEnabled=!0}static disableUnsafeRawKeyExport(){$e.unsafeRawKeyExportEnabled=!1}static isUnsafeRawKeyExportEnabled(){return $e.unsafeRawKeyExportEnabled}async decryptPrivateKey(e){try{const t=await M.decryptWithPassword(this.privateKey,e),r=JSON.parse(t);if(r&&"object"==typeof r&&!Array.isArray(r)){const e=Object.keys(r).sort((e,t)=>Number(e)-Number(t)).map(e=>{const t=r[e],n="string"==typeof t?Number(t):t;return"number"!=typeof n||isNaN(n)?0:n});return new Uint8Array(e)}return new Uint8Array(r)}catch(e){throw new Error("Unlock Failed: "+e?.message)}}async withSigningCapability(e,t){const r=await this.decryptPrivateKey(e);let n=!1;const a={signDigest:async e=>{if(n)throw new Error("Signing capability has expired");return await c(e,r)},getPublicKey:()=>{if(n)throw new Error("Signing capability has expired");return z.getPublicKeyFromPrivateKey(r)}};try{return await t(a)}finally{n=!0,r.fill(0)}}getEncryptedPrivateKey(){return this.privateKey}registerAsset(e){this.assets.set(e.getId(),e)}getAddress(){return this.address}getName(){return this.name}getIndex(){return this.index}getAssets(){return this.assets}isWalletLocked(){return this.isLocked}toString(){const e={name:this.name,address:this.address,encryptedPrivateKey:JSON.stringify(this.privateKey),masterNodeId:this.masterNodeId??"",index:this.index?.toString()??""};return JSON.stringify(e)}static async encryptPrivateKey(e,t){return await M.encryptWithPassword(JSON.stringify(e),t)}}$e.unsafeRawKeyExportEnabled=!1;const Ge="0";class He{constructor(e){if("undefined"==typeof window)throw new Error("getVault can only be called in a browser environment");if(this.isLocked=!1,this.wallets=new Map,this.seeds=new Map,this.encryptedVaultData=null,!e)return;const t=JSON.parse(e);this.encryptedVaultData=t,this.isLocked=!0}static getSavedVaultKeys(){this.ensureBrowserEnvironment();const e=[];for(let t=0;t<localStorage.length;t++){const r=localStorage.key(t);r&&r.startsWith(this.vaultPrefix)&&e.push(r)}return e}static getVaultDataFromStorage(e){return this.ensureBrowserEnvironment(),localStorage.getItem(e)}isVaultLocked(){return this.isLocked}save(e="0"){if(He.ensureBrowserEnvironment(),!this.isLocked)throw new Error("Cannot save an unlocked vault");const t=`${He.vaultPrefix}_${e}`;localStorage.setItem(t,JSON.stringify(this.encryptedVaultData))}async lock(e){this.ensureUnlocked();const t=this.toString();this.encryptedVaultData=await M.encryptWithPassword(t,e),this.wallets=new Map,this.seeds=new Map,this.isLocked=!0}async unlock(e){if(!this.isLocked)return;if(!this.encryptedVaultData)throw new Error("Vault was unlocked on undefined encryptedVaultData");const t=await M.decryptWithPassword(this.encryptedVaultData,e),{wallets:r,seeds:n}=JSON.parse(t);this.metaToWallets(r),this.metaToSeeds(n),this.isLocked=!1}isEmpty(){return this.ensureUnlocked(),0===this.wallets.size}getWallets(){return Array.from(this.wallets.values())}getWalletsCount(){return this.ensureUnlocked(),this.wallets.size}getWalletAddresses(){return this.ensureUnlocked(),Array.from(this.wallets.keys())}addWallet(e){this.ensureUnlocked(),this.wallets.set(e.getAddress(),e)}removeWallet(e){this.ensureUnlocked(),this.wallets.delete(e)}getWallet(e){return this.ensureUnlocked(),this.wallets.get(e)}hasWallet(e){return this.ensureUnlocked(),this.wallets.has(e)}hasSeed(e){return this.ensureUnlocked(),this.seeds.has(e)}metaToWallets(e){const t=new Map;Object.keys(e).forEach(r=>{const n=JSON.parse(e[r]),a=$e.fromEncryptedData(n.name,n.address,JSON.parse(n.encryptedPrivateKey),n.masterNodeId,n.index?+n.index:null);t.set(r,a)}),this.wallets=t}metaToSeeds(e){const t=new Map;Object.keys(e).forEach(r=>{const n=We.createFromStringifiedEncryptedData(e[r]);t.set(r,n)}),this.seeds=t}getSeeds(){return this.ensureUnlocked(),Array.from(this.seeds.values())}getSeed(e){return this.ensureUnlocked(),this.seeds.get(e)}addSeed(e,t){this.ensureUnlocked(),this.seeds.set(e,t)}removeSeed(e){this.ensureUnlocked(),this.seeds.delete(e)}getSeedsIds(){return this.ensureUnlocked(),Array.from(this.seeds.keys())}toString(){const e={},t={};this.ensureUnlocked();const r=this.getWalletAddresses(),n=this.getSeedsIds();return r.forEach(e=>{const r=this.getWallet(e);r&&(t[e]=r.toString())}),n.forEach(t=>{const r=this.getSeed(t);r&&(e[t]=r.toString())}),JSON.stringify({wallets:t,seeds:e})}ensureUnlocked(){if(this.isLocked)throw new Error("Attempted to access locked vault")}static ensureBrowserEnvironment(){if("undefined"==typeof window)throw new Error("getVault can only be called in a browser environment")}}He.vaultPrefix="ASI_WALLETS_VAULT";class ze{constructor(e="storage_prefix"){if("undefined"==typeof localStorage)throw new Error("localStorage is not supported in this environment.");this.prefix=e}write(e,t){localStorage.setItem(this.createKey(e),t)}read(e){return localStorage.getItem(this.createKey(e))}delete(e){localStorage.removeItem(this.createKey(e))}has(e){return!!localStorage.getItem(this.createKey(e))}isEmpty(){return!this.getIds().length}clear(){this.getIds().forEach(e=>localStorage.removeItem(e))}getIds(){const e=[];for(let t=0;t<localStorage.length;t++){const r=localStorage.key(t);if(!r)break;r.startsWith(`${this.prefix}`)&&e.push(r)}return e}createKey(e){return`${this.prefix}_${e}`}}export{w as ASI_BASE_UNIT,y as ASI_CHAIN_PREFIX,p as ASI_COIN_TYPE,g as ASI_DECIMALS,Pe as AddressValidationErrorCode,xe as Asset,Me as AssetsService,ne as AxiosHttpClient,ge as BinaryWriter,ie as BlockchainGateway,M as CryptoService,ce as DEFAULT_AXIOS_TIMEOUT_MS,N as DEFAULT_BIP_44_PATH_OPTIONS,oe as DEFAULT_CLIENT_CONFIG,de as DEFAULT_DECIMALS_AMOUNT,ue as DEFAULT_PHLO_LIMIT,he as DEFAULT_RESUBMIT_CONFIG,Ge as DEFAULT_STORAGE_KEY,Ve as DeployResubmitter,ae as DeployStatus,re as DeploymentErrorHandler,We as EncryptedRecord,E as FAULT_TOLERANCE_THRESHOLD,q as FatalDeployErrors,v as FeeService,m as GasFee,I as INVALID_BLOCK_NUMBER,$ as KeyDerivationService,z as KeysManager,le as MAX_WALLETS_PER_ACCOUNT,F as MnemonicService,W as MnemonicStrength,f as POWER_BASE,h as PRIVATE_KEY_LENGTH,Z as RecoverableDeployErrors,ye as ResubmitNodeManager,ze as SecureStorage,fe as SignerService,He as Vault,$e as Wallet,se as WalletClientModes,Fe as WalletMemoryKeys,J as WalletsService,L as arrayBufferToBase64,_ as base64ToArrayBuffer,S as decodeBase16,b as decodeBase58,Q as deploymentErrorMessages,D as encodeBase16,R as encodeBase58,be as fromAtomicAmount,Re as fromAtomicAmountToNumber,ve as fromAtomicAmountToString,Se as genRandomHex,ee as getDeploymentErrorMessage,Ke as isAddress,x as setupBufferPolyfill,Ae as toAtomicAmount,_e as validateAccountName,Ue as validateAddress};

package/dist/services/AssetsService/index.d.ts

@@ -0,0 +1,6 @@
+import Wallet, { Address } from "@domains/Wallet";
+import { PasswordProvider } from "@domains/Signer";
+export default class AssetsService {
+    transfer(fromAddress: Address, toAddress: Address, amount: bigint, wallet: Wallet, passwordProvider: PasswordProvider, phloLimit?: number): Promise<string | undefined>;
+    getASIBalance(address: Address): Promise<bigint>;
+}

package/dist/services/BinaryWriter/index.d.ts

@@ -0,0 +1,8 @@
+export default class BinaryWriterService {
+    private buffer;
+    writeString(fieldNumber: number, value: string): void;
+    writeInt64(fieldNumber: number, value: number): void;
+    private writeInteger;
+    private writeInteger64;
+    getResultBuffer(): Uint8Array;
+}

package/dist/services/Crypto/index.d.ts

@@ -0,0 +1,29 @@
+declare const enum KeyUsage {
+    ENCRYPT = "encrypt",
+    DECRYPT = "decrypt",
+    DERIVATION = "deriveKey"
+}
+export interface CryptoConfig {
+    readonly VERSION: number;
+    readonly IV_LENGTH: number;
+    readonly SALT_LENGTH: number;
+    readonly KEY_SIZE_BITS: number;
+    readonly KEY_IMPORT_FORMAT: "raw" | "pkcs8" | "spki";
+    readonly KEY_DERIVATION_ITERATIONS: number;
+    readonly KEY_DERIVATION_FUNCTION: string;
+    readonly KEY_IMPORT_USAGE: KeyUsage[];
+    readonly HASH_FUNCTION: string;
+    readonly ALGORITHM: string;
+}
+export interface EncryptedData {
+    data: string;
+    salt: string;
+    iv: string;
+    version: number;
+}
+export default class CryptoService {
+    static encryptWithPassword(data: string, password: string): Promise<EncryptedData>;
+    static decryptWithPassword(payload: EncryptedData, passphrase: string): Promise<string>;
+    static deriveKey(password: string, salt: Uint8Array): Promise<CryptoKey>;
+}
+export {};

package/dist/services/Fee/index.d.ts

@@ -0,0 +1,5 @@
+export default class FeeService {
+    static generateRandomGasFee: () => string;
+    static getGasFeeAsNumber: () => number;
+    static formatGasFee: (fee?: string) => string;
+}

package/dist/services/KeyDerivation/index.d.ts

@@ -0,0 +1,15 @@
+import { type BIP32Interface } from "bip32";
+export interface Bip44PathOptions {
+    coinType: number;
+    account?: number;
+    change?: number;
+    index?: number;
+}
+export default 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>;
+}

package/dist/services/KeysManager/index.d.ts

@@ -0,0 +1,14 @@
+import { Bip44PathOptions } from "@services/KeyDerivation";
+export interface KeyPair {
+    privateKey: Uint8Array;
+    publicKey: Uint8Array;
+}
+export default 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;
+}