@spirobel/monero-wallet-api 0.1.2 → 0.3.0

package/README.md

@@ -18,7 +18,19 @@ rust release build
 
 ```bash
 cd rust || cd ../rust
-cargo wasi build  --target wasm32-wasip1 --release --lib
+cargo build  --target wasm32-wasip1 --release --lib
+```
+
+prerequisite: install rust
+
+```bash
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+```
+
+```bash
+rustup install 1.89.0
+rustup default 1.89.0
+rustup target add wasm32-wasip1
 ```
 
 ## reproducible build with pinned cargo + rust + cargo wasi

package/dist/api.d.ts

@@ -1,55 +1,27 @@
-import { type ScanResult, type ErrorResponse, type GetBlocksBinMetaCallback, type GetBlocksBinRequest } from "./node-interaction/binaryEndpoints";
-import { WasmProcessor } from "./wasm-processing/wasmProcessor";
+import "./io/indexedDB";
+export type { ScanResult, ScanResultCallback, } from "./scanning-syncing/scanresult/scanResult";
+export type { CacheChangedCallback, CacheChangedCallbackParameters, } from "./scanning-syncing/scanresult/scanCache";
+export { NodeUrl } from "./node-interaction/nodeUrl";
+export { ViewPair } from "./viewpair/ViewPair";
+export { ScanCacheOpened, ManyScanCachesOpened, } from "./scanning-syncing/scanresult/scanCacheOpened";
 export * from "./node-interaction/binaryEndpoints";
 export * from "./node-interaction/jsonEndpoints";
-export type ScanResultCallback = (result: ScanResult | ErrorResponse) => void;
-/**
- * This class is useful to interact with Moneros DaemonRpc binary requests in a convenient way.
- * (similar to how you would interact with a REST api that gives you json back.)
- * The wasm part will handle the creation of the binary requests and parse the responses and then parse them
- * and return outputs that belong to the ViewPair.
- * {@link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_blocksbin}
- */
-export declare class ViewPair extends WasmProcessor {
-    static create(primary_address: string, secret_view_key: string, node_url?: string): Promise<ViewPair>;
-    /**
-     * This request helps making requests to the get_blocks.bin endpoint of the Monerod nodes.
-     * @link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_blocksbin
-     * @param params params that will be turned into epee (moner lib that does binary serialization)
-     * @param metaCallBack contains meta information about the getBlocksbin call (new sync height = start_height param + number of blocks)
-     * @returns The difference to the same method on NodeUrl is: It returns {@link ScanResult} (outputs that belong to viewpair) and not just the blocks as json.
-     */
-    getBlocksBin(params: GetBlocksBinRequest, metaCallBack?: GetBlocksBinMetaCallback): Promise<ScanResult | ErrorResponse>;
-    /**
-     * This method will use getBlocks.bin from start height to daemon height.
-     * This is CPU bound work, so it should be executed in a seperate thread (worker).
-     * The scanner.ts worker in the standard-checkout dir shows how to keep scanning after the tip is reached.
-     * It also shows how the outputs are saved (note the unqiue requirement for the stealth_adress).
-     * @param start_height the height to start syncing from.
-     * @param callback this function will get the new outputs as they are found as a parameter
-     */
-    scan(start_height: number, callback: ScanResultCallback): Promise<void>;
-    /**
-     * This method makes an integrated Address for the Address of the Viewpair it was opened with.
-     * The network (mainnet, stagenet, testnet) is the same as the one of the Viewpairaddress.
-     * @param paymentId (u64 under the hood) you can use a random number or a primary key of an sqlite db to associate payments with customer sessions.
-     * @returns Adressstring
-     */
-    makeIntegratedAddress(paymentId: number): string;
-}
-/**
- * This class is useful to interact with Moneros DaemonRpc binary requests in a convenient way.
- * (similar to how you would interact with a REST api that gives you json back.)
- * The wasm part will handle the creation of the binary requests and parse the responses and return them as json.
- * {@link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_blocksbin}
- */
-export declare class NodeUrl extends WasmProcessor {
-    static create(node_url?: string): Promise<NodeUrl>;
-    /**
-     * This request helps making requests to the get_blocks.bin endpoint of the Monerod nodes.
-     *  @link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_blocksbin
-     * @param params params that will be turned into epee (moner lib that does binary serialization)
-     * @returns after the request is made it will return epee serialized objects that are then parsed into json.
-     */
-    getBlocksBin(params: GetBlocksBinRequest): Promise<import("./api").GetBlocksBinResponse | ErrorResponse>;
-}
+export * from "./io/readDir";
+export * from "./io/atomicWrite";
+export * from "./io/sleep";
+export { writeScanSettings, readScanSettings, } from "./scanning-syncing/scanSettings";
+export { signTransaction, parseAddress, type ParsedAddress, type ParseAddressError, } from "./send-functionality/transactionBuilding";
+export { computeKeyImage } from "./scanning-syncing/scanresult/computeKeyImage";
+export { scanWallets, startWebworker, createWebworker, makeWebworkerScript, } from "./scanning-syncing/backgroundWorker";
+export { spendable } from "./scanning-syncing/scanresult/scanResult";
+export { openWallets, openWallet } from "./scanning-syncing/openWallet";
+export * from "./scanning-syncing/connectionStatus";
+export * from "./scanning-syncing/scanSettings";
+export * from "./scanning-syncing/scanresult/scanResult";
+export * from "./scanning-syncing/scanresult/scanStats";
+export * from "./scanning-syncing/scanresult/scanCache";
+export * from "./keypairs-seeds/writeKeypairs";
+export * from "./keypairs-seeds/keypairs";
+export * from "./send-functionality/conversion";
+export * from "./send-functionality/inputSelection";
+export * from "./tools/monero-tools";

