@attocash/n8n-nodes-atto 0.2.2 → 0.3.1

package/dist/nodes/Atto/operations.js

@@ -1,225 +1,200 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deriveAccountFromSecret = void 0;
-exports.deriveAddressFromSecret = deriveAddressFromSecret;
-exports.createNodeClient = createNodeClient;
-exports.createWorkerClient = createWorkerClient;
-exports.clearWorkerClientCache = clearWorkerClientCache;
 exports.executeAttoOperation = executeAttoOperation;
-exports.createAttoTriggerSubscription = createAttoTriggerSubscription;
-const node_crypto_1 = require("node:crypto");
-const commons_core_1 = require("@attocash/commons-core");
-const commons_node_1 = require("@attocash/commons-node");
-const commons_node_remote_1 = require("@attocash/commons-node-remote");
-const commons_wallet_1 = require("@attocash/commons-wallet");
-const commons_worker_remote_1 = require("@attocash/commons-worker-remote");
+exports.pollAttoEvent = pollAttoEvent;
+const n8n_workflow_1 = require("n8n-workflow");
+const protocol_1 = require("./protocol");
 const DEFAULT_STREAM_TIMEOUT_MS = 5000;
 const DEFAULT_PUBLISH_TIMEOUT_MS = 60000;
-const MAX_WORKER_CLIENT_CACHE_SIZE = 32;
-const workerClientCache = new Map();
-function normalizeCredentials(credentials) {
-    return (credentials ?? {});
+const POLL_MAX_ITEMS = 100;
+const POLL_TIMEOUT_MS = 2000;
+const MAX_SEEN_POLL_ITEMS = 500;
+function credentials(value) {
+    return (value ?? {});
 }
 function text(value) {
     return typeof value === 'string' ? value.trim() : '';
 }
 function optionalText(value) {
-    const normalized = text(value);
-    return normalized ? normalized : undefined;
+    const valueText = text(value);
+    return valueText || undefined;
 }
-function positiveInteger(value, fieldName) {
+function nonNegativeInteger(value, fieldName) {
     const numberValue = typeof value === 'number' ? value : Number(value);
-    if (!Number.isInteger(numberValue) || numberValue < 0) {
+    if (!Number.isSafeInteger(numberValue) || numberValue < 0)
         throw new Error(`${fieldName} must be a non-negative integer`);
-    }
     return numberValue;
 }
-function positiveTimeout(value, fieldName) {
-    const timeoutMs = positiveInteger(value, fieldName);
-    if (timeoutMs < 1)
+function positiveInteger(value, fieldName) {
+    const numberValue = nonNegativeInteger(value, fieldName);
+    if (numberValue < 1)
         throw new Error(`${fieldName} must be greater than zero`);
-    return timeoutMs;
+    return numberValue;
 }
-function parseSecretType(value, fieldName) {
-    if (value === 'mnemonic' || value === 'privateKey')
-        return value;
-    throw new Error(`${fieldName} must be either mnemonic or privateKey`);
-}
-function secretInput(parameters, credentials) {
-    const source = text(parameters.secretSource || 'credentials');
-    if (source === 'node') {
-        const walletSecret = text(parameters.walletSecret);
-        if (!walletSecret)
-            throw new Error('Wallet Secret is required');
-        return {
-            secretType: parseSecretType(parameters.walletSecretType ?? 'mnemonic', 'Wallet Secret Type'),
-            walletSecret,
-            keyIndex: positiveInteger(parameters.keyIndex ?? 0, 'Key Index'),
-        };
-    }
-    const walletSecret = text(credentials.walletSecret);
-    if (!walletSecret)
-        throw new Error('Atto credentials must include a Wallet Secret');
-    return {
-        secretType: parseSecretType(credentials.walletMaterialType ?? 'mnemonic', 'Credential Wallet Secret Type'),
-        walletSecret,
-        keyIndex: positiveInteger(credentials.keyIndex ?? 0, 'Credential Key Index'),
-    };
+function positiveHeight(value, fieldName) {
+    const valueText = optionalText(value);
+    if (!valueText)
+        return undefined;
+    if (!/^\d+$/.test(valueText) || BigInt(valueText) < 1n)
+        throw new Error(`${fieldName} must be a positive integer`);
+    return valueText;
 }
-async function deriveAddressFromSecret(parameters, credentials) {
-    const input = secretInput(parameters, normalizeCredentials(credentials));
-    const index = (0, commons_core_1.toAttoIndex)(input.keyIndex);
-    if (input.secretType === 'mnemonic') {
-        const mnemonic = commons_core_1.AttoMnemonic.fromPhrase(input.walletSecret);
-        const seed = await (0, commons_core_1.toSeedAsync)(mnemonic);
-        const privateKey = (0, commons_core_1.toPrivateKey)(seed, index);
-        const publicKey = (0, commons_core_1.toPublicKey)(privateKey);
-        const address = new commons_core_1.AttoAddress(commons_core_1.AttoAlgorithm.V1, publicKey);
-        return {
-            secretType: input.secretType,
-            keyIndex: input.keyIndex,
-            privateKey,
-            publicKey,
-            address,
-            seed,
-        };
-    }
-    const privateKey = commons_core_1.AttoPrivateKey.Companion.parse(input.walletSecret);
-    const publicKey = (0, commons_core_1.toPublicKey)(privateKey);
-    const address = new commons_core_1.AttoAddress(commons_core_1.AttoAlgorithm.V1, publicKey);
-    return {
-        secretType: input.secretType,
-        keyIndex: input.keyIndex,
-        privateKey,
-        publicKey,
-        address,
-    };
+function simplifyOutput(parameters) {
+    return parameters.simplify !== false;
 }
-exports.deriveAccountFromSecret = deriveAddressFromSecret;
-function requireNodeUrl(credentials) {
-    const nodeUrl = text(credentials.nodeUrl);
-    if (!nodeUrl)
+function requireNodeUrl(value) {
+    const url = text(value.nodeUrl);
+    if (!url)
         throw new Error('Atto credentials must include a Node Base URL');
-    return nodeUrl.replace(/\/+$/, '');
+    return url.replace(/\/+$/, '');
 }
-function requireWorkerUrl(credentials) {
-    const workerUrl = text(credentials.workerUrl);
-    if (!workerUrl)
+function requireWorkerUrl(value) {
+    const url = text(value.workerUrl);
+    if (!url)
         throw new Error('Atto credentials must include a Worker Base URL');
-    return workerUrl.replace(/\/+$/, '');
+    return url.replace(/\/+$/, '');
 }
-function applyHeaders(builder, credentials) {
-    const apiKey = text(credentials.apiKey);
+function requestHeaders(value, accept = 'application/json') {
+    const headers = { Accept: accept };
+    const apiKey = text(value.apiKey);
     if (!apiKey)
-        return builder;
-    const header = text(credentials.authHeaderName || 'Authorization');
-    if (!header)
+        return headers;
+    const headerName = text(value.authHeaderName || 'Authorization');
+    if (!headerName)
         throw new Error('API Key Header is required when API Key is set');
-    const prefix = text(credentials.authHeaderPrefix);
-    return builder.header(header, prefix ? `${prefix} ${apiKey}` : apiKey);
-}
-function sha256(value) {
-    return (0, node_crypto_1.createHash)('sha256').update(value).digest('hex');
-}
-function workerClientCacheKey(credentials) {
-    const workerUrl = requireWorkerUrl(credentials);
-    const apiKey = text(credentials.apiKey);
-    if (!apiKey) {
-        return JSON.stringify({
-            workerUrl,
-            auth: 'none',
-        });
-    }
-    const header = text(credentials.authHeaderName || 'Authorization');
-    if (!header)
-        throw new Error('API Key Header is required when API Key is set');
-    const prefix = text(credentials.authHeaderPrefix);
-    const headerValue = prefix ? `${prefix} ${apiKey}` : apiKey;
-    return JSON.stringify({
-        workerUrl,
-        header,
-        headerValueHash: sha256(headerValue),
-    });
+    const prefix = text(value.authHeaderPrefix);
+    headers[headerName] = prefix ? `${prefix} ${apiKey}` : apiKey;
+    return headers;
 }
-function createNodeClient(credentials) {
-    const attoCredentials = normalizeCredentials(credentials);
-    return applyHeaders(new commons_node_remote_1.AttoNodeClientAsyncBuilder(requireNodeUrl(attoCredentials)), attoCredentials).build();
-}
-function createWorkerClient(credentials) {
-    const attoCredentials = normalizeCredentials(credentials);
-    const cacheKey = workerClientCacheKey(attoCredentials);
-    const cachedWorker = workerClientCache.get(cacheKey);
-    if (cachedWorker)
-        return cachedWorker;
-    const worker = applyHeaders(new commons_worker_remote_1.AttoWorkerAsyncBuilder(requireWorkerUrl(attoCredentials)), attoCredentials)
-        .cached(true)
-        .build();
-    if (workerClientCache.size >= MAX_WORKER_CLIENT_CACHE_SIZE) {
-        const oldestKey = workerClientCache.keys().next().value;
-        if (typeof oldestKey === 'string')
-            workerClientCache.delete(oldestKey);
-    }
-    workerClientCache.set(cacheKey, worker);
-    return worker;
+function apiError(context, error, message) {
+    const cause = error && typeof error === 'object' ? error : { message: String(error) };
+    return new n8n_workflow_1.NodeApiError(context.getNode(), cause, { message });
 }
-function clearWorkerClientCache() {
-    for (const worker of workerClientCache.values()) {
-        try {
-            worker.close?.();
-        }
-        catch {
-        }
-    }
-    workerClientCache.clear();
-}
-async function createWalletRuntime(parameters, credentials) {
-    const derived = await deriveAddressFromSecret(parameters, credentials);
-    const node = createNodeClient(credentials);
-    const worker = createWorkerClient(credentials);
-    const builder = new commons_wallet_1.AttoWalletAsyncBuilder(node, worker);
-    if (derived.seed) {
-        builder.signerProviderSeed(derived.seed);
+function responseStatus(response) {
+    if (!response || typeof response !== 'object')
+        return undefined;
+    const value = response;
+    const status = Number(value.statusCode ?? value.status);
+    return Number.isFinite(status) ? status : undefined;
+}
+function responseBody(response) {
+    if (!response || typeof response !== 'object' || !('body' in response))
+        return response;
+    return response.body;
+}
+async function requestText(context, value, baseUrl, method, path, options = {}) {
+    const request = {
+        url: `${baseUrl}/${path}`,
+        method,
+        headers: {
+            ...requestHeaders(value),
+            ...(options.body ? { 'Content-Type': 'application/json' } : {}),
+        },
+        encoding: 'text',
+        json: false,
+        timeout: options.timeoutMs ?? 10_000,
+        returnFullResponse: options.allowNotFound,
+        ignoreHttpStatusErrors: options.allowNotFound,
+        ...(options.body ? { body: (0, protocol_1.stringifyAttoJson)(options.body) } : {}),
+    };
+    try {
+        const response = await context.helpers.httpRequest(request);
+        if (options.allowNotFound && responseStatus(response) === 404)
+            return undefined;
+        const status = responseStatus(response);
+        if (status !== undefined && status >= 400)
+            throw new Error(`Atto API returned HTTP ${status}`);
+        const body = responseBody(response);
+        return typeof body === 'string' ? body : JSON.stringify(body);
+    }
+    catch (error) {
+        throw apiError(context, error, `Atto API request failed: ${method} /${path}`);
+    }
+}
+async function requestJson(context, value, baseUrl, method, path, options = {}) {
+    const body = await requestText(context, value, baseUrl, method, path, options);
+    if (body === undefined || !body.trim())
+        return undefined;
+    try {
+        return (0, protocol_1.parseAttoJson)(body);
     }
-    else {
-        builder.signerProviderFunction({
-            get: async () => (0, commons_core_1.privateKeyToSigner)(derived.privateKey),
-        });
+    catch (error) {
+        throw apiError(context, error, `Atto API returned invalid JSON for ${method} /${path}`);
     }
-    const wallet = builder.build();
-    await wallet.openAccount((0, commons_core_1.toAttoIndex)(derived.keyIndex));
-    return { node, derived, wallet };
 }
-function parseAddress(value, fieldName) {
-    const raw = text(value);
-    if (!raw)
-        throw new Error(`${fieldName} is required`);
+function streamChunk(value) {
+    if (typeof value === 'string')
+        return value;
+    if (Buffer.isBuffer(value))
+        return value.toString('utf8');
+    if (value instanceof Uint8Array)
+        return Buffer.from(value).toString('utf8');
+    return String(value);
+}
+function isExpectedStreamEnd(error) {
+    if (!error || typeof error !== 'object')
+        return false;
+    const value = error;
+    const message = String(value.message ?? '').toLowerCase();
+    return (value.code === 'ECONNABORTED' ||
+        value.name === 'AbortError' ||
+        message.includes('aborted') ||
+        message.includes('timeout') ||
+        message.includes('timed out'));
+}
+async function requestStream(context, value, request) {
+    const controller = new AbortController();
+    const options = {
+        url: `${requireNodeUrl(value)}/${request.path}`,
+        method: request.method,
+        headers: {
+            ...requestHeaders(value, 'application/x-ndjson'),
+            ...(request.body ? { 'Content-Type': 'application/json' } : {}),
+        },
+        encoding: 'stream',
+        json: false,
+        timeout: request.timeoutMs,
+        abortSignal: controller.signal,
+        ...(request.body ? { body: (0, protocol_1.stringifyAttoJson)(request.body) } : {}),
+    };
+    const items = [];
+    let pending = '';
     try {
-        return commons_core_1.AttoAddress.parse(raw);
+        const response = await context.helpers.httpRequest(options);
+        if (!response || typeof response !== 'object' || !(Symbol.asyncIterator in response)) {
+            throw new Error('Atto stream response is not readable');
+        }
+        for await (const chunk of response) {
+            pending += streamChunk(chunk);
+            const lines = pending.split('\n');
+            pending = lines.pop() ?? '';
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                const parsed = (0, protocol_1.parseAttoJson)(line);
+                items.push(parsed);
+                if (items.length >= request.maxItems) {
+                    controller.abort();
+                    return items;
+                }
+            }
+        }
+        if (pending.trim() && items.length < request.maxItems)
+            items.push((0, protocol_1.parseAttoJson)(pending));
+        return items;
     }
-    catch {
-        throw new Error(`${fieldName} must be a valid Atto address`);
+    catch (error) {
+        if (controller.signal.aborted || isExpectedStreamEnd(error))
+            return items;
+        throw apiError(context, error, `Atto API stream failed: ${request.method} /${request.path}`);
     }
 }
-function parseOptionalAddress(value, fieldName) {
-    const raw = optionalText(value);
-    return raw ? parseAddress(raw, fieldName) : undefined;
-}
-function parseAddressList(value, fieldName) {
-    const raw = typeof value === 'string'
-        ? value
-        : Array.isArray(value)
-            ? value.join('\n')
-            : '';
-    const addresses = raw
-        .split(/[\n,]+/)
-        .map((address) => address.trim())
-        .filter(Boolean)
-        .map((address) => parseAddress(address, fieldName));
-    if (addresses.length === 0)
-        throw new Error(`${fieldName} is required`);
-    return addresses;
+function contextRequired(context) {
+    if (!context)
+        throw new Error('This Atto operation requires an n8n execution context');
+    return context;
 }
-function parseAddressSource(value, allowAll) {
+function addressSource(value, allowAll) {
     const source = text(value || 'credentials');
     if (source === 'credentials' || source === 'manual')
         return source;
@@ -227,398 +202,341 @@ function parseAddressSource(value, allowAll) {
         return source;
     throw new Error('Address Source must be credentials, manual, or all');
 }
-function parseQueryMode(value) {
+function queryMode(value) {
     const mode = text(value || 'credentials');
     if (mode === 'credentials' || mode === 'manual' || mode === 'all' || mode === 'hash')
         return mode;
     throw new Error('Query Mode must be credentials, manual, all, or hash');
 }
-async function addressesFromSource(parameters, credentials, allowAll = false) {
-    const source = parseAddressSource(parameters.addressSource, allowAll);
-    if (source === 'all')
-        return undefined;
-    if (source === 'manual')
-        return parseAddressList(parameters.addresses ?? parameters.address, 'Address');
-    const derived = await deriveAddressFromSecret({ secretSource: 'credentials' }, credentials);
-    return [derived.address];
-}
-async function addressForCredentials(credentials) {
-    const derived = await deriveAddressFromSecret({ secretSource: 'credentials' }, credentials);
-    return derived.address;
-}
-function parseAmount(amount, unit, fieldName) {
-    const raw = text(amount);
-    if (!raw)
+function parseAddresses(value, fieldName) {
+    const source = typeof value === 'string' ? value : Array.isArray(value) ? value.join('\n') : '';
+    const result = source
+        .split(/[\n,]+/)
+        .map((address) => address.trim())
+        .filter(Boolean)
+        .map((address) => (0, protocol_1.parseAddress)(address, fieldName));
+    if (result.length === 0)
         throw new Error(`${fieldName} is required`);
-    try {
-        const amountValue = text(unit).toUpperCase() === 'RAW'
-            ? commons_core_1.AttoAmount.from(commons_core_1.AttoUnit.RAW, raw)
-            : commons_core_1.AttoAmount.from(commons_core_1.AttoUnit.ATTO, raw);
-        if (amountValue.toString() === '0') {
-            throw new Error('zero');
-        }
-        return amountValue;
-    }
-    catch {
-        throw new Error(`${fieldName} must be a positive Atto amount`);
-    }
+    return result;
 }
-function parseOptionalAmount(amount, unit, fieldName) {
-    const raw = optionalText(amount);
-    return raw ? parseAmount(raw, unit, fieldName) : undefined;
+async function derivedAddress(value) {
+    return await (0, protocol_1.deriveAddressFromSecret)({ secretSource: 'credentials' }, value);
 }
-function parseHash(value, fieldName) {
-    const raw = text(value);
-    if (!raw)
-        throw new Error(`${fieldName} is required`);
-    try {
-        return commons_core_1.AttoHash.Companion.parse(raw);
-    }
-    catch {
-        throw new Error(`${fieldName} must be a valid Atto hash`);
-    }
-}
-function parseOptionalHeight(value, fieldName) {
-    const raw = optionalText(value);
-    if (!raw)
+async function addressesForSource(parameters, value, allowAll = false) {
+    const source = addressSource(parameters.addressSource, allowAll);
+    if (source === 'all')
         return undefined;
-    try {
-        return (0, commons_core_1.toAttoHeight)(raw);
-    }
-    catch {
-        throw new Error(`${fieldName} must be a valid Atto height`);
-    }
-}
-function parseRequiredHeight(value, fieldName) {
-    return parseOptionalHeight(value, fieldName) ?? (0, commons_core_1.toAttoHeight)('1');
-}
-function assertSameAddress(expected, actual, fieldName) {
-    if (!expected.equals(actual)) {
-        throw new Error(`${fieldName} must match the address derived from the wallet secret`);
-    }
-}
-function assertOptionalSameAddress(expected, actual, fieldName) {
-    if (actual)
-        assertSameAddress(expected, actual, fieldName);
-}
-function parseJsonObject(value) {
-    return JSON.parse(value);
-}
-function amountOutput(amount) {
-    return {
-        raw: amount.toString(),
-        atto: amount.toFormattedString(commons_core_1.AttoUnit.ATTO),
-    };
+    if (source === 'manual')
+        return parseAddresses(parameters.addresses ?? parameters.address, 'Address');
+    return [await derivedAddress(value)];
 }
-function accountOutput(account) {
-    return {
-        found: true,
-        address: account.address.value,
-        publicKey: account.publicKey.toString(),
-        balance: amountOutput(account.balance),
-        representativeAddress: account.representativeAddress.value,
-        height: account.height.toString(),
-        frontier: account.lastTransactionHash.toString(),
-        account: parseJsonObject((0, commons_node_1.accountToJson)(account)),
-    };
+async function addressesForQuery(parameters, value) {
+    const mode = queryMode(parameters.queryMode);
+    if (mode === 'all' || mode === 'hash')
+        return undefined;
+    return mode === 'manual'
+        ? parseAddresses(parameters.addresses ?? parameters.address, 'Address')
+        : [await derivedAddress(value)];
 }
-function receivableOutput(receivable) {
+function streamLimits(parameters) {
     return {
-        hash: receivable.hash.toString(),
-        address: receivable.receiverAddress.value,
-        fromAddress: receivable.address.value,
-        amount: amountOutput(receivable.amount),
-        receivable: parseJsonObject((0, commons_node_1.receivableToJson)(receivable)),
+        maxItems: positiveInteger(parameters.maxItems ?? 25, 'Max Items'),
+        timeoutMs: positiveInteger(parameters.timeoutMs ?? DEFAULT_STREAM_TIMEOUT_MS, 'Timeout'),
     };
 }
-function transactionOutput(transaction, status) {
-    return {
-        ...(status ? { status } : {}),
-        hash: transaction.hash.toString(),
-        address: transaction.address.value,
-        height: transaction.height.toString(),
-        transaction: parseJsonObject((0, commons_node_1.transactionToJson)(transaction)),
-    };
+function heightQuery(parameters) {
+    const fromHeight = positiveHeight(parameters.fromHeight, 'From Height') ?? '1';
+    const toHeight = positiveHeight(parameters.toHeight, 'To Height');
+    return `fromHeight=${encodeURIComponent(fromHeight)}${toHeight ? `&toHeight=${encodeURIComponent(toHeight)}` : ''}`;
 }
-function accountEntryOutput(accountEntry) {
+function heightSearch(addresses, parameters) {
+    const fromHeight = positiveHeight(parameters.fromHeight, 'From Height') ?? '1';
+    const toHeight = positiveHeight(parameters.toHeight, 'To Height');
     return {
-        hash: accountEntry.hash.toString(),
-        address: accountEntry.address.value,
-        subjectAddress: accountEntry.subjectAddress.value,
-        height: accountEntry.height.toString(),
-        blockType: accountEntry.blockType.name,
-        previousBalance: amountOutput(accountEntry.previousBalance),
-        balance: amountOutput(accountEntry.balance),
-        accountEntry: parseJsonObject((0, commons_node_1.accountEntryToJson)(accountEntry)),
+        search: addresses.map((address) => ({
+            address: address.value,
+            fromHeight,
+            ...(toHeight ? { toHeight } : {}),
+        })),
     };
 }
-function streamOptions(parameters) {
+async function receivableStreamRequest(parameters, value, maxItems, timeoutMs) {
+    const addresses = (await addressesForSource(parameters, value)) ?? [];
+    const minimum = optionalText(parameters.minAmount)
+        ? (0, protocol_1.parseAmount)(parameters.minAmount, parameters.minAmountUnit ?? 'RAW', 'Minimum Amount').toString()
+        : '0';
+    const limits = streamLimits(parameters);
     return {
-        maxItems: positiveInteger(parameters.maxItems ?? 25, 'Max Items') || 1,
-        timeoutMs: positiveTimeout(parameters.timeoutMs ?? DEFAULT_STREAM_TIMEOUT_MS, 'Timeout'),
+        method: 'POST',
+        path: `accounts/receivables/stream?minAmount=${minimum}`,
+        body: { addresses: addresses.map((address) => address.value) },
+        maxItems: maxItems ?? limits.maxItems,
+        timeoutMs: timeoutMs ?? limits.timeoutMs,
     };
 }
-function cancelJob(job) {
-    try {
-        job?.cancel?.();
-        job?.close?.();
-    }
-    catch {
-    }
-}
-function errorFromUnknown(error, fallback) {
-    if (!error)
-        return new Error(fallback);
-    if (error instanceof Error)
-        return error;
-    return new Error(String(error));
-}
-async function collectStream(start, options) {
-    return await new Promise((resolve, reject) => {
-        const items = [];
-        let settled = false;
-        const state = {};
-        const finish = (error) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            cancelJob(state.job);
-            if (error) {
-                reject(error);
-                return;
-            }
-            resolve(items);
+async function transactionStreamRequest(parameters, value, maxItems, timeoutMs) {
+    const mode = queryMode(parameters.queryMode);
+    const limits = streamLimits(parameters);
+    if (mode === 'hash') {
+        return {
+            method: 'GET',
+            path: `transactions/${(0, protocol_1.parseHash)(parameters.hash, 'Hash')}/stream`,
+            maxItems: maxItems ?? 1,
+            timeoutMs: timeoutMs ?? limits.timeoutMs,
         };
-        const timer = setTimeout(() => finish(), options.timeoutMs);
-        state.job = start((item) => {
-            if (settled)
-                return;
-            items.push(item);
-            if (items.length >= options.maxItems)
-                finish();
-        }, (error) => {
-            if (settled)
-                return;
-            finish(error ? errorFromUnknown(error, 'Atto stream stopped') : undefined);
-        });
-    });
-}
-function inputItem(parameters) {
-    const item = parameters.inputItem;
-    if (!item || typeof item !== 'object' || Array.isArray(item)) {
-        throw new Error('Input item must contain a receivable object from Atto Trigger or Get Receivables');
-    }
-    return item;
-}
-function parseInputReceivable(parameters) {
-    const item = inputItem(parameters);
-    const value = item.receivable ?? item;
-    const json = typeof value === 'string' ? value : JSON.stringify(value);
-    try {
-        return (0, commons_node_1.receivableFromJson)(json);
     }
-    catch {
-        throw new Error('Input item must contain a valid Atto receivable object');
-    }
-}
-async function withTimeout(promise, timeoutMs, operationName) {
-    let timer;
-    try {
-        return await Promise.race([
-            promise,
-            new Promise((_resolve, reject) => {
-                timer = setTimeout(() => reject(new Error(`${operationName} timed out after ${timeoutMs}ms`)), timeoutMs);
-            }),
-        ]);
+    const addresses = await addressesForQuery(parameters, value);
+    if (!addresses) {
+        return { method: 'GET', path: 'transactions/stream', maxItems: maxItems ?? limits.maxItems, timeoutMs: timeoutMs ?? limits.timeoutMs };
     }
-    finally {
-        if (timer)
-            clearTimeout(timer);
+    if (addresses.length === 1) {
+        return {
+            method: 'GET',
+            path: `accounts/${addresses[0].publicKey}/transactions/stream?${heightQuery(parameters)}`,
+            maxItems: maxItems ?? limits.maxItems,
+            timeoutMs: timeoutMs ?? limits.timeoutMs,
+        };
     }
+    return {
+        method: 'POST',
+        path: 'accounts/transactions/stream',
+        body: heightSearch(addresses, parameters),
+        maxItems: maxItems ?? limits.maxItems,
+        timeoutMs: timeoutMs ?? limits.timeoutMs,
+    };
 }
-function heightSearch(addresses, parameters) {
-    const fromHeight = parseRequiredHeight(parameters.fromHeight, 'From Height');
-    const toHeight = parseOptionalHeight(parameters.toHeight, 'To Height');
-    const searches = addresses.map((address) => new commons_node_1.AccountHeightSearch(address, fromHeight, toHeight));
-    return commons_node_1.HeightSearch.Companion.fromArray(searches);
-}
-async function collectReceivables(node, parameters, credentials) {
-    const addresses = await addressesFromSource(parameters, credentials);
-    const minAmount = parseOptionalAmount(parameters.minAmount, parameters.minAmountUnit ?? 'RAW', 'Minimum Amount');
-    const options = streamOptions(parameters);
-    const receivables = await collectStream((onItem, onCancel) => node.onReceivableByAddresses(addresses, minAmount, onItem, onCancel), options);
-    return receivables.map(receivableOutput);
-}
-async function collectTransactionsForMode(node, parameters, credentials) {
-    const mode = parseQueryMode(parameters.queryMode);
+async function accountEntryStreamRequest(parameters, value, maxItems, timeoutMs) {
+    const mode = queryMode(parameters.queryMode);
+    const limits = streamLimits(parameters);
     if (mode === 'hash') {
-        const transaction = await node.transaction(parseHash(parameters.hash, 'Hash'));
-        return [transactionOutput(transaction)];
+        return {
+            method: 'GET',
+            path: `accounts/entries/${(0, protocol_1.parseHash)(parameters.hash, 'Hash')}/stream`,
+            maxItems: maxItems ?? 1,
+            timeoutMs: timeoutMs ?? limits.timeoutMs,
+        };
     }
-    const addresses = mode === 'credentials' ? [await addressForCredentials(credentials)] : mode === 'manual' ? parseAddressList(parameters.addresses ?? parameters.address, 'Address') : undefined;
-    const fromHeight = parseOptionalHeight(parameters.fromHeight, 'From Height');
-    const toHeight = parseOptionalHeight(parameters.toHeight, 'To Height');
-    const options = streamOptions(parameters);
-    const transactions = await collectStream((onItem, onCancel) => subscribeToTransactionAddresses(node, addresses, fromHeight, toHeight, parameters, onItem, onCancel), options);
-    return transactions.map((transaction) => transactionOutput(transaction));
-}
-async function collectAccountEntries(node, parameters, credentials) {
-    const mode = parseQueryMode(parameters.queryMode);
-    if (mode === 'hash') {
-        const accountEntry = await node.accountEntry(parseHash(parameters.hash, 'Hash'));
-        return [accountEntryOutput(accountEntry)];
+    const addresses = await addressesForQuery(parameters, value);
+    if (!addresses) {
+        return { method: 'GET', path: 'accounts/entries/stream', maxItems: maxItems ?? limits.maxItems, timeoutMs: timeoutMs ?? limits.timeoutMs };
     }
-    const addresses = mode === 'credentials' ? [await addressForCredentials(credentials)] : mode === 'manual' ? parseAddressList(parameters.addresses ?? parameters.address, 'Address') : undefined;
-    const fromHeight = parseOptionalHeight(parameters.fromHeight, 'From Height');
-    const toHeight = parseOptionalHeight(parameters.toHeight, 'To Height');
-    const options = streamOptions(parameters);
-    const accountEntries = await collectStream((onItem, onCancel) => subscribeToAccountEntryAddresses(node, addresses, fromHeight, toHeight, parameters, onItem, onCancel), options);
-    return accountEntries.map((accountEntry) => accountEntryOutput(accountEntry));
-}
-function subscribeToTransactionAddresses(node, addresses, fromHeight, toHeight, parameters, onItem, onCancel) {
-    if (!addresses)
-        return node.onTransactionAll(onItem, onCancel);
     if (addresses.length === 1) {
-        return node.onTransactionByPublicKey(addresses[0].publicKey, fromHeight, toHeight, onItem, onCancel);
+        return {
+            method: 'GET',
+            path: `accounts/${addresses[0].publicKey}/entries/stream?${heightQuery(parameters)}`,
+            maxItems: maxItems ?? limits.maxItems,
+            timeoutMs: timeoutMs ?? limits.timeoutMs,
+        };
     }
-    return node.onTransactionByHeightSearch(heightSearch(addresses, parameters), onItem, onCancel);
+    return {
+        method: 'POST',
+        path: 'accounts/entries/stream',
+        body: heightSearch(addresses, parameters),
+        maxItems: maxItems ?? limits.maxItems,
+        timeoutMs: timeoutMs ?? limits.timeoutMs,
+    };
 }
-function subscribeToAccountEntryAddresses(node, addresses, fromHeight, toHeight, parameters, onItem, onCancel) {
-    if (!addresses)
-        return node.onAccountEntryAll(onItem, onCancel);
-    if (addresses.length === 1) {
-        return node.onAccountEntryByPublicKey(addresses[0].publicKey, fromHeight, toHeight, onItem, onCancel);
+async function accountByAddress(context, value, address) {
+    return (await requestJson(context, value, requireNodeUrl(value), 'GET', `accounts/${address.publicKey}`, {
+        allowNotFound: true,
+        timeoutMs: 3000,
+    }));
+}
+async function nodeTimestamp(context, value) {
+    const localTimestamp = Date.now();
+    const response = (await requestJson(context, value, requireNodeUrl(value), 'GET', `instants/${encodeURIComponent(new Date(localTimestamp).toISOString())}`));
+    const difference = Number(response?.differenceMillis ?? 0);
+    if (!Number.isSafeInteger(difference))
+        throw new Error('Atto node returned an invalid clock difference');
+    return Date.now() + difference;
+}
+async function workForBlock(context, value, block, timeoutMs) {
+    const response = (await requestJson(context, value, requireWorkerUrl(value), 'POST', 'works', {
+        body: {
+            network: block.network.name,
+            timestamp: Number(block.timestamp.toEpochMilliseconds()),
+            target: (0, protocol_1.workTarget)(block),
+        },
+        timeoutMs,
+    }));
+    const work = text(response?.work);
+    if (!work)
+        throw new Error('Atto worker response is missing work');
+    return work;
+}
+async function publishBlock(context, value, block, signer, timeoutMs) {
+    const transaction = await (0, protocol_1.signedTransaction)(block, signer, await workForBlock(context, value, block, timeoutMs));
+    const accepted = await requestStream(context, value, {
+        method: 'POST',
+        path: 'transactions/stream',
+        body: transaction.raw,
+        maxItems: 1,
+        timeoutMs,
+    });
+    if (accepted.length === 0)
+        throw new Error('Atto node did not acknowledge the transaction before timeout');
+    if ((0, protocol_1.blockHash)((accepted[0].block ?? {})) !== transaction.model.hash.toString()) {
+        throw new Error('Atto node acknowledged a different transaction');
     }
-    return node.onAccountEntryByHeightSearch(heightSearch(addresses, parameters), onItem, onCancel);
+    return transaction.raw;
 }
-async function executeAttoOperation(operation, parameters, credentials) {
-    const attoCredentials = normalizeCredentials(credentials);
+async function receivableFromInput(context, value, parameters) {
+    const item = parameters.inputItem;
+    if (!item || typeof item !== 'object' || Array.isArray(item)) {
+        throw new Error('Input item must contain a receivable from Atto Trigger or Get Receivables');
+    }
+    const input = item;
+    const nested = input.receivable;
+    if (nested && typeof nested === 'object' && !Array.isArray(nested))
+        return nested;
+    if (input.network && input.receiverPublicKey && input.amount)
+        return input;
+    const hash = (0, protocol_1.parseHash)(input.hash, 'Input receivable hash');
+    const transaction = (await requestJson(context, value, requireNodeUrl(value), 'GET', `transactions/${hash}`));
+    const block = transaction.block;
+    if (!block || block.type !== 'SEND')
+        throw new Error('Input receivable hash does not identify an Atto send transaction');
+    return {
+        network: block.network,
+        hash,
+        version: block.version,
+        algorithm: block.algorithm,
+        publicKey: block.publicKey,
+        timestamp: block.timestamp,
+        receiverAlgorithm: block.receiverAlgorithm,
+        receiverPublicKey: block.receiverPublicKey,
+        amount: block.amount,
+    };
+}
+async function executeAttoOperation(context, operation, parameters, credentialData) {
+    const value = credentials(credentialData);
+    const simplify = simplifyOutput(parameters);
     if (operation === 'deriveAddress' || operation === 'deriveAccount') {
-        const derived = await deriveAddressFromSecret(parameters, credentials);
-        return {
-            address: derived.address.value,
-            publicKey: derived.publicKey.toString(),
-            keyIndex: derived.keyIndex,
-            secretType: derived.secretType,
-        };
+        const derived = await (0, protocol_1.deriveAddressFromSecret)(parameters, value);
+        return { address: derived.value, publicKey: derived.publicKey, keyIndex: derived.keyIndex, secretType: derived.secretType };
     }
+    const execution = contextRequired(context);
     if (operation === 'getAccount') {
-        const node = createNodeClient(attoCredentials);
-        const address = parseAddress(parameters.address ?? parameters.lookupAddress, 'Address');
-        const account = await node.accountByPublicKey(address.publicKey);
-        if (!account) {
-            return {
-                found: false,
-                address: address.value,
-            };
-        }
-        return accountOutput(account);
+        const address = (0, protocol_1.parseAddress)(parameters.address ?? parameters.lookupAddress, 'Address');
+        const account = await accountByAddress(execution, value, address);
+        return account ? (0, protocol_1.accountOutput)(account, simplify) : { found: false, address: address.value };
     }
     if (operation === 'getReceivables') {
-        const node = createNodeClient(attoCredentials);
-        return await collectReceivables(node, parameters, attoCredentials);
+        return (await requestStream(execution, value, await receivableStreamRequest(parameters, value))).map((item) => (0, protocol_1.receivableOutput)(item, simplify));
     }
     if (operation === 'getTransactions') {
-        const node = createNodeClient(attoCredentials);
-        return await collectTransactionsForMode(node, parameters, attoCredentials);
+        if (queryMode(parameters.queryMode) === 'hash') {
+            const hash = (0, protocol_1.parseHash)(parameters.hash, 'Hash');
+            const transaction = (await requestJson(execution, value, requireNodeUrl(value), 'GET', `transactions/${hash}`));
+            return [(0, protocol_1.transactionOutput)(transaction, simplify)];
+        }
+        return (await requestStream(execution, value, await transactionStreamRequest(parameters, value))).map((item) => (0, protocol_1.transactionOutput)(item, simplify));
     }
     if (operation === 'getAccountEntries') {
-        const node = createNodeClient(attoCredentials);
-        return await collectAccountEntries(node, parameters, attoCredentials);
+        return (await requestStream(execution, value, await accountEntryStreamRequest(parameters, value))).map((item) => (0, protocol_1.accountEntryOutput)(item, simplify));
     }
+    const derived = await (0, protocol_1.deriveAddressFromSecret)(parameters, value);
+    const account = await accountByAddress(execution, value, derived);
+    const timestamp = await nodeTimestamp(execution, value);
+    const timeoutMs = positiveInteger(parameters.timeoutMs ?? DEFAULT_PUBLISH_TIMEOUT_MS, 'Timeout');
     if (operation === 'sendTransaction') {
-        const destinationAddress = parseAddress(parameters.destinationAddress, 'Destination Address');
-        const amount = parseAmount(parameters.amount, parameters.amountUnit, 'Amount');
-        const timeoutMs = positiveTimeout(parameters.timeoutMs ?? DEFAULT_PUBLISH_TIMEOUT_MS, 'Timeout');
-        const runtime = await createWalletRuntime(parameters, attoCredentials);
-        assertOptionalSameAddress(runtime.derived.address, parseOptionalAddress(parameters.fromAddress, 'From Address'), 'From Address');
-        const transaction = await withTimeout(Promise.resolve(runtime.wallet.sendByAddress(runtime.derived.address, destinationAddress, amount, null)), timeoutMs, 'Send transaction');
+        if (!account)
+            throw new Error('The wallet account is not open yet');
+        const destination = (0, protocol_1.parseAddress)(parameters.destinationAddress, 'Destination Address');
+        const amount = (0, protocol_1.parseAmount)(parameters.amount, parameters.amountUnit, 'Amount');
+        const block = (0, protocol_1.createSendBlock)(account, destination, amount, timestamp);
+        const transaction = await publishBlock(execution, value, block, derived.signer, timeoutMs);
         return {
-            ...transactionOutput(transaction, 'published'),
-            fromAddress: runtime.derived.address.value,
-            destinationAddress: destinationAddress.value,
-            amount: amountOutput(amount),
+            ...(0, protocol_1.transactionOutput)(transaction, true, 'published'),
+            fromAddress: derived.value,
+            destinationAddress: destination.value,
+            amount: (0, protocol_1.amountOutput)(amount),
         };
     }
     if (operation === 'receivePending') {
-        const timeoutMs = positiveTimeout(parameters.timeoutMs ?? DEFAULT_PUBLISH_TIMEOUT_MS, 'Timeout');
-        const receivable = parseInputReceivable(parameters);
-        const requestedRepresentative = parseOptionalAddress(parameters.receiveRepresentativeAddress ?? parameters.representativeAddress, 'Representative Address');
-        const runtime = await createWalletRuntime(parameters, attoCredentials);
-        assertOptionalSameAddress(runtime.derived.address, parseOptionalAddress(parameters.receiveAddress, 'Address'), 'Address');
-        assertSameAddress(runtime.derived.address, receivable.receiverAddress, 'Receivable Address');
-        const representative = requestedRepresentative ?? runtime.derived.address;
-        const transaction = await withTimeout(Promise.resolve(runtime.wallet.receive(receivable, representative, null)), timeoutMs, 'Receive transaction');
+        const receivable = await receivableFromInput(execution, value, parameters);
+        const receiver = (0, protocol_1.addressFromPublicKey)(text(receivable.receiverPublicKey));
+        if (receiver.value !== derived.value)
+            throw new Error('Receivable Address must match the address derived from the wallet secret');
+        const representative = optionalText(parameters.representativeAddress)
+            ? (0, protocol_1.parseAddress)(parameters.representativeAddress, 'Representative Address')
+            : derived;
+        const block = (0, protocol_1.createReceiveBlock)(account, receivable, representative, timestamp);
+        const transaction = await publishBlock(execution, value, block, derived.signer, timeoutMs);
         return {
-            ...transactionOutput(transaction, 'received'),
-            address: runtime.derived.address.value,
+            ...(0, protocol_1.transactionOutput)(transaction, true, 'received'),
+            address: derived.value,
             representativeAddress: representative.value,
-            amount: amountOutput(receivable.amount),
-            receivable: parseJsonObject((0, commons_node_1.receivableToJson)(receivable)),
+            amount: (0, protocol_1.amountOutput)(receivable.amount),
         };
     }
     if (operation === 'changeRepresentative') {
-        const representativeAddress = parseAddress(parameters.representativeAddress, 'Representative Address');
-        const runtime = await createWalletRuntime(parameters, attoCredentials);
-        assertOptionalSameAddress(runtime.derived.address, parseOptionalAddress(parameters.changeAddress, 'Address'), 'Address');
-        const transaction = await runtime.wallet.change((0, commons_core_1.toAttoIndex)(runtime.derived.keyIndex), representativeAddress, null);
+        if (!account)
+            throw new Error('The wallet account is not open yet');
+        const representative = (0, protocol_1.parseAddress)(parameters.representativeAddress, 'Representative Address');
+        const block = (0, protocol_1.createChangeBlock)(account, representative, timestamp);
+        const transaction = await publishBlock(execution, value, block, derived.signer, timeoutMs);
         return {
-            ...transactionOutput(transaction, 'representative_changed'),
-            address: runtime.derived.address.value,
-            representativeAddress: representativeAddress.value,
+            ...(0, protocol_1.transactionOutput)(transaction, true, 'representative_changed'),
+            address: derived.value,
+            representativeAddress: representative.value,
         };
     }
     throw new Error(`Unsupported Atto operation: ${operation}`);
 }
-async function createAttoTriggerSubscription(event, parameters, credentials, emit, emitError) {
-    const attoCredentials = normalizeCredentials(credentials);
-    const node = createNodeClient(attoCredentials);
-    let closing = false;
-    const onCancel = (error) => {
-        if (closing || !error)
-            return;
-        emitError(errorFromUnknown(error, 'Atto trigger stream stopped'));
-    };
-    const closeJob = (job) => {
-        closing = true;
-        cancelJob(job);
-    };
+async function pollAccounts(context, parameters, value) {
+    const addresses = await addressesForSource(parameters, value, true);
+    if (addresses?.length === 1) {
+        const account = await accountByAddress(context, value, addresses[0]);
+        return account ? [(0, protocol_1.accountOutput)(account, true)] : [];
+    }
+    return (await requestStream(context, value, {
+        method: addresses ? 'POST' : 'GET',
+        path: 'accounts/stream',
+        ...(addresses ? { body: { addresses: addresses.map((address) => address.value) } } : {}),
+        maxItems: POLL_MAX_ITEMS,
+        timeoutMs: POLL_TIMEOUT_MS,
+    })).map((item) => (0, protocol_1.accountOutput)(item, true));
+}
+function pollItemKey(event, item) {
+    if (event === 'account')
+        return `${String(item.address)}:${String(item.frontier)}:${String(item.balance?.raw ?? '')}`;
+    return String(item.hash ?? JSON.stringify(item));
+}
+function newPollItems(context, event, items) {
+    const staticData = context.getWorkflowStaticData('node');
+    const stateKey = `seen_${event}`;
+    const existing = Array.isArray(staticData[stateKey]) ? staticData[stateKey].map(String) : [];
+    const seen = new Set(existing);
+    const fresh = items.filter((item) => !seen.has(pollItemKey(event, item)));
+    const updated = [...existing, ...items.map((item) => pollItemKey(event, item))].slice(-MAX_SEEN_POLL_ITEMS);
+    staticData[stateKey] = updated;
+    if (existing.length === 0 && context.getMode() !== 'manual')
+        return [];
+    return fresh;
+}
+async function pollAttoEvent(context, event, parameters, credentialData) {
+    const value = credentials(credentialData);
+    let items;
     if (event === 'receivable') {
-        const addresses = await addressesFromSource(parameters, attoCredentials);
-        const minAmount = parseOptionalAmount(parameters.minAmount, parameters.minAmountUnit ?? 'RAW', 'Minimum Amount');
-        const job = node.onReceivableByAddresses(addresses, minAmount, (receivable) => emit(receivableOutput(receivable)), onCancel);
-        return { close: () => closeJob(job) };
+        items = (await requestStream(context, value, await receivableStreamRequest(parameters, value, POLL_MAX_ITEMS, POLL_TIMEOUT_MS))).map((item) => (0, protocol_1.receivableOutput)(item, true));
     }
-    if (event === 'account') {
-        const addresses = await addressesFromSource(parameters, attoCredentials, true);
-        const job = addresses
-            ? node.onAccountByAddresses(addresses, (account) => emit(accountOutput(account)), onCancel)
-            : node.onAccountAll((account) => emit(accountOutput(account)), onCancel);
-        return { close: () => closeJob(job) };
+    else if (event === 'account') {
+        items = await pollAccounts(context, parameters, value);
     }
-    if (event === 'transaction') {
-        const mode = parseQueryMode(parameters.queryMode);
-        const hash = mode === 'hash' ? parseHash(parameters.hash, 'Hash') : undefined;
-        const addresses = mode === 'credentials' ? [await addressForCredentials(attoCredentials)] : mode === 'manual' ? parseAddressList(parameters.addresses ?? parameters.address, 'Address') : undefined;
-        const fromHeight = parseOptionalHeight(parameters.fromHeight, 'From Height');
-        const toHeight = parseOptionalHeight(parameters.toHeight, 'To Height');
-        const job = hash
-            ? node.onTransactionByHash(hash, (transaction) => emit(transactionOutput(transaction)), onCancel)
-            : subscribeToTransactionAddresses(node, addresses, fromHeight, toHeight, parameters, (transaction) => emit(transactionOutput(transaction)), onCancel);
-        return { close: () => closeJob(job) };
+    else if (event === 'transaction') {
+        const mode = queryMode(parameters.queryMode);
+        if (mode === 'hash') {
+            const transaction = (await requestJson(context, value, requireNodeUrl(value), 'GET', `transactions/${(0, protocol_1.parseHash)(parameters.hash, 'Hash')}`));
+            items = [(0, protocol_1.transactionOutput)(transaction, true)];
+        }
+        else {
+            items = (await requestStream(context, value, await transactionStreamRequest(parameters, value, POLL_MAX_ITEMS, POLL_TIMEOUT_MS))).map((item) => (0, protocol_1.transactionOutput)(item, true));
+        }
     }
-    if (event === 'accountEntry') {
-        const mode = parseQueryMode(parameters.queryMode);
-        const hash = mode === 'hash' ? parseHash(parameters.hash, 'Hash') : undefined;
-        const addresses = mode === 'credentials' ? [await addressForCredentials(attoCredentials)] : mode === 'manual' ? parseAddressList(parameters.addresses ?? parameters.address, 'Address') : undefined;
-        const fromHeight = parseOptionalHeight(parameters.fromHeight, 'From Height');
-        const toHeight = parseOptionalHeight(parameters.toHeight, 'To Height');
-        const job = hash
-            ? node.onAccountEntryByHash(hash, (accountEntry) => emit(accountEntryOutput(accountEntry)), onCancel)
-            : subscribeToAccountEntryAddresses(node, addresses, fromHeight, toHeight, parameters, (accountEntry) => emit(accountEntryOutput(accountEntry)), onCancel);
-        return { close: () => closeJob(job) };
+    else {
+        items = (await requestStream(context, value, await accountEntryStreamRequest(parameters, value, POLL_MAX_ITEMS, POLL_TIMEOUT_MS))).map((item) => (0, protocol_1.accountEntryOutput)(item, true));
     }
-    throw new Error(`Unsupported Atto trigger event: ${event}`);
+    return newPollItems(context, event, items);
 }
 //# sourceMappingURL=operations.js.map