@attocash/cli 0.1.0

package/dist/storage/secrets.d.ts

@@ -0,0 +1,16 @@
+export interface SecretStore {
+    get(): Promise<string | null>;
+    set(mnemonic: string): Promise<void>;
+    remove?(): Promise<void>;
+}
+/** Dedicated credential namespace; neither reads nor overwrites the desktop wallet. */
+export declare class OsSecretStore implements SecretStore {
+    private readonly account;
+    private readonly service;
+    constructor(account?: string, service?: 'Atto CLI' | 'Atto MCP');
+    get(): Promise<string | null>;
+    set(mnemonic: string): Promise<void>;
+    remove(): Promise<void>;
+    private nativeEntry;
+    private secretTool;
+}

package/dist/storage/secrets.js

@@ -0,0 +1,104 @@
+import { spawn } from 'node:child_process';
+import { AttoError } from '../domain/errors.js';
+function unavailable() {
+    return new AttoError('SECRET_STORE_UNAVAILABLE', 'The operating-system password store is unavailable or locked. Unlock it and, on Linux, install secret-tool. Run doctor in the failing environment for diagnostics.');
+}
+/** Dedicated credential namespace; neither reads nor overwrites the desktop wallet. */
+export class OsSecretStore {
+    account;
+    service;
+    constructor(account = 'default', service = 'Atto MCP') {
+        this.account = account;
+        this.service = service;
+        if (!account || account.length > 200 || /[\r\n\0]/.test(account))
+            throw new AttoError('INVALID_ACCOUNT', 'Use a nonempty credential account identifier.');
+        if (service !== 'Atto CLI' && service !== 'Atto MCP')
+            throw new AttoError('INVALID_SERVICE', 'Use an Atto CLI or Atto MCP credential service.');
+    }
+    async get() {
+        if (process.platform === 'linux') {
+            const result = await this.secretTool('lookup');
+            if (result.code === 1 && !result.output && !result.error)
+                return null;
+            if (result.code !== 0 || result.error)
+                throw unavailable();
+            return result.output.replace(/\r?\n$/, '') || null;
+        }
+        try {
+            return await (await this.nativeEntry()).getPassword() ?? null;
+        }
+        catch {
+            throw unavailable();
+        }
+    }
+    async set(mnemonic) {
+        if (!mnemonic || /[\r\n\0]/.test(mnemonic))
+            throw new AttoError('INVALID_MNEMONIC', 'The recovery phrase must be a single nonempty line.');
+        if (process.platform === 'linux') {
+            const result = await this.secretTool('store', mnemonic);
+            if (result.code !== 0 || result.error)
+                throw unavailable();
+        }
+        else {
+            try {
+                await (await this.nativeEntry()).setPassword(mnemonic);
+            }
+            catch {
+                throw unavailable();
+            }
+        }
+        // Verify durability before wallet setup reports success.
+        if (await this.get() !== mnemonic)
+            throw unavailable();
+    }
+    async remove() {
+        // An interrupted reset may have removed the credential before committing
+        // its public-state cleanup. Native keyrings need not accept deleting twice.
+        if (await this.get() === null)
+            return;
+        if (process.platform === 'linux') {
+            const result = await this.secretTool('clear');
+            if (result.code !== 0 && !(result.code === 1 && !result.error))
+                throw unavailable();
+        }
+        else {
+            try {
+                await (await this.nativeEntry()).deleteCredential();
+            }
+            catch {
+                throw unavailable();
+            }
+        }
+        if (await this.get() !== null)
+            throw unavailable();
+    }
+    async nativeEntry() {
+        if (process.platform !== 'darwin' && process.platform !== 'win32')
+            throw unavailable();
+        const { AsyncEntry } = await import('@napi-rs/keyring');
+        return new AsyncEntry(this.service, this.account);
+    }
+    secretTool(operation, secret) {
+        return new Promise((resolve, reject) => {
+            const args = operation === 'store' ? ['store', `--label=${this.service}`] : [operation];
+            args.push('service', this.service, 'account', this.account, 'key_type', 'mnemonic');
+            const child = spawn('secret-tool', args, { stdio: ['pipe', 'pipe', 'pipe'], signal: AbortSignal.timeout(60_000), windowsHide: true });
+            let output = '';
+            let error = false;
+            child.stdout.setEncoding('utf8');
+            child.stdout.on('data', (chunk) => {
+                output += chunk;
+                if (output.length > 16_384) {
+                    error = true;
+                    child.kill();
+                }
+            });
+            // Do not preserve dependency diagnostics, which may contain secret values.
+            child.stderr.on('data', () => { error = true; });
+            child.on('error', () => reject(unavailable()));
+            child.stdin.on('error', () => { error = true; });
+            child.on('close', (code) => resolve({ code, output, error }));
+            child.stdin.end(secret);
+        });
+    }
+}