package/dist/api.js

@@ -1,103 +1,25 @@
-import { getBlocksBinJson, getBlocksBinScan, } from "./node-interaction/binaryEndpoints";
-import { TinyWASI } from "./wasm-processing/wasi";
-import { WasmProcessor } from "./wasm-processing/wasmProcessor";
+import "./io/indexedDB";
+export { NodeUrl } from "./node-interaction/nodeUrl";
+export { ViewPair } from "./viewpair/ViewPair";
+export { ScanCacheOpened, ManyScanCachesOpened, } from "./scanning-syncing/scanresult/scanCacheOpened";
 export * from "./node-interaction/binaryEndpoints";
 export * from "./node-interaction/jsonEndpoints";
-/**
- * This class is useful to interact with Moneros DaemonRpc binary requests in a convenient way.
- * (similar to how you would interact with a REST api that gives you json back.)
- * The wasm part will handle the creation of the binary requests and parse the responses and then parse them
- * and return outputs that belong to the ViewPair.
- * {@link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_blocksbin}
- */
-export class ViewPair extends WasmProcessor {
-    static async create(primary_address, secret_view_key, node_url) {
-        const viewPair = new ViewPair(new TinyWASI(), node_url || "http://localhost:38081");
-        const tinywasi = await viewPair.initWasmModule();
-        viewPair.writeToWasmMemory = (ptr, len) => {
-            viewPair.writeString(ptr, len, primary_address);
-            viewPair.writeToWasmMemory = (ptr, len) => {
-                viewPair.writeString(ptr, len, secret_view_key);
-            };
-        };
-        //@ts-ignore
-        tinywasi.instance.exports.init_viewpair(primary_address.length, secret_view_key.length);
-        return viewPair;
-    }
-    /**
-     * This request helps making requests to the get_blocks.bin endpoint of the Monerod nodes.
-     * @link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_blocksbin
-     * @param params params that will be turned into epee (moner lib that does binary serialization)
-     * @param metaCallBack contains meta information about the getBlocksbin call (new sync height = start_height param + number of blocks)
-     * @returns The difference to the same method on NodeUrl is: It returns {@link ScanResult} (outputs that belong to viewpair) and not just the blocks as json.
-     */
-    getBlocksBin(params, metaCallBack) {
-        return getBlocksBinScan(this, params, metaCallBack);
-    }
-    /**
-     * This method will use getBlocks.bin from start height to daemon height.
-     * This is CPU bound work, so it should be executed in a seperate thread (worker).
-     * The scanner.ts worker in the standard-checkout dir shows how to keep scanning after the tip is reached.
-     * It also shows how the outputs are saved (note the unqiue requirement for the stealth_adress).
-     * @param start_height the height to start syncing from.
-     * @param callback this function will get the new outputs as they are found as a parameter
-     */
-    async scan(start_height, callback) {
-        let latest_meta = {
-            new_height: start_height,
-            daemon_height: start_height + 1,
-            status: "",
-        };
-        while (latest_meta.new_height < latest_meta.daemon_height) {
-            const res = await this.getBlocksBin({
-                start_height: latest_meta.new_height - 1,
-            }, (meta) => {
-                latest_meta = meta;
-            });
-            callback(res);
-        }
-    }
-    /**
-     * This method makes an integrated Address for the Address of the Viewpair it was opened with.
-     * The network (mainnet, stagenet, testnet) is the same as the one of the Viewpairaddress.
-     * @param paymentId (u64 under the hood) you can use a random number or a primary key of an sqlite db to associate payments with customer sessions.
-     * @returns Adressstring
-     */
-    makeIntegratedAddress(paymentId) {
-        let address = "";
-        this.readFromWasmMemory = (ptr, len) => {
-            address = this.readString(ptr, len);
-        };
-        //@ts-ignore
-        this.tinywasi.instance.exports.make_integrated_address(BigInt(paymentId));
-        return address;
-    }
-}
-/**
- * This class is useful to interact with Moneros DaemonRpc binary requests in a convenient way.
- * (similar to how you would interact with a REST api that gives you json back.)
- * The wasm part will handle the creation of the binary requests and parse the responses and return them as json.
- * {@link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_blocksbin}
- */
-export class NodeUrl extends WasmProcessor {
-    static async create(node_url) {
-        const nodeUrl = new NodeUrl(new TinyWASI(), node_url || "http://localhost:38081");
-        await nodeUrl.initWasmModule();
-        return nodeUrl;
-    }
-    /**
-     * This request helps making requests to the get_blocks.bin endpoint of the Monerod nodes.
-     *  @link https://docs.getmonero.org/rpc-library/monerod-rpc/#get_blocksbin
-     * @param params params that will be turned into epee (moner lib that does binary serialization)
-     * @returns after the request is made it will return epee serialized objects that are then parsed into json.
-     */
-    getBlocksBin(params) {
-        return getBlocksBinJson(this, params);
-    }
-}
-// const nodeurl = await NodeUrl.create("http://stagenet.community.rino.io:38081");
-// nodeurl.getBlocksBin({ start_height: 1731707 });
-// const viewpair = await ViewPair.create(
-//   "5B5ieVKGSyfAyh68X6AFB48Gnx9diT8jPbWN6UcZHJUZVQSLRhaaHuHQz3dGuxxZDXPYgCXzrkerK3m6Q1tHoougR7VYyd9",
-//   "10b9885324933ee6055b001a3ee4b70f6832b866db389ad023b51fe7e2e7ca01"
-// );
+export * from "./io/readDir";
+export * from "./io/atomicWrite";
+export * from "./io/sleep";
+export { writeScanSettings, readScanSettings, } from "./scanning-syncing/scanSettings";
+export { signTransaction, parseAddress, } from "./send-functionality/transactionBuilding";
+export { computeKeyImage } from "./scanning-syncing/scanresult/computeKeyImage";
+export { scanWallets, startWebworker, createWebworker, makeWebworkerScript, } from "./scanning-syncing/backgroundWorker";
+export { spendable } from "./scanning-syncing/scanresult/scanResult";
+export { openWallets, openWallet } from "./scanning-syncing/openWallet";
+export * from "./scanning-syncing/connectionStatus";
+export * from "./scanning-syncing/scanSettings";
+export * from "./scanning-syncing/scanresult/scanResult";
+export * from "./scanning-syncing/scanresult/scanStats";
+export * from "./scanning-syncing/scanresult/scanCache";
+export * from "./keypairs-seeds/writeKeypairs";
+export * from "./keypairs-seeds/keypairs";
+export * from "./send-functionality/conversion";
+export * from "./send-functionality/inputSelection";
+export * from "./tools/monero-tools";

