diff --git a/src/venues/near-intents/signing.mjs b/src/venues/near-intents/signing.mjs
index 671d287..529aeb5 100644
--- a/src/venues/near-intents/signing.mjs
+++ b/src/venues/near-intents/signing.mjs
@@ -54,6 +54,60 @@ export function buildQuoteResponseSubmission({
};
}
+export function buildIntentRequestSubmission({
+ request,
+ signerAccountId,
+ signer,
+ verifierContract,
+ currentSaltHex,
+ nonce = null,
+ now = Date.now(),
+}) {
+ const selectedQuote = request.selected_quote || {};
+ const quoteHash = selectedQuote.quote_hash || request.quote_hash;
+ const destinationAmount = request.destination_amount_units
+ || selectedQuote.amount_out
+ || request.quoted_destination_amount_units;
+ if (!quoteHash) throw new Error('request quote_hash is required');
+ if (!request.source_asset_id || !request.destination_asset_id) throw new Error('request assets are required');
+ if (!request.source_amount_units || !destinationAmount) throw new Error('request amounts are required');
+
+ const deadline = request.deadline_at || new Date(now + Number(request.min_deadline_ms || 60_000)).toISOString();
+ const intentNonce = nonce || buildIntentNonce(currentSaltHex);
+ const payload = {
+ signer_id: signerAccountId,
+ verifying_contract: verifierContract,
+ deadline,
+ nonce: intentNonce,
+ intents: [
+ {
+ intent: 'token_diff',
+ diff: {
+ [request.source_asset_id]: `-${String(request.source_amount_units)}`,
+ [request.destination_asset_id]: String(destinationAmount),
+ },
+ },
+ ],
+ };
+
+ const payloadString = JSON.stringify(payload);
+ const signed = signer.sign(Buffer.from(payloadString));
+
+ return {
+ quote_hashes: [String(quoteHash)],
+ signed_data: {
+ standard: 'raw_ed25519',
+ payload: payloadString,
+ public_key: signer.getPublicKey().toString(),
+ signature: encodeNearSignature(signed.signature),
+ },
+ signed_payload: payload,
+ destination_amount_units: String(destinationAmount),
+ nonce: intentNonce,
+ deadline,
+ };
+}
+
function encodeNearSignature(signatureBytes) {
return `ed25519:${encodeBase58(signatureBytes)}`;
}
diff --git a/src/venues/near-intents/verifier-client.mjs b/src/venues/near-intents/verifier-client.mjs
index 2cc8146..0cd2fc4 100644
--- a/src/venues/near-intents/verifier-client.mjs
+++ b/src/venues/near-intents/verifier-client.mjs
@@ -72,22 +72,45 @@ export function createVerifierClient({
};
}
-export function createSolverRelayRpcClient({ rpcUrl }) {
+export function createSolverRelayRpcClient({ rpcUrl, apiKey = '' }) {
let id = 1;
- return {
- async getStatus(intentHash) {
- const response = await postJson(rpcUrl, {
+
+ async function request(method, params, { timeoutMs = 10_000 } = {}) {
+ const headers = apiKey ? { Authorization: `Bearer ${apiKey}` } : {};
+ const response = await postJson(
+ rpcUrl,
+ {
jsonrpc: '2.0',
id: id++,
- method: 'get_status',
- params: [{ intent_hash: intentHash }],
- });
+ method,
+ params,
+ },
+ {
+ headers,
+ signal: AbortSignal.timeout(timeoutMs),
+ },
+ );
- if (response.error) {
- throw new Error(response.error.message || 'Solver Relay get_status failed');
- }
+ if (response.error) {
+ throw new Error(response.error.message || `Solver Relay ${method} failed`);
+ }
- return response.result;
+ return response.result;
+ }
+
+ return {
+ request,
+ async quote(params, options = {}) {
+ return request('quote', [params], options);
+ },
+ async publishIntent({ quoteHashes, signedData }, options = {}) {
+ return request('publish_intent', [{
+ quote_hashes: quoteHashes,
+ signed_data: signedData,
+ }], options);
+ },
+ async getStatus(intentHash, options = {}) {
+ return request('get_status', [{ intent_hash: intentHash }], options);
},
};
}
diff --git a/test/intent-request-outcomes.test.mjs b/test/intent-request-outcomes.test.mjs
new file mode 100644
index 0000000..3b328ef
--- /dev/null
+++ b/test/intent-request-outcomes.test.mjs
@@ -0,0 +1,161 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { deriveIntentRequestOutcomeRecords } from '../src/core/intent-request-outcomes.mjs';
+
+const BTC = {
+ assetId: 'nep141:btc.omft.near',
+ symbol: 'BTC',
+ decimals: 8,
+};
+const EURE = {
+ assetId: 'nep141:eure.omft.near',
+ symbol: 'EURe',
+ decimals: 18,
+};
+
+function preflight(overrides = {}) {
+ return {
+ request_id: 'request-1',
+ idempotency_key: 'idem-1',
+ state: 'draft',
+ reason_code: 'quote_available',
+ source_asset_id: EURE.assetId,
+ destination_asset_id: BTC.assetId,
+ source_amount_units: '5000000000000000000',
+ min_destination_amount_units: '9800',
+ quoted_destination_amount_units: '10000',
+ selected_quote: {
+ quote_hash: 'quote-hash-1',
+ amount_out: '10000',
+ },
+ min_deadline_ms: 60000,
+ deadline_at: '2026-04-12T10:01:00.000Z',
+ created_at: '2026-04-12T10:00:00.000Z',
+ ...overrides,
+ };
+}
+
+function submission(overrides = {}) {
+ return {
+ request_id: 'request-1',
+ idempotency_key: 'idem-1',
+ submission_id: 'submission-1',
+ status: 'accepted_by_relay',
+ result_code: 'publish_intent_accepted',
+ quote_hash: 'quote-hash-1',
+ intent_hash: 'intent-hash-1',
+ destination_amount_units: '10000',
+ submitted_at: '2026-04-12T10:00:10.000Z',
+ relay_status: 'PENDING',
+ ...overrides,
+ };
+}
+
+function outcomes({ preflights = [preflight()], submissions = [], inventorySnapshots = [], now = '2026-04-12T10:00:30.000Z' } = {}) {
+ return deriveIntentRequestOutcomeRecords({
+ preflights,
+ submissions,
+ inventorySnapshots,
+ btcAsset: BTC,
+ eureAsset: EURE,
+ now: Date.parse(now),
+ });
+}
+
+test('request submitted or relay accepted does not become completed without inventory delta', () => {
+ const [record] = outcomes({
+ submissions: [submission({ relay_status: 'SETTLED' })],
+ inventorySnapshots: [
+ {
+ observed_at: '2026-04-12T10:00:00.000Z',
+ spendable: {
+ [EURE.assetId]: '5000000000000000000',
+ [BTC.assetId]: '0',
+ },
+ },
+ {
+ observed_at: '2026-04-12T10:00:20.000Z',
+ spendable: {
+ [EURE.assetId]: '5000000000000000000',
+ [BTC.assetId]: '0',
+ },
+ },
+ ],
+ });
+
+ assert.equal(record.submission_status, 'accepted_by_relay');
+ assert.equal(record.relay_status, 'SETTLED');
+ assert.equal(record.outcome_status, 'awaiting_settlement');
+ assert.equal(record.outcome_reason, 'relay_settled_but_inventory_delta_missing');
+ assert.equal(record.attribution_status, 'unattributed');
+ assert.equal(record.attributed_inventory_delta, null);
+ assert.notEqual(record.outcome_status, 'completed');
+});
+
+test('completed request requires exact EURe decrease and BTC increase after submission', () => {
+ const [record] = outcomes({
+ submissions: [submission()],
+ inventorySnapshots: [
+ {
+ inventory_id: 'inventory-before',
+ observed_at: '2026-04-12T10:00:00.000Z',
+ spendable: {
+ [EURE.assetId]: '5000000000000000000',
+ [BTC.assetId]: '0',
+ },
+ },
+ {
+ inventory_id: 'inventory-after',
+ observed_at: '2026-04-12T10:00:15.000Z',
+ spendable: {
+ [EURE.assetId]: '0',
+ [BTC.assetId]: '10000',
+ },
+ },
+ ],
+ });
+
+ assert.equal(record.outcome_status, 'completed');
+ assert.equal(record.outcome_source, 'intent_inventory_spendable_delta');
+ assert.equal(record.outcome_reason, 'matched_inventory_delta');
+ assert.equal(record.attribution_status, 'heuristic_match');
+ assert.equal(record.attributed_inventory_delta.inventory_id, 'inventory-after');
+ assert.deepEqual(record.attributed_inventory_delta.delta_units, {
+ [BTC.assetId]: '10000',
+ [EURE.assetId]: '-5000000000000000000',
+ });
+});
+
+test('accepted request becomes not filled only after deadline grace and fresh inventory evidence', () => {
+ const [record] = outcomes({
+ submissions: [submission()],
+ inventorySnapshots: [
+ {
+ observed_at: '2026-04-12T10:02:01.000Z',
+ spendable: {
+ [EURE.assetId]: '5000000000000000000',
+ [BTC.assetId]: '0',
+ },
+ },
+ ],
+ now: '2026-04-12T10:02:01.000Z',
+ });
+
+ assert.equal(record.outcome_status, 'not_filled');
+ assert.equal(record.outcome_reason, 'deadline_elapsed_without_settlement');
+ assert.equal(record.attribution_status, 'unattributed');
+ assert.equal(record.attributed_inventory_delta, null);
+});
+
+test('blocked preflight remains blocked and is distinct from request rejection or completion', () => {
+ const [record] = outcomes({
+ preflights: [preflight({ state: 'blocked', reason_code: 'insufficient_spendable_eure' })],
+ });
+
+ assert.equal(record.outcome_status, 'blocked');
+ assert.equal(record.outcome_reason, 'insufficient_spendable_eure');
+ assert.equal(record.submission_status, null);
+ assert.notEqual(record.outcome_status, 'completed');
+ assert.notEqual(record.outcome_status, 'rejected');
+});
diff --git a/test/intent-requests.test.mjs b/test/intent-requests.test.mjs
new file mode 100644
index 0000000..151465f
--- /dev/null
+++ b/test/intent-requests.test.mjs
@@ -0,0 +1,275 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { KeyPair } from 'near-api-js';
+
+import { createIntentRequestController } from '../src/core/intent-request-controller.mjs';
+import {
+ applySlippageBps,
+ buildSolverQuoteRequest,
+ computeBtcReceiveUnitsFromEure,
+ normalizeSolverQuotes,
+ parseDecimalToUnits,
+ selectBestSolverQuote,
+} from '../src/core/intent-requests.mjs';
+
+const BTC = {
+ assetId: 'nep141:btc.omft.near',
+ symbol: 'BTC',
+ decimals: 8,
+};
+const EURE = {
+ assetId: 'nep141:eure.omft.near',
+ symbol: 'EURe',
+ decimals: 18,
+};
+
+function buildConfig() {
+ return {
+ tradingBtc: BTC,
+ tradingEure: EURE,
+ nearIntentsAccountId: 'unrip.test.near',
+ nearVerifierContract: 'intents.near',
+ intentRequestDefaultAmountEure: 5,
+ intentRequestMaxAmountEure: 5,
+ intentRequestDefaultSlippageBps: 200,
+ intentRequestMaxSlippageBps: 200,
+ intentRequestMinDeadlineMs: 60_000,
+ intentRequestQuoteTimeoutMs: 10_000,
+ intentRequestPublishTimeoutMs: 10_000,
+ intentRequestStatusTimeoutMs: 10_000,
+ intentRequestInventoryMaxAgeMs: 30_000,
+ intentRequestPriceMaxAgeMs: 30_000,
+ executorResponseTimeoutMs: 10_000,
+ };
+}
+
+function buildStore({
+ inventoryUnits = '5000000000000000000',
+ nowIso = '2026-04-12T10:00:00.000Z',
+ inventorySyncedAt = nowIso,
+ priceObservedAt = nowIso,
+} = {}) {
+ const preflights = [];
+ const submissions = [];
+ return {
+ preflights,
+ submissions,
+ async loadLatestInventorySnapshot() {
+ return {
+ ingested_at: nowIso,
+ payload: {
+ synced_at: inventorySyncedAt,
+ spendable: {
+ [EURE.assetId]: inventoryUnits,
+ [BTC.assetId]: '1000',
+ },
+ pending_inbound: {
+ [EURE.assetId]: '100000000000000000000',
+ },
+ },
+ };
+ },
+ async loadLatestMarketPrice() {
+ return {
+ ingested_at: nowIso,
+ payload: {
+ observed_at: priceObservedAt,
+ eure_per_btc: '50000',
+ },
+ };
+ },
+ async insertPreflight(payload) {
+ preflights.push(payload);
+ },
+ async findPreflight({ requestId, idempotencyKey }) {
+ return preflights.find((entry) => (
+ (requestId && entry.request_id === requestId)
+ || (idempotencyKey && entry.idempotency_key === idempotencyKey)
+ )) || null;
+ },
+ async findSubmissionByRequest({ requestId }) {
+ return [...submissions].reverse().find((entry) => entry.request_id === requestId) || null;
+ },
+ async insertSubmissionResult(payload) {
+ submissions.push(payload);
+ },
+ async refreshOutcomes() {
+ return [];
+ },
+ };
+}
+
+function buildRelay() {
+ return {
+ quoteCalls: 0,
+ publishCalls: 0,
+ async quote() {
+ this.quoteCalls += 1;
+ return [{
+ quote_hash: 'quote-hash-1',
+ amount_out: '10000',
+ expiration_time: '2026-04-12T10:01:00.000Z',
+ }];
+ },
+ async publishIntent() {
+ this.publishCalls += 1;
+ return { status: 'OK', intent_hash: 'intent-hash-1' };
+ },
+ async getStatus() {
+ return { status: 'PENDING' };
+ },
+ };
+}
+
+function buildController({ store = buildStore(), relay = buildRelay(), armed = true, verifierRegistered = true } = {}) {
+ return {
+ store,
+ relay,
+ controller: createIntentRequestController({
+ config: buildConfig(),
+ store,
+ relayRpcClient: relay,
+ verifierClient: {
+ async isPublicKeyRegistered() { return verifierRegistered; },
+ async currentSalt() { return '252812b3'; },
+ },
+ signer: KeyPair.fromRandom('ed25519'),
+ isArmed: () => armed,
+ isPaused: () => false,
+ now: () => Date.parse('2026-04-12T10:00:00.000Z'),
+ uuid: (() => {
+ let next = 1;
+ return () => `id-${next++}`;
+ })(),
+ }),
+ };
+}
+
+test('EURe decimal parsing, BTC expected receive, and slippage math are exact enough for request limits', () => {
+ const sourceUnits = parseDecimalToUnits('5', EURE.decimals, { field: 'amount_eure' });
+ const expectedBtc = computeBtcReceiveUnitsFromEure({
+ eureUnits: sourceUnits,
+ eurPerBtc: '50000',
+ eureDecimals: EURE.decimals,
+ btcDecimals: BTC.decimals,
+ });
+
+ assert.equal(sourceUnits, '5000000000000000000');
+ assert.equal(expectedBtc, '10000');
+ assert.equal(applySlippageBps(expectedBtc, 200), '9800');
+});
+
+test('solver quote normalization selects the best quote above explicit min receive', () => {
+ const quotes = normalizeSolverQuotes({
+ quotes: [
+ { quote_hash: 'low', amount_out: '9700' },
+ { quote_hash: 'best', amount_out: '10050' },
+ { quote_hash: 'ok', amount_out: '9900' },
+ ],
+ });
+ const selected = selectBestSolverQuote(quotes, { minDestinationAmountUnits: '9800' });
+
+ assert.equal(selected.quote_hash, 'best');
+ assert.deepEqual(buildSolverQuoteRequest({
+ sourceAssetId: EURE.assetId,
+ destinationAssetId: BTC.assetId,
+ sourceAmountUnits: '5000000000000000000',
+ minDeadlineMs: 60_000,
+ }), {
+ defuse_asset_identifier_in: EURE.assetId,
+ defuse_asset_identifier_out: BTC.assetId,
+ exact_amount_in: '5000000000000000000',
+ min_deadline_ms: 60000,
+ });
+});
+
+test('preflight is side-effect-free and does not publish a live intent', async () => {
+ const { controller, relay } = buildController();
+ const preflight = await controller.preflight({ amount_eure: '5', slippage_bps: 200 });
+
+ assert.equal(preflight.state, 'draft');
+ assert.equal(preflight.live_submit_capable, true);
+ assert.equal(preflight.reason_code, 'quote_available');
+ assert.equal(relay.quoteCalls, 1);
+ assert.equal(relay.publishCalls, 0);
+});
+
+test('insufficient spendable EURe blocks before solver quote or signing', async () => {
+ const store = buildStore({ inventoryUnits: '0' });
+ const relay = buildRelay();
+ const { controller } = buildController({ store, relay });
+ const preflight = await controller.preflight({ amount_eure: '5', slippage_bps: 200 });
+
+ assert.equal(preflight.state, 'blocked');
+ assert.equal(preflight.reason_code, 'insufficient_spendable_eure');
+ assert.equal(preflight.inventory_snapshot.pending_inbound[EURE.assetId], '100000000000000000000');
+ assert.equal(relay.quoteCalls, 0);
+ assert.equal(relay.publishCalls, 0);
+});
+
+test('duplicate request submit returns stored result and never publishes twice', async () => {
+ const { controller, store, relay } = buildController();
+ const preflight = await controller.preflight({ amount_eure: '5', slippage_bps: 200 });
+ const first = await controller.submit({ request_id: preflight.request_id });
+ const second = await controller.submit({ request_id: preflight.request_id });
+
+ assert.equal(first.submission_result.status, 'accepted_by_relay');
+ assert.equal(second.duplicate, true);
+ assert.equal(relay.publishCalls, 1);
+ assert.equal(store.submissions.filter((entry) => entry.status === 'submit_requested').length, 1);
+ assert.equal(store.submissions.filter((entry) => entry.status === 'accepted_by_relay').length, 1);
+});
+
+test('executor disarmed blocks request submission without calling relay publish', async () => {
+ const { controller, relay } = buildController({ armed: false });
+ const preflight = await controller.preflight({ amount_eure: '5', slippage_bps: 200 });
+ const result = await controller.submit({ request_id: preflight.request_id });
+
+ assert.equal(result.submission_result.status, 'blocked');
+ assert.equal(result.submission_result.result_code, 'executor_disarmed');
+ assert.equal(relay.publishCalls, 0);
+});
+
+
+test('stale reference price blocks request preflight before solver quote', async () => {
+ const store = buildStore({ priceObservedAt: '2026-04-12T09:59:00.000Z' });
+ const relay = buildRelay();
+ const { controller } = buildController({ store, relay });
+ const preflight = await controller.preflight({ amount_eure: '5', slippage_bps: 200 });
+
+ assert.equal(preflight.state, 'blocked');
+ assert.equal(preflight.reason_code, 'stale_reference_price');
+ assert.equal(relay.quoteCalls, 0);
+ assert.equal(relay.publishCalls, 0);
+});
+
+test('unregistered signer blocks request preflight before solver quote or signing', async () => {
+ const relay = buildRelay();
+ const { controller } = buildController({ relay, verifierRegistered: false });
+ const preflight = await controller.preflight({ amount_eure: '5', slippage_bps: 200 });
+
+ assert.equal(preflight.state, 'blocked');
+ assert.equal(preflight.reason_code, 'signer_not_registered');
+ assert.equal(relay.quoteCalls, 0);
+ assert.equal(relay.publishCalls, 0);
+});
+
+test('relay publish failure records submit_requested first and never reports completion', async () => {
+ const relay = buildRelay();
+ relay.publishIntent = async function publishIntent() {
+ this.publishCalls += 1;
+ throw new Error('relay publish unavailable');
+ };
+ const { controller, store } = buildController({ relay });
+ const preflight = await controller.preflight({ amount_eure: '5', slippage_bps: 200 });
+ const result = await controller.submit({ request_id: preflight.request_id });
+
+ assert.equal(result.submission_result.status, 'failed');
+ assert.equal(result.submission_result.result_code, 'publish_intent_failed');
+ assert.equal(result.submission_result.result_text, 'relay publish unavailable');
+ assert.equal(relay.publishCalls, 1);
+ assert.equal(store.submissions[0].status, 'submit_requested');
+ assert.equal(store.submissions[1].status, 'failed');
+ assert.notEqual(result.submission_result.status, 'completed');
+});
diff --git a/test/operator-dashboard.test.mjs b/test/operator-dashboard.test.mjs
index e08a73c..66c5726 100644
--- a/test/operator-dashboard.test.mjs
+++ b/test/operator-dashboard.test.mjs
@@ -117,6 +117,14 @@ test('control routing only resolves the allowlisted safe dashboard actions', ()
service: 'trade-executor',
action: 'resume',
});
+ const requestPreflight = resolveDashboardControl({
+ service: 'trade-executor',
+ action: 'intent-request-preflight',
+ });
+ const requestSubmit = resolveDashboardControl({
+ service: 'trade-executor',
+ action: 'intent-request-submit',
+ });
const risky = resolveDashboardControl({
service: 'strategy-engine',
action: 'arm',
@@ -128,6 +136,10 @@ test('control routing only resolves the allowlisted safe dashboard actions', ()
assert.equal(armExecutor?.label, 'Arm Executor');
assert.equal(resumeExecutor?.path, '/resume');
assert.equal(resumeExecutor?.label, 'Resume Executor Intake');
+ assert.equal(requestPreflight?.path, '/intent-request/preflight');
+ assert.equal(requestPreflight?.risk_class, 'safe');
+ assert.equal(requestSubmit?.path, '/intent-request/submit');
+ assert.equal(requestSubmit?.risk_class, 'live_funds');
assert.equal(risky, null);
});
@@ -1190,3 +1202,81 @@ test('bootstrap lifecycle rows preserve quote terms, submitted terms, and gross
assert.equal(row.submitted_terms.asset_out_symbol, 'EURe');
assert.equal(row.gross_edge_value_eure, '1.5');
});
+
+
+test('own request dashboard rows do not label relay accepted evidence as completed trade', () => {
+ const config = buildConfig();
+ const bootstrap = buildDashboardBootstrap({
+ config,
+ auth: { authenticated: true, subject: 'local-operator', mode: 'stub', roles: ['operator'] },
+ portfolioMetric: null,
+ inventorySnapshot: null,
+ marketPrice: null,
+ recentQuotes: [],
+ submissionPage: { page: 1, page_size: 20, total: 0, total_pages: 1, items: [] },
+ submissionSummary: { total: 0, last_submission_at: null },
+ fundingObservations: [],
+ recentDepositStatuses: [],
+ recentTradeDecisions: [],
+ recentExecuteTradeCommands: [],
+ recentExecutionResults: [],
+ recentQuoteOutcomes: [],
+ recentIntentRequests: [{
+ request_id: 'request-accepted-only',
+ idempotency_key: 'idem-accepted-only',
+ submission_id: 'submission-accepted-only',
+ intent_hash: 'intent-hash-accepted-only',
+ quote_hash: 'quote-hash-accepted-only',
+ created_at: '2026-04-12T10:00:00.000Z',
+ submitted_at: '2026-04-12T10:00:01.000Z',
+ state: 'awaiting_settlement',
+ state_label: 'Awaiting settlement',
+ reason_code: 'accepted_by_relay_without_settlement',
+ reason_text: 'Relay accepted the signed request. This is not settlement.',
+ source_asset_id: config.tradingEure.assetId,
+ source_symbol: 'EURe',
+ source_decimals: 18,
+ destination_asset_id: config.tradingBtc.assetId,
+ destination_symbol: 'BTC',
+ destination_decimals: 8,
+ source_amount_units: '5000000000000000000',
+ expected_destination_amount_units: '10000',
+ min_destination_amount_units: '9800',
+ quoted_destination_amount_units: '10000',
+ slippage_bps: 200,
+ submission_status: 'accepted_by_relay',
+ relay_status: 'PENDING',
+ outcome_status: 'awaiting_settlement',
+ attribution_status: 'unattributed',
+ attribution_method: null,
+ attributed_inventory_delta: null,
+ has_settlement_evidence: false,
+ live_submit_capable: false,
+ lifecycle: {
+ preflight: { state: 'draft' },
+ submission: { status: 'accepted_by_relay' },
+ outcome: { outcome_status: 'awaiting_settlement' },
+ },
+ }],
+ recentAlertTransitions: [],
+ serviceSnapshots: [{
+ service: 'trade-executor',
+ label: 'Trade Executor',
+ base_url: 'http://trade-executor',
+ reachable: true,
+ health: { ok: true },
+ state: { armed: true, paused: false },
+ }],
+ });
+
+ const row = bootstrap.funds.intent_requests.items[0];
+ assert.equal(row.state, 'awaiting_settlement');
+ assert.equal(row.state_label, 'Awaiting settlement');
+ assert.equal(row.submission_status, 'accepted_by_relay');
+ assert.equal(row.has_settlement_evidence, false);
+ assert.equal(row.settlement_summary.text, 'No settled inventory delta is linked to this request.');
+ assert.doesNotMatch(
+ [row.state_label, row.reason_text, row.settlement_summary.text].join(' '),
+ /successful trade|completed trade|asset delta/i,
+ );
+});
diff --git a/test/signing.test.mjs b/test/signing.test.mjs
index b7ddd15..4c3ff52 100644
--- a/test/signing.test.mjs
+++ b/test/signing.test.mjs
@@ -3,7 +3,11 @@ import assert from 'node:assert/strict';
import { KeyPair } from 'near-api-js';
-import { buildIntentNonce, buildQuoteResponseSubmission } from '../src/venues/near-intents/signing.mjs';
+import {
+ buildIntentNonce,
+ buildIntentRequestSubmission,
+ buildQuoteResponseSubmission,
+} from '../src/venues/near-intents/signing.mjs';
test('intent nonce uses verifier salt prefix and 32 byte base64 payload', () => {
const nonce = buildIntentNonce('252812b3');
@@ -42,3 +46,49 @@ test('quote response signing builds token_diff payload for solver submission', (
assert.equal(payload.intents[0].diff['nep141:btc.omft.near'], '5000');
assert.equal(payload.intents[0].diff['nep141:eure.omft.near'], '-4900000000000000000');
});
+
+
+test('request signing builds taker token_diff payload for EURe to BTC submission', () => {
+ const signer = {
+ getPublicKey() {
+ return { toString: () => 'ed25519:test-public-key' };
+ },
+ sign() {
+ return { signature: Uint8Array.from({ length: 64 }, () => 7) };
+ },
+ };
+ const submission = buildIntentRequestSubmission({
+ request: {
+ request_id: 'request-1',
+ source_asset_id: 'nep141:eure.omft.near',
+ destination_asset_id: 'nep141:btc.omft.near',
+ source_amount_units: '5000000000000000000',
+ selected_quote: {
+ quote_hash: 'quote-hash-1',
+ amount_out: '10000',
+ },
+ deadline_at: '2026-04-12T10:01:00.000Z',
+ },
+ signerAccountId: 'solver.near',
+ signer,
+ verifierContract: 'intents.near',
+ currentSaltHex: '252812b3',
+ nonce: 'fixed-nonce',
+ });
+
+ assert.deepEqual(submission.quote_hashes, ['quote-hash-1']);
+ assert.equal(submission.destination_amount_units, '10000');
+ assert.equal(submission.nonce, 'fixed-nonce');
+ assert.equal(submission.signed_data.standard, 'raw_ed25519');
+ assert.equal(submission.signed_data.public_key, 'ed25519:test-public-key');
+ assert.match(submission.signed_data.signature, /^ed25519:/);
+
+ const payload = JSON.parse(submission.signed_data.payload);
+ assert.equal(payload.signer_id, 'solver.near');
+ assert.equal(payload.verifying_contract, 'intents.near');
+ assert.equal(payload.deadline, '2026-04-12T10:01:00.000Z');
+ assert.equal(payload.nonce, 'fixed-nonce');
+ assert.equal(payload.intents[0].intent, 'token_diff');
+ assert.equal(payload.intents[0].diff['nep141:eure.omft.near'], '-5000000000000000000');
+ assert.equal(payload.intents[0].diff['nep141:btc.omft.near'], '10000');
+});