package/dist/storage/state.d.ts

@@ -0,0 +1,32 @@
+export declare function defaultDataDirectory(): string;
+/** Public wallet state only. Recovery material belongs exclusively in SecretStore. */
+export declare class StateStore {
+    readonly directory: string;
+    private readonly state;
+    private readonly coordination;
+    private readonly lifecycle;
+    private queue;
+    private closed;
+    private lockRequests;
+    private exclusiveReset;
+    get busy(): boolean;
+    constructor(directory: string);
+    get<T>(key: string): T | undefined;
+    set(key: string, value: unknown): void;
+    /** Only synchronous state work belongs here; network work uses withWalletLock. */
+    transaction<T>(fn: () => T): T;
+    /** Terminal-only lifecycle operation. Once the shared lease is released this
+     * store closes, even if another session prevents acquiring exclusivity. */
+    withExclusiveReset<T>(fn: () => Promise<T>): Promise<T>;
+    /** Keep database and lock file identities intact; caller owns the transaction. */
+    clearForReset(): void;
+    private requireOpen;
+    withWalletLock<T>(fn: () => Promise<T>): Promise<T>;
+    /** Never wait for account locks while holding the wallet lock. This immediate
+     * attempt is safe during short wallet selection/reservation transactions. */
+    tryAccountLocks(indexes: readonly number[]): (() => void) | undefined;
+    /** Acquire account locks first; short wallet reservations may run inside fn.
+     * Closing the connection (including process death) releases every lock. */
+    withAccountLocks<T>(indexes: readonly number[], fn: () => Promise<T>): Promise<T>;
+    close(): void;
+}

package/dist/storage/state.js