package/dist/io/BunFileInterface.d.ts

@@ -0,0 +1,32 @@
+export interface Bun {
+    stdin: BunFile;
+    stdout: BunFile;
+    stderr: BunFile;
+    file(path: string | number | URL, options?: {
+        type?: string;
+    }): BunFile;
+    write(destination: string | number | BunFile | URL, input: string | Blob | ArrayBuffer | SharedArrayBuffer | TypedArray | Response): Promise<number>;
+}
+export interface BunFile {
+    readonly size: number;
+    readonly type: string;
+    text(): Promise<string>;
+    stream(): ReadableStream;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    json(): Promise<any>;
+    writer(params: {
+        highWaterMark?: number;
+    }): FileSink;
+    exists(): Promise<boolean>;
+}
+export interface FileSink {
+    write(chunk: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer): number | Promise<number>;
+    flush(): number | Promise<number>;
+    end(error?: Error): number | Promise<number>;
+    start(options?: {
+        highWaterMark?: number;
+    }): void;
+    ref(): void;
+    unref(): void;
+}
+export type TypedArray = Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | Uint8ClampedArray;

package/dist/io/BunFileInterface.js

@@ -0,0 +1 @@
+export {};

package/dist/io/atomicWrite.d.ts

@@ -0,0 +1,2 @@
+import type { TypedArray } from "./BunFileInterface";
+export declare function atomicWrite(targetPath: string, data: string | Blob | ArrayBuffer | SharedArrayBuffer | TypedArray | Response): Promise<number>;

package/dist/io/atomicWrite.js

@@ -0,0 +1,10 @@
+export async function atomicWrite(targetPath, data) {
+    // in the browser we don't have rename + indexedDB writes are atomic in any case
+    if (areWeInTheBrowser)
+        return await Bun.write(targetPath, data);
+    const { rename } = await import("node:fs/promises");
+    const tempPath = targetPath + ".tmp";
+    const bytesWritten = await Bun.write(tempPath, data);
+    await rename(tempPath, targetPath);
+    return bytesWritten;
+}

package/dist/io/extension.d.ts

@@ -0,0 +1,18 @@
+interface ExtensionRuntime {
+    id: string;
+    connect?: (extensionId?: string) => any;
+    sendMessage?: (message: any) => Promise<any> | ((callback: (response: any) => void) => void);
+}
+interface Chrome {
+    runtime?: ExtensionRuntime;
+}
+interface Browser {
+    runtime?: ExtensionRuntime;
+}
+declare global {
+    var chrome: Chrome | undefined;
+    var browser: Browser | undefined;
+}
+export declare function isExtensionContext(): boolean;
+export declare function getRuntime(): ExtensionRuntime | null;
+export {};

package/dist/io/extension.js

@@ -0,0 +1,11 @@
+export function isExtensionContext() {
+    return !!((typeof chrome !== "undefined" && chrome.runtime?.id) ||
+        (typeof browser !== "undefined" && browser.runtime?.id));
+}
+export function getRuntime() {
+    if (chrome?.runtime?.id)
+        return chrome.runtime;
+    if (browser?.runtime?.id)
+        return browser.runtime;
+    return null;
+}

package/dist/io/indexedDB.d.ts