@@ -0,0 +1,255 @@
+import { chmodSync, closeSync, mkdirSync, openSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { setTimeout as delay } from 'node:timers/promises';
+import { AttoError } from '../domain/errors.js';
+export function defaultDataDirectory() {
+    if (process.platform === 'win32')
+        return join(process.env.LOCALAPPDATA || join(homedir(), 'AppData', 'Local'), 'Atto MCP');
+    if (process.platform === 'darwin')
+        return join(homedir(), 'Library', 'Application Support', 'Atto MCP');
+    return join(process.env.XDG_DATA_HOME || join(homedir(), '.local', 'share'), 'atto-mcp');
+}
+/** Public wallet state only. Recovery material belongs exclusively in SecretStore. */
+export class StateStore {
+    directory;
+    state;
+    coordination;
+    lifecycle;
+    queue = Promise.resolve();
+    closed = false;
+    lockRequests = 0;
+    exclusiveReset = false;
+    get busy() { return this.lockRequests !== 0 || this.exclusiveReset; }
+    constructor(directory) {
+        this.directory = resolve(directory);
+        mkdirSync(this.directory, { recursive: true, mode: 0o700 });
+        const connections = [];
+        const open = (name) => {
+            const path = join(this.directory, name);
+            closeSync(openSync(path, 'a', 0o600));
+            if (process.platform !== 'win32')
+                chmodSync(path, 0o600);
+            const connection = new DatabaseSync(path);
+            connections.push(connection);
+            return connection;
+        };
+        try {
+            // A lifetime read lease prevents reset while another wallet session exists.
+            // This separate database must use rollback journaling: WAL readers do not
+            // exclude writers. Acquire the lease before opening any wallet state.
+            this.lifecycle = open('lifecycle.sqlite');
+            this.lifecycle.exec('PRAGMA busy_timeout = 0; PRAGMA journal_mode = DELETE; CREATE TABLE IF NOT EXISTS lease (id INTEGER PRIMARY KEY); BEGIN; SELECT COUNT(*) FROM lease;');
+            this.state = open('state.sqlite');
+            this.state.exec('PRAGMA busy_timeout = 5000; PRAGMA journal_mode = WAL; PRAGMA synchronous = FULL;');
+            const version = this.state.prepare('PRAGMA user_version').get()?.user_version;
+            if (version !== 0 && version !== 1)
+                throw new AttoError('STATE_VERSION', 'This wallet state requires a newer Atto CLI.');
+            this.state.exec('CREATE TABLE IF NOT EXISTS settings (key TEXT PRIMARY KEY, value TEXT NOT NULL); PRAGMA user_version = 1;');
+            this.coordination = open('coordination.sqlite');
+            this.coordination.exec('PRAGMA busy_timeout = 0;');
+        }
+        catch (error) {
+            for (const connection of connections.reverse()) {
+                try {
+                    connection.close();
+                }
+                catch { /* Preserve the startup failure. */ }
+            }
+            const code = error.errcode;
+            if (code === 5 || code === 6)
+                throw new AttoError('WALLET_BUSY', 'The wallet is busy. Wait for reset or other wallet operations to finish.');
+            throw error;
+        }
+    }
+    get(key) {
+        this.requireOpen();
+        const row = this.state.prepare('SELECT value FROM settings WHERE key = ?').get(key);
+        return row ? JSON.parse(row.value) : undefined;
+    }
+    set(key, value) {
+        this.requireOpen();
+        const json = JSON.stringify(value);
+        if (json === undefined)
+            throw new AttoError('INVALID_STATE', 'Persistent state must be JSON serializable.');
+        this.state.prepare('INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value').run(key, json);
+    }
+    /** Only synchronous state work belongs here; network work uses withWalletLock. */
+    transaction(fn) {
+        this.requireOpen();
+        this.state.exec('BEGIN IMMEDIATE');
+        try {
+            const result = fn();
+            this.state.exec('COMMIT');
+            return result;
+        }
+        catch (error) {
+            this.state.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    /** Terminal-only lifecycle operation. Once the shared lease is released this
+     * store closes, even if another session prevents acquiring exclusivity. */
+    async withExclusiveReset(fn) {
+        this.requireOpen();
+        if (this.lockRequests !== 0 || this.exclusiveReset)
+            throw new AttoError('WALLET_BUSY', 'Wait for wallet operations before resetting this profile.');
+        try {
+            this.lifecycle.exec('ROLLBACK;');
+            try {
+                this.lifecycle.exec('BEGIN EXCLUSIVE;');
+            }
+            catch (error) {
+                const code = error.errcode;
+                if (code === 5 || code === 6)
+                    throw new AttoError('WALLET_BUSY', 'Stop other sessions using this wallet before resetting.');
+                throw error;
+            }
+            this.exclusiveReset = true;
+            return await fn();
+        }
+        finally {
+            this.close();
+        }
+    }
+    /** Keep database and lock file identities intact; caller owns the transaction. */
+    clearForReset() {
+        this.requireOpen();
+        if (!this.exclusiveReset)
+            throw new AttoError('LOCAL_APPROVAL_REQUIRED', 'Clearing wallet state requires an exclusive local reset.');
+        this.state.exec('DELETE FROM settings;');
+    }
+    requireOpen() {
+        if (this.closed)
+            throw new AttoError('STATE_CLOSED', 'The wallet state is closed.');
+    }
+    async withWalletLock(fn) {
+        if (this.closed)
+            throw new AttoError('STATE_CLOSED', 'The wallet state is closed.');
+        this.lockRequests++;
+        const previous = this.queue;
+        let release;
+        this.queue = new Promise((resolveQueue) => { release = resolveQueue; });
+        await previous;
+        let locked = false;
+        try {
+            // Separate coordination lets short reservations commit durably without
+            // keeping the state database transaction open during other async work.
+            for (;;) {
+                try {
+                    this.coordination.exec('BEGIN IMMEDIATE');
+                    locked = true;
+                    break;
+                }
+                catch (error) {
+                    const code = error.errcode;
+                    if (code !== 5 && code !== 6)
+                        throw error;
+                    await delay(25);
+                }
+            }
+            return await fn();
+        }
+        finally {
+            try {
+                if (locked)
+                    this.coordination.exec('ROLLBACK');
+            }
+            finally {
+                this.lockRequests--;
+                release();
+            }
+        }
+    }
+    /** Never wait for account locks while holding the wallet lock. This immediate
+     * attempt is safe during short wallet selection/reservation transactions. */
+    tryAccountLocks(indexes) {
+        if (this.closed)
+            throw new AttoError('STATE_CLOSED', 'The wallet state is closed.');
+        if (!Array.isArray(indexes) || indexes.length < 1 || indexes.length > 100
+            || indexes.some(index => !Number.isSafeInteger(index) || index < 0 || index > 0x7fff_ffff)) {
+            throw new AttoError('INVALID_INDEX', 'Account locks require between 1 and 100 valid wallet indexes.');
+        }
+        const directory = join(this.directory, 'account-locks');
+        mkdirSync(directory, { recursive: true, mode: 0o700 });
+        const connections = [];
+        const closeConnections = () => {
+            let failure;
+            for (const connection of connections.reverse()) {
+                try {
+                    connection.close();
+                }
+                catch (error) {
+                    failure ??= error;
+                }
+            }
+            connections.length = 0;
+            if (failure)
+                throw failure;
+        };
+        try {
+            // Sorted acquisition prevents cycles when payments consolidate accounts.
+            for (const index of [...new Set(indexes)].sort((left, right) => left - right)) {
+                const file = join(directory, `${index}.sqlite`);
+                closeSync(openSync(file, 'a', 0o600));
+                if (process.platform !== 'win32')
+                    chmodSync(file, 0o600);
+                const connection = new DatabaseSync(file);
+                connections.push(connection);
+                connection.exec('PRAGMA busy_timeout = 0; BEGIN IMMEDIATE;');
+            }
+        }
+        catch (error) {
+            closeConnections();
+            const code = error.errcode;
+            if (code === 5 || code === 6)
+                return undefined;
+            throw error;
+        }
+        this.lockRequests++;
+        let held = true;
+        return () => {
+            if (!held)
+                return;
+            held = false;
+            try {
+                closeConnections();
+            }
+            finally {
+                this.lockRequests--;
+            }
+        };
+    }
+    /** Acquire account locks first; short wallet reservations may run inside fn.
+     * Closing the connection (including process death) releases every lock. */
+    async withAccountLocks(indexes, fn) {
+        if (this.closed)
+            throw new AttoError('STATE_CLOSED', 'The wallet state is closed.');
+        this.lockRequests++;
+        let release;
+        try {
+            while (!(release = this.tryAccountLocks(indexes)))
+                await delay(25);
+            return await fn();
+        }
+        finally {
+            try {
+                release?.();
+            }
+            finally {
+                this.lockRequests--;
+            }
+        }
+    }
+    close() {
+        if (this.closed)
+            return;
+        if (this.lockRequests !== 0)
+            throw new AttoError('WALLET_BUSY', 'Wait for wallet operations before closing state.');
+        this.coordination.close();
+        this.state.close();
+        this.lifecycle.close();
+        this.closed = true;
+    }
+}

package/dist/wallet/auto-receive.d.ts

@@ -0,0 +1,57 @@
+import type { AddressLabels } from '../labels/presentation.js';
+import { errorResult } from '../domain/errors.js';
+import { amountOutput } from '../domain/amount.js';
+import type { WalletAddress, WalletSettings } from './types.js';
+interface PendingPayment {
+    index: number;
+    address: string;
+    sendHash: string;
+    amount: ReturnType<typeof amountOutput>;
+}
+export type ReceiveProgress = ((PendingPayment & {
+    event: 'pending' | 'receiving';
+}) | (PendingPayment & {
+    event: 'received';
+    receiveHash?: string;
+}) | (PendingPayment & {
+    event: 'retry';
+    error: ReturnType<typeof errorResult>;
+    retryInMs: number;
+}) | (PendingPayment & {
+    event: 'skipped';
+    error: ReturnType<typeof errorResult>;
+}) | {
+    event: 'reconnecting';
+    error: ReturnType<typeof errorResult>;
+    retryInMs: number;
+}) & {
+    addressLabels?: ReturnType<AddressLabels['dictionary']>;
+    globalDirectory?: ReturnType<AddressLabels['status']>;
+};
+/** Session-owned supervision; every receive goes through the shared mutation gate. */
+export declare class AutoReceiver {
+    private readonly snapshot;
+    private readonly receive;
+    private readonly onProgress?;
+    private controller?;
+    private loop?;
+    private lastError;
+    private active;
+    constructor(snapshot: () => {
+        settings: WalletSettings;
+        addresses: WalletAddress[];
+    }, receive: (index: number, hash: string) => Promise<unknown>, onProgress?: ((event: ReceiveProgress) => void) | undefined);
+    status(): {
+        running: boolean;
+        lastError: {
+            code: string;
+            message: string;
+            details?: unknown;
+        } | null;
+    };
+    private report;
+    start(): void;
+    private run;
+    close(): Promise<void>;
+}
+export {};

package/dist/wallet/auto-receive.js

@@ -0,0 +1,140 @@
+import { NodeReader } from '../network/reader.js';
+import { AttoError, errorResult } from '../domain/errors.js';
+import { amountOutput } from '../domain/amount.js';
+/** Session-owned supervision; every receive goes through the shared mutation gate. */
+export class AutoReceiver {
+    snapshot;
+    receive;
+    onProgress;
+    controller;
+    loop;
+    lastError = null;
+    active = false;
+    constructor(snapshot, receive, onProgress) {
+        this.snapshot = snapshot;
+        this.receive = receive;
+        this.onProgress = onProgress;
+    }
+    status() { return { running: this.active, lastError: this.lastError }; }
+    report(event) {
+        // Output failures must never turn a completed payment into another attempt.
+        try {
+            this.onProgress?.(event);
+        }
+        catch { /* Receiving is independent of its observer. */ }
+    }
+    start() {
+        if (this.loop)
+            return;
+        this.controller = new AbortController();
+        this.loop = this.run(this.controller.signal).finally(() => { this.active = false; });
+    }
+    async run(signal) {
+        let configuration = '';
+        let subscription;
+        let stream;
+        const pending = new Map();
+        let retryAt = 0;
+        let delayMs = 1000;
+        let connected = false;
+        try {
+            while (!signal.aborted) {
+                const { settings, addresses } = this.snapshot();
+                const active = addresses.filter(address => address.active);
+                const next = JSON.stringify({ settings, active });
+                if (configuration !== next) {
+                    subscription?.abort();
+                    await stream;
+                    pending.clear();
+                    configuration = next;
+                    retryAt = 0;
+                    delayMs = 1000;
+                    connected = false;
+                }
+                this.active = settings.autoReceive && active.length > 0;
+                if (this.active && !connected && Date.now() >= retryAt) {
+                    subscription = new AbortController();
+                    const child = subscription;
+                    connected = true;
+                    let streamError;
+                    const byAddress = new Map(active.map(address => [address.publicKey.toUpperCase(), address.index]));
+                    stream = new NodeReader(settings).stream({ event: 'receivable', addresses: active.map(address => address.address), minAmountRaw: settings.minReceiveRaw }, model => {
+                        const receivable = model;
+                        const index = byAddress.get(receivable.receiverPublicKey.toString().toUpperCase());
+                        if (index === undefined)
+                            return;
+                        const hash = receivable.hash.toString();
+                        // A bounded queue; reconnecting replays outstanding receivables.
+                        if (pending.size >= 1000 && !pending.has(hash)) {
+                            child.abort();
+                            return;
+                        }
+                        if (!pending.has(hash)) {
+                            const payment = { index, address: receivable.receiverAddress.value, sendHash: hash, amount: amountOutput(receivable.amount.toString()) };
+                            pending.set(hash, { payment, retryAt: 0 });
+                            this.report({ event: 'pending', ...payment });
+                        }
+                        delayMs = 1000;
+                    }, child.signal).catch(error => {
+                        if (!child.signal.aborted && !signal.aborted)
+                            this.lastError = streamError = errorResult(error);
+                    }).finally(() => {
+                        connected = false;
+                        retryAt = Date.now() + delayMs;
+                        if (!child.signal.aborted && !signal.aborted)
+                            this.report({
+                                event: 'reconnecting',
+                                error: streamError ?? errorResult(new AttoError('NODE_UNAVAILABLE', 'The node stream ended.')),
+                                retryInMs: delayMs,
+                            });
+                        delayMs = Math.min(delayMs * 2, 30_000);
+                    });
+                }
+                for (const [hash, item] of pending) {
+                    if (signal.aborted)
+                        break;
+                    if (Date.now() < item.retryAt)
+                        continue;
+                    this.report({ event: 'receiving', ...item.payment });
+                    try {
+                        const result = await this.receive(item.payment.index, hash);
+                        pending.delete(hash);
+                        this.lastError = null;
+                        const receiveHash = result && typeof result === 'object' && 'hash' in result && typeof result.hash === 'string' ? result.hash : undefined;
+                        this.report({ event: 'received', ...item.payment, ...(receiveHash ? { receiveHash } : {}) });
+                    }
+                    catch (error) {
+                        if (error instanceof AttoError && ['RECEIVABLE_NOT_PENDING', 'ADDRESS_INACTIVE', 'AUTO_RECEIVE_DISABLED', 'RECEIVABLE_BELOW_MINIMUM'].includes(error.code)) {
+                            pending.delete(hash);
+                            if (!signal.aborted)
+                                this.report({ event: 'skipped', ...item.payment, error: errorResult(error) });
+                        }
+                        else {
+                            item.retryAt = Date.now() + 10_000;
+                            this.lastError = errorResult(error);
+                            if (!signal.aborted)
+                                this.report({ event: 'retry', ...item.payment, error: this.lastError, retryInMs: 10_000 });
+                        }
+                    }
+                    // Return to the settings/cancellation check between mutations.
+                    break;
+                }
+                if (!signal.aborted)
+                    await new Promise(resolve => {
+                        const finish = () => { clearTimeout(timer); signal.removeEventListener('abort', finish); resolve(); };
+                        const timer = setTimeout(finish, 250);
+                        signal.addEventListener('abort', finish, { once: true });
+                    });
+            }
+        }
+        finally {
+            subscription?.abort();
+            await stream;
+        }
+    }
+    async close() {
+        this.controller?.abort();
+        await this.loop;
+        this.loop = undefined;
+    }
+}

package/dist/wallet/defaults.d.ts

@@ -0,0 +1,3 @@
+import type { WalletSettings } from './types.js';
+export declare const representativePublicKeys: string[];
+export declare function defaultSettings(): WalletSettings;

package/dist/wallet/defaults.js

@@ -0,0 +1,26 @@
+import { AttoAddress, AttoAlgorithm, AttoPublicKey } from '@attocash/commons-core';
+// Same LIVE representative pool as the desktop wallet. Choose once per installation.
+export const representativePublicKeys = [
+    'd50d27281df93e71e6e7a279fc308d5e90891c27a1129cd0bf24bf94731f547f',
+    'ebc906cc473fce6a5bc1e58622d6d807cb4bc820ac13169d88f96ee26d29b982',
+    'e7877ac47b475989f3c24783e2d5c0ffc4943d1d0c48c02ba152305b0d42ff5b',
+    'e00ba25f78dcd0f229a9335060256cef12609d161daf2fd614dc32c37ccdc56a',
+    'a73f0b55a50d3bb89eead7b47005fd488cc2f540f342f893b72dd357200b4432',
+    '5df80120502f2eac7cbf1af12555b5a82990a66745ff89573d6093f535ac25e8',
+    '6c9a4b64bbb6ed51a305d1185d83288a62378dbE761e932e38c05c17623d74b1',
+    '1d7948c4d449ac8151d7855f44276308e98c899c6f066eb9324dffaa15901929',
+    '853380ff0f905b3801f3a32fa193250395b4bd0ca6d83e76eea7389ec9d4ba10',
+    '58d293037fdfe6318ac97215e3e8a202cb27637a17831cbfb1964a4534343c48',
+    '45eb652403ca618c5f1cff92b2bb1f4c7d86b903e880721937f07ea9e0e5648f',
+    '096523285e1fe5755daabb94ecab124d0e395e1d2e613e97d10aa2717b82a4ce',
+];
+export function defaultSettings() {
+    return {
+        network: 'LIVE',
+        nodeUrl: 'https://gatekeeper.live.application.atto.cash',
+        workerUrl: 'https://gatekeeper.live.application.atto.cash',
+        representative: new AttoAddress(AttoAlgorithm.V1, AttoPublicKey.Companion.parse(representativePublicKeys[Math.floor(Math.random() * representativePublicKeys.length)])).value,
+        autoReceive: true,
+        minReceiveRaw: '1',
+    };
+}

package/dist/wallet/signing.d.ts

@@ -0,0 +1,17 @@
+import { AttoSeed, AttoBlock, AttoSigner, AttoAccount, AttoAddress, AttoAmount, AttoInstant, AttoKeyIndex, AttoReceivable, AttoTransaction } from '@attocash/commons-core';
+import { type SendRetry } from '../network/retry.js';
+import type { WalletSettings } from './types.js';
+import type { BlockWorker } from './work.js';
+export declare function mnemonicSeed(phrase: string): Promise<AttoSeed>;
+export declare function derivedSigner(seed: AttoSeed, index: number): Promise<AttoSigner>;
+export declare function signingWallet(seed: AttoSeed, index: number, settings: WalletSettings, beforeSign: (block: AttoBlock) => void | Promise<void>, suppliedWorker?: BlockWorker, retry?: SendRetry): Promise<{
+    wallet: {
+        sendByIndex(value: AttoKeyIndex, destination: AttoAddress, amount: AttoAmount, timestamp?: AttoInstant | null): Promise<AttoTransaction>;
+        receive(receivable: AttoReceivable, representative?: AttoAddress | null, timestamp?: AttoInstant | null): Promise<AttoTransaction>;
+        change(value: AttoKeyIndex, representative: AttoAddress, timestamp?: AttoInstant | null): Promise<AttoTransaction>;
+        getAccountByIndex(value: AttoKeyIndex): Promise<AttoAccount | null>;
+        close(): void;
+    };
+    client: import("@attocash/commons-node").AttoNodeClientAsync;
+    address: AttoAddress;
+}>;