@@ -0,0 +1,45 @@
+import type { BunFile, Bun, TypedArray } from "./BunFileInterface";
+export type PossibleBunFileContent = string | Blob | ArrayBuffer | SharedArrayBuffer | TypedArray | Response;
+declare class IndexedDBBun implements Bun {
+    stdin: BunFile;
+    stdout: BunFile;
+    stderr: BunFile;
+    file(path: string | number | URL, options?: {
+        type?: string;
+    }): BunFile;
+    write(destination: string | number | BunFile | URL, input: PossibleBunFileContent): Promise<number>;
+    env: BunEnv;
+}
+export type BunEnv = {
+    [key: string]: string | undefined;
+    TZ?: string | undefined;
+    NODE_ENV?: string | undefined;
+};
+export type IndexedDBItem = string | Blob | ArrayBufferLike | ArrayBuffer | SharedArrayBuffer;
+export declare function getItemLength(input: PossibleBunFileContent): Promise<[IndexedDBItem, number]>;
+export declare function putFileIntoIndexedDB(path: string, content: PossibleBunFileContent): Promise<number>;
+export declare function getFileFromIndexedDB(path: string): Promise<unknown>;
+export declare function deleteFileFromIndexedDB(path: string): Promise<void>;
+export declare const fileStoreName = "files";
+export type BrowserGlobal = {
+    filesDb?: IDBDatabase;
+    Bun: IndexedDBBun;
+    areWeInTheBrowser: boolean;
+};
+declare global {
+    var areWeInTheBrowser: boolean;
+}
+export declare function refreshEnvIndexedDB(): Promise<void>;
+export declare function writeEnvIndexedDB(key: string, value: string): Promise<void>;
+export declare function readEnvIndexedDB(): Promise<{
+    [key: string]: string;
+}>;
+/**
+ * useless function
+ * you can just do process.env[key] instead. Look at the code above.
+ * @param key
+ * @returns value
+ */
+export declare function readEnvIndexedDBLine(key: string): Promise<string>;
+export declare function readdir(dirpath: string): Promise<string[]>;
+export {};

package/dist/io/indexedDB.js

@@ -0,0 +1,221 @@
+import { writeEnvLineToDotEnvRefresh } from "../keypairs-seeds/writeKeypairs";
+class IndexedDBBun {
+    stdin = new IndexedDBFile();
+    stdout = new IndexedDBFile();
+    stderr = new IndexedDBFile();
+    file(path, options) {
+        return new IndexedDBFile(getFileFromIndexedDB(path.toString()), path.toString());
+    }
+    async write(destination, input) {
+        return await putFileIntoIndexedDB(destination.toString(), input);
+    }
+    env = {};
+}
+class IndexedDBFile {
+    content;
+    path;
+    size = 0;
+    type = "";
+    constructor(content, path) {
+        this.content = content;
+        this.path = path;
+    }
+    async text() {
+        const result = (await this.content);
+        if (!result)
+            throw new Error(`no such file or directory, open '${this.path}'`);
+        return result;
+    }
+    stream() {
+        throw new Error("not implemented");
+        return new ReadableStream();
+    }
+    async arrayBuffer() {
+        const result = (await this.content);
+        if (!result)
+            throw new Error(`no such file or directory, open '${this.path}'`);
+        return result;
+    }
+    json() {
+        throw new Error("not implemented");
+        return Promise.resolve({});
+    }
+    writer(params) {
+        throw new Error("not implemented");
+        return new BunFileSink();
+    }
+    exists() {
+        throw new Error("not implemented");
+        return Promise.resolve(false);
+    }
+    delete() {
+        return deleteFileFromIndexedDB(this.path);
+    }
+}
+class BunFileSink {
+    write(chunk) {
+        throw new Error("not implemented");
+        return 0;
+    }
+    flush() {
+        throw new Error("not implemented");
+        return 0;
+    }
+    end(error) {
+        throw new Error("not implemented");
+        return 0;
+    }
+    start(options) {
+        throw new Error("not implemented");
+    }
+    ref() {
+        throw new Error("not implemented");
+    }
+    unref() {
+        throw new Error("not implemented");
+    }
+}
+export async function getItemLength(input) {
+    if (typeof input === "string") {
+        return [input, new TextEncoder().encode(input).length];
+    }
+    if (input instanceof Blob) {
+        return [input, input.size];
+    }
+    if (ArrayBuffer.isView(input)) {
+        return [input.buffer, input.byteLength];
+    }
+    if ("arrayBuffer" in input) {
+        const bytes = await input.arrayBuffer();
+        return [bytes, bytes.byteLength];
+    }
+    // SharedArrayBuffer/ArrayBuffer fallback
+    if ("byteLength" in input) {
+        return [input, input.byteLength];
+    }
+    throw new Error(`ENOSPC: unsupported input type`);
+}
+export async function putFileIntoIndexedDB(path, content) {
+    if (!browserGlobal.filesDb) {
+        throw new Error("IndexedDB not initialized");
+    }
+    const [dbContent, byteLength] = await getItemLength(content);
+    const tx = browserGlobal.filesDb.transaction(fileStoreName, "readwrite");
+    const store = tx.objectStore(fileStoreName);
+    const request = store.put(dbContent, path);
+    return await new Promise((resolve, reject) => {
+        request.onsuccess = () => resolve(byteLength);
+        request.onerror = () => reject(request.error);
+    });
+}
+export function getFileFromIndexedDB(path) {
+    if (!browserGlobal.filesDb) {
+        throw new Error("IndexedDB not initialized");
+    }
+    else {
+        const tx = browserGlobal.filesDb.transaction(fileStoreName, "readonly");
+        const store = tx.objectStore(fileStoreName);
+        const request = store.get(path);
+        return new Promise((resolve, reject) => {
+            request.onsuccess = () => resolve(request.result);
+            request.onerror = () => reject(request.error);
+        });
+    }
+}
+export async function deleteFileFromIndexedDB(path) {
+    if (!browserGlobal.filesDb) {
+        throw new Error("IndexedDB not initialized");
+    }
+    const tx = browserGlobal.filesDb.transaction(fileStoreName, "readwrite");
+    const store = tx.objectStore(fileStoreName);
+    const request = store.delete(path.trim());
+    return new Promise((resolve, reject) => {
+        request.onsuccess = () => resolve();
+        request.onerror = () => reject(request.error);
+    });
+}
+export const fileStoreName = "files";
+async function initFilesDB() {
+    return new Promise((resolve, reject) => {
+        const request = indexedDB.open(fileStoreName);
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => resolve(request.result);
+        request.onupgradeneeded = () => request.result.createObjectStore(fileStoreName);
+    });
+}
+// In browsers: window in main thread, self in workers
+const hasWindow = typeof window !== "undefined";
+const hasSelf = typeof self !== "undefined";
+//@ts-ignore
+const browserGlobal = hasWindow ? window : hasSelf ? self : {}; // non-browser -> no shimming
+if (typeof globalThis.Bun === "undefined") {
+    browserGlobal.filesDb = await initFilesDB();
+    browserGlobal.Bun = new IndexedDBBun();
+    browserGlobal.Bun.env = await readEnvIndexedDB();
+    browserGlobal.areWeInTheBrowser = true;
+}
+else {
+    browserGlobal.areWeInTheBrowser = false;
+}
+export async function refreshEnvIndexedDB() {
+    browserGlobal.Bun.env = await readEnvIndexedDB();
+}
+// we need this to change the env at runtime from inside the Browser extension,
+// or react native app. Or to persist view keys in bun web backend.
+// this one is specifically for indexedDB (convention of treating .env as Bun.env)
+export async function writeEnvIndexedDB(key, value) {
+    // this file should be treated as ephemeral
+    // private spendkeys + viewkeys are deterministically derived from seedphrase and password
+    // we have to go through indexedDB just so the background worker has access to this.
+    // (after waking up from an alarm or onmessage event)
+    await writeEnvLineToDotEnvRefresh(key, value, ".env");
+}
+export async function readEnvIndexedDB() {
+    const file = Bun.file(".env");
+    const content = await file
+        .text()
+        .catch(() => { })
+        .then((c) => c || "");
+    const lines = content.split("\n");
+    const result = {};
+    for (const line of lines) {
+        const keyValue = line.split("=");
+        const key = keyValue[0];
+        if (!key)
+            continue;
+        const value = keyValue[1];
+        result[key.trim()] = value?.trim();
+    }
+    return result;
+}
+/**
+ * useless function
+ * you can just do process.env[key] instead. Look at the code above.
+ * @param key
+ * @returns value
+ */
+export async function readEnvIndexedDBLine(key) {
+    const file = Bun.file(".env");
+    const content = await file.text();
+    const lines = content.split("\n");
+    const idx = lines.findIndex((line) => line.startsWith(key.trim()));
+    return lines[idx].split("=")[1].trim();
+}
+export async function readdir(dirpath) {
+    if (!browserGlobal.filesDb) {
+        throw new Error("IndexedDB not initialized");
+    }
+    let prefix = dirpath.trim();
+    if (prefix && !prefix.endsWith("/")) {
+        prefix += "/";
+    }
+    const tx = browserGlobal.filesDb.transaction(fileStoreName, "readonly");
+    const store = tx.objectStore(fileStoreName);
+    const range = IDBKeyRange.bound(prefix, prefix + "\uffff", false, true);
+    const keys = await new Promise((resolve, reject) => {
+        const request = store.getAllKeys(range);
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+    });
+    return keys.map((key) => key.slice(prefix.length));
+}

package/dist/io/readDir.d.ts

@@ -0,0 +1 @@
+export declare function readDir(path: string): Promise<string[]>;

package/dist/io/readDir.js

@@ -0,0 +1,7 @@
+import { readdir as indexedDBreaddir } from "./indexedDB";
+export async function readDir(path) {
+    if (areWeInTheBrowser)
+        return await indexedDBreaddir(path);
+    const { readdir } = await import("node:fs/promises");
+    return await readdir(path);
+}

package/dist/io/sleep.d.ts

@@ -0,0 +1 @@
+export declare const sleep: (ms: number) => Promise<unknown>;

package/dist/io/sleep.js

@@ -0,0 +1 @@
+export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

package/dist/keypairs-seeds/keypairs.d.ts

@@ -0,0 +1,29 @@
+/**
+ * "So when we first decided to create a mnemonic system the spec we
+ * came up with was: take the seed from the mnemonic, hash it for the
+ * spend key, hash it twice for the view key. Somewhere during the
+ * simplewallet implementation we forgot about that, and just used the
+ * mnemonic seed as the spendkey directly.
+ *
+ * This proved to be a blessing in disguise, though, as we'd not realised
+ * that people might want to retrieve their seed. Using our original
+ * design this wouldn't have been possible, as we didn't store the seed
+ * in the wallet file.
+ *
+ * Much later on when we were creating MyMonero (a different group of
+ * developers, I'm the only common link between the two) we decided that
+ * a 13 word seed would be much easier for people to remember, but
+ * because we wanted it to match simplewallet's implementation we made
+ * sure that we followed the spec... as it was originally... before we
+ * duffed the implementation."
+ */
+export type SpendKey = string;
+export declare function makeSpendKey(): Promise<SpendKey>;
+export declare function makeSpendKeyFromSeed(wallet_secret: string): Promise<SpendKey>;
+export type ViewPairJson = {
+    view_key: string;
+    mainnet_primary: string;
+    stagenet_primary: string;
+    testnet_primary: string;
+};
+export declare function makeViewKey(spend_private_key: string): Promise<ViewPairJson>;