@attocash/cli 0.6.0 → 0.7.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/application/app.d.ts +3 -1
- package/dist/application/app.js +23 -19
- package/dist/application/operations.d.ts +0 -1
- package/dist/application/operations.js +1 -7
- package/dist/cli/cli.js +4 -21
- package/dist/internal-marketplace.d.ts +2 -11
- package/dist/internal-marketplace.js +6 -13
- package/dist/marketplace/approval-preview.js +5 -20
- package/dist/marketplace/connection.d.ts +43 -0
- package/dist/marketplace/{topups.js → connection.js} +18 -213
- package/dist/marketplace/proof-approval.d.ts +1 -1
- package/dist/marketplace/proof-approval.js +10 -119
- package/dist/marketplace/relay.d.ts +58 -0
- package/dist/marketplace/relay.js +122 -0
- package/dist/marketplace/strict-json.d.ts +2 -0
- package/dist/marketplace/strict-json.js +96 -0
- package/dist/spending/atto-x402.d.ts +2 -0
- package/dist/spending/atto-x402.js +1 -1
- package/dist/spending/journal.d.ts +9 -0
- package/dist/spending/journal.js +11 -0
- package/dist/spending/ledger.d.ts +11 -3
- package/dist/spending/ledger.js +42 -7
- package/dist/spending/payments.d.ts +9 -36
- package/dist/spending/payments.js +253 -817
- package/dist/wallet/signing.d.ts +3 -1
- package/dist/wallet/signing.js +25 -17
- package/package.json +1 -1
- package/dist/marketplace/topups.d.ts +0 -82
|
@@ -1,9 +1,8 @@
|
|
|
1
1
|
import { createHash } from 'node:crypto';
|
|
2
2
|
import { derivedSigner } from '../wallet/signing.js';
|
|
3
3
|
import { AttoError } from '../domain/errors.js';
|
|
4
|
-
import { parseAttoExactRequirement } from '../spending/atto-x402.js';
|
|
5
4
|
import { createMarketplaceProofApprovalResponse, inspectMarketplaceProofApproval, } from './proof-approval.js';
|
|
6
|
-
const CONNECTION_KEY = 'marketplace.
|
|
5
|
+
const CONNECTION_KEY = 'marketplace.connection';
|
|
7
6
|
const RESPONSE_BYTES = 65_536;
|
|
8
7
|
const REQUEST_TIMEOUT_MS = 15_000;
|
|
9
8
|
function object(value) {
|
|
@@ -15,36 +14,29 @@ function uuid(value) {
|
|
|
15
14
|
}
|
|
16
15
|
function instant(value) {
|
|
17
16
|
if (typeof value !== 'string')
|
|
18
|
-
throw new AttoError('MARKETPLACE_PROTOCOL', 'Marketplace returned an invalid session
|
|
17
|
+
throw new AttoError('MARKETPLACE_PROTOCOL', 'Marketplace returned an invalid session expiry.');
|
|
19
18
|
const parsed = Date.parse(value);
|
|
20
19
|
if (!Number.isSafeInteger(parsed) || parsed < 0)
|
|
21
|
-
throw new AttoError('MARKETPLACE_PROTOCOL', 'Marketplace returned an invalid session
|
|
20
|
+
throw new AttoError('MARKETPLACE_PROTOCOL', 'Marketplace returned an invalid session expiry.');
|
|
22
21
|
return parsed;
|
|
23
22
|
}
|
|
24
23
|
function safeToken(value) {
|
|
25
24
|
return typeof value === 'string' && value.length >= 16 && value.length <= 8192 && !/[\r\n\0]/.test(value);
|
|
26
25
|
}
|
|
27
|
-
function networkFor(settings) {
|
|
28
|
-
if (settings.network === 'LIVE')
|
|
29
|
-
return 'atto:live';
|
|
30
|
-
if (settings.network === 'LOCAL')
|
|
31
|
-
return 'atto:local';
|
|
32
|
-
throw new AttoError('MARKETPLACE_NETWORK', 'Marketplace top-ups support the configured LIVE or isolated LOCAL ATTO network only.');
|
|
33
|
-
}
|
|
34
26
|
export function validateMarketplaceApiUrl(value, network) {
|
|
35
27
|
let url;
|
|
36
28
|
try {
|
|
37
29
|
url = new URL(value);
|
|
38
30
|
}
|
|
39
31
|
catch {
|
|
40
|
-
throw new AttoError('MARKETPLACE_CONFIGURATION', 'Use the absolute Marketplace /v1/agent/
|
|
32
|
+
throw new AttoError('MARKETPLACE_CONFIGURATION', 'Use the absolute Marketplace /v1/agent/payments URL.');
|
|
41
33
|
}
|
|
42
34
|
const loopback = ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname.toLowerCase());
|
|
43
|
-
if (url.username || url.password || url.search || url.hash || url.pathname.replace(/\/+$/, '') !== '/v1/agent/
|
|
35
|
+
if (url.username || url.password || url.search || url.hash || url.pathname.replace(/\/+$/, '') !== '/v1/agent/payments'
|
|
44
36
|
|| (url.protocol !== 'https:' && !(url.protocol === 'http:' && network === 'LOCAL' && loopback))) {
|
|
45
|
-
throw new AttoError('MARKETPLACE_CONFIGURATION', 'Use an HTTPS Marketplace /v1/agent/
|
|
37
|
+
throw new AttoError('MARKETPLACE_CONFIGURATION', 'Use an HTTPS Marketplace /v1/agent/payments URL; HTTP is allowed only for loopback on an isolated LOCAL wallet.');
|
|
46
38
|
}
|
|
47
|
-
return `${url.origin}/v1/agent/
|
|
39
|
+
return `${url.origin}/v1/agent/payments`;
|
|
48
40
|
}
|
|
49
41
|
function validateBrowserOrigins(value, network) {
|
|
50
42
|
if (!Array.isArray(value) || value.length < 1 || value.length > 8
|
|
@@ -73,10 +65,9 @@ function validateBrowserOrigins(value, network) {
|
|
|
73
65
|
}
|
|
74
66
|
return origins;
|
|
75
67
|
}
|
|
76
|
-
export class
|
|
68
|
+
export class MarketplaceConnectionClient {
|
|
77
69
|
store;
|
|
78
70
|
wallet;
|
|
79
|
-
session;
|
|
80
71
|
constructor(store, wallet) {
|
|
81
72
|
this.store = store;
|
|
82
73
|
this.wallet = wallet;
|
|
@@ -104,7 +95,6 @@ export class MarketplaceTopUpClient {
|
|
|
104
95
|
const session = await this.login(candidate);
|
|
105
96
|
const connection = { ...candidate, accountId: session.accountId, agentId: session.agentId, identityId: session.identityId };
|
|
106
97
|
this.store.set(CONNECTION_KEY, connection);
|
|
107
|
-
this.session = { key: this.sessionKey(connection), value: session };
|
|
108
98
|
return connection;
|
|
109
99
|
}
|
|
110
100
|
connection() {
|
|
@@ -133,7 +123,7 @@ export class MarketplaceTopUpClient {
|
|
|
133
123
|
catch (error) {
|
|
134
124
|
if (error instanceof AttoError)
|
|
135
125
|
throw error;
|
|
136
|
-
throw new AttoError('MARKETPLACE_NOT_CONNECTED', 'Connect this wallet to Marketplace from a local terminal before
|
|
126
|
+
throw new AttoError('MARKETPLACE_NOT_CONNECTED', 'Connect this wallet to Marketplace from a local terminal before approving non-login proofs.');
|
|
137
127
|
}
|
|
138
128
|
}
|
|
139
129
|
inspectProofApproval(input) {
|
|
@@ -167,109 +157,9 @@ export class MarketplaceTopUpClient {
|
|
|
167
157
|
seed.value.fill(0);
|
|
168
158
|
}
|
|
169
159
|
}
|
|
170
|
-
async challenge(connection, paymentIdentifier, amountRaw) {
|
|
171
|
-
if (!/^[A-Za-z0-9_-]{16,128}$/.test(paymentIdentifier) || !/^[1-9]\d*$/.test(amountRaw)) {
|
|
172
|
-
throw new AttoError('INVALID_INPUT', 'Marketplace top-ups require a positive RAW amount and a 16-128 character payment identifier.');
|
|
173
|
-
}
|
|
174
|
-
const network = networkFor(this.wallet.settings());
|
|
175
|
-
const session = await this.authorize(connection);
|
|
176
|
-
const response = await this.fetchJson(connection.apiUrl, connection.apiUrl, 'POST', session.accessToken, {
|
|
177
|
-
asset: 'ATTO', amountAtomic: amountRaw, paymentIdentifier,
|
|
178
|
-
});
|
|
179
|
-
const status = parseTopUpStatus(response.json);
|
|
180
|
-
this.assertStatusBinding(status, paymentIdentifier, amountRaw, network);
|
|
181
|
-
if (response.status !== 402)
|
|
182
|
-
return { status };
|
|
183
|
-
const requirementHeader = response.headers.get('payment-required');
|
|
184
|
-
if (!requirementHeader)
|
|
185
|
-
throw new AttoError('MARKETPLACE_PROTOCOL', 'Marketplace omitted the required ATTO payment challenge.');
|
|
186
|
-
const requirement = parseAttoExactRequirement({ header: requirementHeader, apiUrl: connection.apiUrl,
|
|
187
|
-
intentId: status.intentId, network, amountRaw });
|
|
188
|
-
return { status, challenge: { status, requirementHeader, requirement } };
|
|
189
|
-
}
|
|
190
|
-
async pay(connection, status, paymentIdentifier, paymentHeader, expected, beforeSubmit) {
|
|
191
|
-
const session = await this.authorize(connection);
|
|
192
|
-
const url = `${connection.apiUrl}/${status.intentId}`;
|
|
193
|
-
await beforeSubmit();
|
|
194
|
-
const response = await this.fetchJson(connection.apiUrl, url, 'POST', session.accessToken, undefined, { 'PAYMENT-SIGNATURE': paymentHeader });
|
|
195
|
-
const updated = parseTopUpStatus(response.json);
|
|
196
|
-
this.assertStatusBinding(updated, paymentIdentifier, status.amountAtomic, expected.network, {
|
|
197
|
-
intentId: status.intentId, hash: expected.hash, payer: expected.payer, requirePayment: true,
|
|
198
|
-
});
|
|
199
|
-
if (![200, 202, 409].includes(response.status))
|
|
200
|
-
throw this.httpFailure(response.status);
|
|
201
|
-
const paymentResponse = response.headers.get('payment-response');
|
|
202
|
-
if (paymentResponse === null) {
|
|
203
|
-
if (response.status === 202 && updated.state === 'PENDING' && updated.paymentState === 'PENDING')
|
|
204
|
-
return updated;
|
|
205
|
-
throw new AttoError('MARKETPLACE_PROTOCOL', 'Marketplace omitted the payment receipt without an exact pending payment status.');
|
|
206
|
-
}
|
|
207
|
-
const receipt = this.decodeObject(paymentResponse);
|
|
208
|
-
const paymentApplied = updated.state === 'ACCEPTED' || updated.state === 'SETTLED';
|
|
209
|
-
const pending = updated.state === 'PENDING';
|
|
210
|
-
const rejected = updated.state === 'REJECTED';
|
|
211
|
-
const responseMatchesState = (response.status === 200 && paymentApplied)
|
|
212
|
-
|| (response.status === 202 && pending) || (response.status === 409 && rejected);
|
|
213
|
-
if (!responseMatchesState || receipt.success !== paymentApplied || typeof receipt.transaction !== 'string'
|
|
214
|
-
|| receipt.transaction.toUpperCase() !== expected.hash.toUpperCase()
|
|
215
|
-
|| receipt.network !== expected.network || receipt.payer !== expected.payer
|
|
216
|
-
|| updated.sendHash?.toUpperCase() !== receipt.transaction.toUpperCase() || updated.payer !== receipt.payer
|
|
217
|
-
|| (receipt.errorReason !== undefined && typeof receipt.errorReason !== 'string')) {
|
|
218
|
-
throw new AttoError('MARKETPLACE_PROTOCOL', 'Marketplace returned a receipt for a different ATTO payment.');
|
|
219
|
-
}
|
|
220
|
-
return updated;
|
|
221
|
-
}
|
|
222
|
-
async status(connection, intentId, paymentIdentifier, amountRaw, network, expected) {
|
|
223
|
-
const session = await this.authorize(connection);
|
|
224
|
-
if (!uuid(intentId))
|
|
225
|
-
throw new AttoError('MARKETPLACE_PROTOCOL', 'The saved Marketplace intent ID is invalid.');
|
|
226
|
-
const response = await this.fetchJson(connection.apiUrl, `${connection.apiUrl}/${intentId}`, 'GET', session.accessToken);
|
|
227
|
-
if (response.status !== 200)
|
|
228
|
-
throw this.httpFailure(response.status);
|
|
229
|
-
const status = parseTopUpStatus(response.json);
|
|
230
|
-
this.assertStatusBinding(status, paymentIdentifier, amountRaw, network, {
|
|
231
|
-
intentId, hash: expected?.hash, payer: expected?.payer,
|
|
232
|
-
});
|
|
233
|
-
return status;
|
|
234
|
-
}
|
|
235
|
-
async authorize(connection) {
|
|
236
|
-
const key = this.sessionKey(connection);
|
|
237
|
-
const cached = this.session?.key === key ? this.session.value : undefined;
|
|
238
|
-
if (cached && cached.accessExpiresAt > Date.now() + 30_000)
|
|
239
|
-
return cached;
|
|
240
|
-
if (cached && cached.refreshExpiresAt > Date.now() + 30_000) {
|
|
241
|
-
try {
|
|
242
|
-
const response = await this.fetchJson(connection.apiUrl, this.authUrl(connection.apiUrl, 'sessions/refresh'), 'POST', undefined, { refreshToken: cached.refreshToken });
|
|
243
|
-
if (response.status !== 200)
|
|
244
|
-
throw this.httpFailure(response.status);
|
|
245
|
-
const refresh = object(response.json);
|
|
246
|
-
if (!refresh || !safeToken(refresh.accessToken) || !safeToken(refresh.refreshToken))
|
|
247
|
-
throw new Error();
|
|
248
|
-
const value = { ...cached, accessToken: refresh.accessToken,
|
|
249
|
-
accessExpiresAt: instant(refresh.accessExpiresAt), refreshToken: refresh.refreshToken,
|
|
250
|
-
refreshExpiresAt: instant(refresh.refreshExpiresAt) };
|
|
251
|
-
if (value.accessExpiresAt <= Date.now() || value.refreshExpiresAt < value.accessExpiresAt)
|
|
252
|
-
throw new Error();
|
|
253
|
-
this.session = { key, value };
|
|
254
|
-
return value;
|
|
255
|
-
}
|
|
256
|
-
catch (error) {
|
|
257
|
-
if (!(error instanceof AttoError) || error.code !== 'MARKETPLACE_HTTP'
|
|
258
|
-
|| ![400, 401, 403].includes(error.details?.httpStatus ?? 0))
|
|
259
|
-
throw error;
|
|
260
|
-
// A rejected rotating refresh token falls back to a new wallet proof.
|
|
261
|
-
}
|
|
262
|
-
}
|
|
263
|
-
const value = await this.login(connection);
|
|
264
|
-
if (value.accountId !== connection.accountId || value.agentId !== connection.agentId || value.identityId !== connection.identityId) {
|
|
265
|
-
throw new AttoError('MARKETPLACE_IDENTITY_CHANGED', 'Marketplace authenticated a different account or controller. Reconnect from a local terminal.');
|
|
266
|
-
}
|
|
267
|
-
this.session = { key, value };
|
|
268
|
-
return value;
|
|
269
|
-
}
|
|
270
160
|
async login(connection) {
|
|
271
161
|
const networkForAddress = 'ATTO';
|
|
272
|
-
const response = await this.
|
|
162
|
+
const response = await this.postAuth(connection.apiUrl, 'challenges', { network: networkForAddress, address: connection.controllerAddress });
|
|
273
163
|
if (response.status !== 200)
|
|
274
164
|
throw this.httpFailure(response.status);
|
|
275
165
|
const challenge = parseProofChallenge(response.json, connection);
|
|
@@ -285,7 +175,7 @@ export class MarketplaceTopUpClient {
|
|
|
285
175
|
finally {
|
|
286
176
|
seed.value.fill(0);
|
|
287
177
|
}
|
|
288
|
-
const sessionResponse = await this.
|
|
178
|
+
const sessionResponse = await this.postAuth(connection.apiUrl, 'sessions', { challengeId: challenge.challengeId, message: challenge.message, signature });
|
|
289
179
|
if (sessionResponse.status !== 200)
|
|
290
180
|
throw this.httpFailure(sessionResponse.status);
|
|
291
181
|
const value = parseSession(sessionResponse.json);
|
|
@@ -297,40 +187,17 @@ export class MarketplaceTopUpClient {
|
|
|
297
187
|
}
|
|
298
188
|
return value;
|
|
299
189
|
}
|
|
300
|
-
|
|
301
|
-
const api = new URL(apiUrl);
|
|
302
|
-
return `${api.origin}/v1/agent/auth/${suffix}`;
|
|
303
|
-
}
|
|
304
|
-
async fetchJson(apiUrl, urlValue, method, accessToken, body, extraHeaders = {}) {
|
|
190
|
+
async postAuth(apiUrl, action, body) {
|
|
305
191
|
const api = new URL(apiUrl);
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
url = new URL(urlValue);
|
|
309
|
-
}
|
|
310
|
-
catch {
|
|
311
|
-
throw new AttoError('MARKETPLACE_RESOURCE_MISMATCH', 'Marketplace request URL is invalid.');
|
|
312
|
-
}
|
|
313
|
-
const topupsPath = api.pathname;
|
|
314
|
-
const agentPath = topupsPath.replace(/\/topups$/, '');
|
|
315
|
-
const allowed = new Set([topupsPath, `${agentPath}/auth/challenges`, `${agentPath}/auth/sessions`,
|
|
316
|
-
`${agentPath}/auth/sessions/refresh`]);
|
|
317
|
-
const intentPath = new RegExp(`^${topupsPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$`);
|
|
318
|
-
if (url.origin !== api.origin || url.username || url.password || url.search || url.hash
|
|
319
|
-
|| (!allowed.has(url.pathname) && !intentPath.test(url.pathname))) {
|
|
320
|
-
throw new AttoError('MARKETPLACE_RESOURCE_MISMATCH', 'Marketplace request escaped the configured HTTPS origin.');
|
|
321
|
-
}
|
|
322
|
-
const headers = { accept: 'application/json', ...extraHeaders };
|
|
323
|
-
if (accessToken)
|
|
324
|
-
headers.authorization = `Bearer ${accessToken}`;
|
|
325
|
-
if (body)
|
|
326
|
-
headers['content-type'] = 'application/json';
|
|
192
|
+
const url = new URL(`/v1/agent/auth/${action}`, api.origin);
|
|
193
|
+
const headers = { accept: 'application/json', 'content-type': 'application/json' };
|
|
327
194
|
let response;
|
|
328
195
|
try {
|
|
329
|
-
response = await fetch(url, { method, headers,
|
|
196
|
+
response = await fetch(url, { method: 'POST', headers, body: JSON.stringify(body),
|
|
330
197
|
redirect: 'error', signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS) });
|
|
331
198
|
}
|
|
332
199
|
catch {
|
|
333
|
-
throw new AttoError('MARKETPLACE_UNAVAILABLE', 'The configured Marketplace endpoint could not be reached.
|
|
200
|
+
throw new AttoError('MARKETPLACE_UNAVAILABLE', 'The configured Marketplace authentication endpoint could not be reached. Retry connection from the local terminal.');
|
|
334
201
|
}
|
|
335
202
|
if (response.url && new URL(response.url).origin !== api.origin) {
|
|
336
203
|
await response.body?.cancel();
|
|
@@ -359,52 +226,8 @@ export class MarketplaceTopUpClient {
|
|
|
359
226
|
}
|
|
360
227
|
return { status: response.status, headers: response.headers, json };
|
|
361
228
|
}
|
|
362
|
-
decodeObject(header) {
|
|
363
|
-
if (header.length < 1 || header.length > 90_000 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(header)) {
|
|
364
|
-
throw new AttoError('MARKETPLACE_PROTOCOL', 'Marketplace returned an invalid payment receipt.');
|
|
365
|
-
}
|
|
366
|
-
const bytes = Buffer.from(header, 'base64');
|
|
367
|
-
if (bytes.toString('base64') !== header || bytes.length < 1 || bytes.length > RESPONSE_BYTES) {
|
|
368
|
-
throw new AttoError('MARKETPLACE_PROTOCOL', 'Marketplace returned an invalid payment receipt.');
|
|
369
|
-
}
|
|
370
|
-
let value;
|
|
371
|
-
try {
|
|
372
|
-
value = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
|
|
373
|
-
}
|
|
374
|
-
catch {
|
|
375
|
-
throw new AttoError('MARKETPLACE_PROTOCOL', 'Marketplace returned an invalid payment receipt.');
|
|
376
|
-
}
|
|
377
|
-
const result = object(value);
|
|
378
|
-
if (!result)
|
|
379
|
-
throw new AttoError('MARKETPLACE_PROTOCOL', 'Marketplace returned an invalid payment receipt.');
|
|
380
|
-
return result;
|
|
381
|
-
}
|
|
382
|
-
assertStatusBinding(status, paymentIdentifier, amountRaw, network, expected) {
|
|
383
|
-
const terminal = status.state === 'ACCEPTED' || status.state === 'SETTLED';
|
|
384
|
-
if (status.asset !== 'ATTO' || status.network !== network || status.amountAtomic !== amountRaw
|
|
385
|
-
|| !uuid(status.intentId) || !/^[1-9]\d*$/.test(status.amountAtomic)
|
|
386
|
-
|| !paymentIdentifier || instant(status.expiresAt) < 0
|
|
387
|
-
|| (expected?.intentId !== undefined && status.intentId !== expected.intentId)
|
|
388
|
-
|| (expected?.hash !== undefined && status.sendHash !== null
|
|
389
|
-
&& status.sendHash.toUpperCase() !== expected.hash.toUpperCase())
|
|
390
|
-
|| (expected?.payer !== undefined && status.payer !== null && status.payer !== expected.payer)
|
|
391
|
-
|| (expected && !expected.hash && (status.sendHash !== null || status.payer !== null))
|
|
392
|
-
|| (expected && terminal && (!expected.hash || !expected.payer
|
|
393
|
-
|| status.sendHash?.toUpperCase() !== expected.hash.toUpperCase() || status.payer !== expected.payer))
|
|
394
|
-
|| (expected && status.paymentState !== null && (!expected.hash || !expected.payer
|
|
395
|
-
|| status.sendHash?.toUpperCase() !== expected.hash.toUpperCase() || status.payer !== expected.payer))
|
|
396
|
-
|| (expected?.requirePayment && (!expected.hash || !expected.payer
|
|
397
|
-
|| status.paymentState === null
|
|
398
|
-
|| status.sendHash?.toUpperCase() !== expected.hash.toUpperCase() || status.payer !== expected.payer))) {
|
|
399
|
-
throw new AttoError('MARKETPLACE_PROTOCOL', 'Marketplace returned a top-up status for a different payment.');
|
|
400
|
-
}
|
|
401
|
-
}
|
|
402
229
|
httpFailure(status) {
|
|
403
|
-
return new AttoError('MARKETPLACE_HTTP', `Marketplace returned HTTP ${status}.
|
|
404
|
-
}
|
|
405
|
-
sessionKey(connection) {
|
|
406
|
-
return JSON.stringify([connection.apiUrl, connection.audience, connection.controllerAddress,
|
|
407
|
-
connection.accountId ?? null, connection.agentId ?? null, connection.identityId ?? null]);
|
|
230
|
+
return new AttoError('MARKETPLACE_HTTP', `Marketplace returned HTTP ${status}. Review the connection and retry from the local terminal.`, { httpStatus: status });
|
|
408
231
|
}
|
|
409
232
|
}
|
|
410
233
|
async function readBounded(response, maxBytes) {
|
|
@@ -430,24 +253,6 @@ async function readBounded(response, maxBytes) {
|
|
|
430
253
|
reader.releaseLock();
|
|
431
254
|
}
|
|
432
255
|
}
|
|
433
|
-
function parseTopUpStatus(input) {
|
|
434
|
-
const value = object(input);
|
|
435
|
-
const states = ['PENDING', 'ACCEPTED', 'SETTLED', 'REJECTED'];
|
|
436
|
-
const paymentStates = ['PENDING', 'ACCEPTED', 'SETTLED', 'REJECTED'];
|
|
437
|
-
if (!value || !uuid(value.intentId) || typeof value.asset !== 'string' || typeof value.network !== 'string'
|
|
438
|
-
|| typeof value.amountAtomic !== 'string' || !states.includes(String(value.state))
|
|
439
|
-
|| typeof value.expiresAt !== 'string'
|
|
440
|
-
|| (value.sendHash !== null && typeof value.sendHash !== 'string')
|
|
441
|
-
|| (value.payer !== null && typeof value.payer !== 'string')
|
|
442
|
-
|| (value.paymentState !== null && !paymentStates.includes(String(value.paymentState)))
|
|
443
|
-
|| (value.receivePending !== null && typeof value.receivePending !== 'boolean')
|
|
444
|
-
|| (value.discrepancy !== null && typeof value.discrepancy !== 'string')
|
|
445
|
-
|| !(value.receiveStatus === null || ['PENDING', 'ACCEPTED', 'SETTLED', 'REJECTED'].includes(String(value.receiveStatus)))) {
|
|
446
|
-
throw new AttoError('MARKETPLACE_PROTOCOL', 'Marketplace returned an invalid top-up status.');
|
|
447
|
-
}
|
|
448
|
-
instant(value.expiresAt);
|
|
449
|
-
return value;
|
|
450
|
-
}
|
|
451
256
|
function parseProofChallenge(input, connection) {
|
|
452
257
|
const value = object(input);
|
|
453
258
|
if (!value || !uuid(value.challengeId) || !uuid(value.accountId) || !uuid(value.controllerId) || typeof value.message !== 'string'
|
|
@@ -456,7 +261,7 @@ function parseProofChallenge(input, connection) {
|
|
|
456
261
|
}
|
|
457
262
|
const match = /^Marketplace Agent Controller Proof v1\nAudience: ([^\n]+)\nNetwork: live\nAddress: (atto:\/\/[a-z2-7]{61})\nPurpose: login\nRequest ID: ([0-9a-f-]{36})\nBinding Hash: ([0-9a-f]{64})\nNonce: ([0-9a-f]{64})\nIssued At: ([^\n]+)\nExpiration Time: ([^\n]+)$/.exec(value.message);
|
|
458
263
|
if (!match || match[1] !== connection.audience || match[2] !== connection.controllerAddress
|
|
459
|
-
|| match[3] !== value.challengeId || match[4] !== createHash('sha256').update(['
|
|
264
|
+
|| match[3] !== value.challengeId || match[4] !== createHash('sha256').update(['marketplace-login-v1', value.accountId, value.controllerId].join('\n'), 'utf8').digest('hex')
|
|
460
265
|
|| match[6] !== value.issuedAt || match[7] !== value.expiresAt
|
|
461
266
|
|| (connection.accountId !== undefined && value.accountId !== connection.accountId)
|
|
462
267
|
|| (connection.identityId !== undefined && value.controllerId !== connection.identityId)) {
|
|
@@ -3,18 +3,13 @@ import { AttoError } from '../domain/errors.js';
|
|
|
3
3
|
const PURPOSES = new Set([
|
|
4
4
|
'login', 'API-key creation', 'API-key rotation', 'API-key revocation',
|
|
5
5
|
'link authorizer', 'link new identity', 'unlink',
|
|
6
|
-
'
|
|
7
|
-
'
|
|
8
|
-
'administrator dispute opening', 'administrator dispute resolution', 'product purchase', 'product refund',
|
|
6
|
+
'administrator public moderation', 'administrator task cancellation or expiry',
|
|
7
|
+
'administrator dispute opening', 'administrator dispute resolution',
|
|
9
8
|
]);
|
|
10
9
|
const SCOPES = new Set([
|
|
11
10
|
'tasks:read', 'applications:read', 'applications:apply', 'applications:withdraw',
|
|
12
11
|
'tasks:draft:write', 'tasks:publish', 'submissions:write', 'submissions:read',
|
|
13
|
-
'activity:read', 'activity:write', '
|
|
14
|
-
'files:read', 'files:write', 'products:read', 'products:write', 'products:publish', 'products:purchase',
|
|
15
|
-
'purchases:read', 'purchases:refund',
|
|
16
|
-
]);
|
|
17
|
-
const SHOP_SCOPES = new Set([
|
|
12
|
+
'activity:read', 'activity:write', 'payments:read', 'payments:write',
|
|
18
13
|
'files:read', 'files:write', 'products:read', 'products:write', 'products:publish', 'products:purchase',
|
|
19
14
|
'purchases:read', 'purchases:refund',
|
|
20
15
|
]);
|
|
@@ -22,10 +17,9 @@ const SHOP_SCOPES = new Set([
|
|
|
22
17
|
export function validateMarketplaceUserProofApproval(input, options) {
|
|
23
18
|
const request = parseRequest(input, options.network);
|
|
24
19
|
const purposes = new Set(['login', 'API-key creation', 'API-key rotation', 'API-key revocation',
|
|
25
|
-
'link authorizer', 'link new identity', 'unlink'
|
|
26
|
-
'payout address disablement', 'withdrawal creation', 'product purchase', 'product refund']);
|
|
20
|
+
'link authorizer', 'link new identity', 'unlink']);
|
|
27
21
|
const atto = options.network === 'ATTO';
|
|
28
|
-
if (!purposes.has(request.purpose)
|
|
22
|
+
if (!purposes.has(request.purpose)
|
|
29
23
|
|| request.controller.network !== options.network || !Number.isSafeInteger(request.controller.index)
|
|
30
24
|
|| request.controller.index < 0 || request.controller.index > (atto ? 0x7fff_ffff : 0xffff_ffff)
|
|
31
25
|
|| !(atto ? /^atto:\/\/[a-z2-7]{61}$/.test(request.controller.address)
|
|
@@ -207,14 +201,10 @@ function expectedPurpose(action) {
|
|
|
207
201
|
: action.operation === 'NEW_IDENTITY' ? 'link new identity' : '';
|
|
208
202
|
case 'identity-unlink': return 'unlink';
|
|
209
203
|
case 'credential': return { CREATE: 'API-key creation', ROTATE: 'API-key rotation', REVOKE: 'API-key revocation' }[String(action.operation)] ?? '';
|
|
210
|
-
case 'payout-address': return { ENROLL: 'payout address enrollment', SELECT: 'payout address selection', DISABLE: 'payout address disablement' }[String(record(action.command).action)] ?? '';
|
|
211
|
-
case 'withdrawal': return 'withdrawal creation';
|
|
212
204
|
case 'adminModeration': return 'administrator public moderation';
|
|
213
205
|
case 'adminTaskClose': return 'administrator task cancellation or expiry';
|
|
214
206
|
case 'adminDisputeOpen': return 'administrator dispute opening';
|
|
215
207
|
case 'adminDisputeResolution': return 'administrator dispute resolution';
|
|
216
|
-
case 'productPurchase': return 'product purchase';
|
|
217
|
-
case 'productRefund': return 'product refund';
|
|
218
208
|
default: return '';
|
|
219
209
|
}
|
|
220
210
|
}
|
|
@@ -234,15 +224,7 @@ function validActionKeys(action) {
|
|
|
234
224
|
if (command.credential === undefined)
|
|
235
225
|
return true;
|
|
236
226
|
return onlyKeys(record(command.credential), ['name', 'expiresInDays', 'scopes', 'publishAttoLimit', 'publishXnoLimit',
|
|
237
|
-
'
|
|
238
|
-
}
|
|
239
|
-
if (action.kind === 'payout-address') {
|
|
240
|
-
return onlyKeys(action, ['kind', 'command', 'network', 'canonicalTargetAddress'])
|
|
241
|
-
&& onlyKeys(record(action.command), ['action', 'asset', 'idempotencyKey', 'address', 'destinationId', 'expectedSelectionVersion', 'network']);
|
|
242
|
-
}
|
|
243
|
-
if (action.kind === 'withdrawal') {
|
|
244
|
-
return onlyKeys(action, ['kind', 'command', 'network', 'destinationAddress'])
|
|
245
|
-
&& onlyKeys(record(action.command), ['asset', 'atomicAmount', 'destinationId', 'expectedSelectionVersion', 'idempotencyKey', 'network']);
|
|
227
|
+
'purchaseAttoLimit', 'purchaseXnoLimit', 'productPublishAttoLimit', 'productPublishXnoLimit']);
|
|
246
228
|
}
|
|
247
229
|
if (action.kind === 'adminModeration')
|
|
248
230
|
return onlyKeys(action, ['kind', 'targetKind', 'action', 'targetId', 'expectedTargetVersion', 'expectedModerationVersion', 'reason', 'idempotencyKey']);
|
|
@@ -252,11 +234,6 @@ function validActionKeys(action) {
|
|
|
252
234
|
return onlyKeys(action, ['kind', 'taskId', 'expectedEngagementVersion', 'representedAgentId', 'reason', 'statement', 'evidenceUrls', 'auditReason', 'idempotencyKey']);
|
|
253
235
|
if (action.kind === 'adminDisputeResolution')
|
|
254
236
|
return onlyKeys(action, ['kind', 'disputeId', 'expectedDisputeVersion', 'outcome', 'rationale', 'idempotencyKey']);
|
|
255
|
-
if (action.kind === 'productPurchase')
|
|
256
|
-
return hasExactKeys(action, ['kind', 'releaseId', 'expectedReleaseHash', 'sellerAgentId', 'asset', 'grossAtomic', 'feeAtomic', 'netAtomic', 'idempotencyKey']);
|
|
257
|
-
if (action.kind === 'productRefund')
|
|
258
|
-
return hasExactKeys(action, ['kind', 'purchaseId', 'expectedPurchaseVersion', 'authority', 'buyerAgentId', 'sellerAgentId', 'asset', 'grossAtomic',
|
|
259
|
-
'feeAtomic', 'netAtomic', 'originalPurchaseReceiptHash', 'idempotencyKey']);
|
|
260
237
|
return false;
|
|
261
238
|
}
|
|
262
239
|
function bindingHash(request) {
|
|
@@ -265,35 +242,10 @@ function bindingHash(request) {
|
|
|
265
242
|
if (action.network !== request.controller.network || action.address !== request.controller.address
|
|
266
243
|
|| !uuid(request.accountId) || !uuid(request.identityId))
|
|
267
244
|
throw protocolFailure();
|
|
268
|
-
return sha256(['
|
|
245
|
+
return sha256(['marketplace-login-v1', request.accountId, request.identityId].join('\n'));
|
|
269
246
|
}
|
|
270
247
|
if (!request.accountId || !request.identityId)
|
|
271
248
|
throw protocolFailure();
|
|
272
|
-
if (action.kind === 'productPurchase') {
|
|
273
|
-
const releaseId = uuid(action.releaseId);
|
|
274
|
-
const sellerAgentId = uuid(action.sellerAgentId);
|
|
275
|
-
const key = uuid(action.idempotencyKey);
|
|
276
|
-
if (!releaseId || !sellerAgentId || !isSha256Hex(action.expectedReleaseHash) || !isAsset(action.asset)
|
|
277
|
-
|| !validProductAtomicTerms(action.grossAtomic, action.feeAtomic, action.netAtomic) || !key)
|
|
278
|
-
throw protocolFailure();
|
|
279
|
-
return lengthPrefixedSha256(['marketplace-product-purchase-approval-v1', request.accountId, request.identityId,
|
|
280
|
-
releaseId, action.expectedReleaseHash, action.asset, action.grossAtomic, key]);
|
|
281
|
-
}
|
|
282
|
-
if (action.kind === 'productRefund') {
|
|
283
|
-
const purchaseId = uuid(action.purchaseId);
|
|
284
|
-
const version = safeVersion(action.expectedPurchaseVersion);
|
|
285
|
-
const buyerAgentId = uuid(action.buyerAgentId);
|
|
286
|
-
const sellerAgentId = uuid(action.sellerAgentId);
|
|
287
|
-
const key = uuid(action.idempotencyKey);
|
|
288
|
-
if (!purchaseId || version === undefined || (action.authority !== 'SELLER' && action.authority !== 'ADMIN')
|
|
289
|
-
|| !buyerAgentId || !sellerAgentId || !isAsset(action.asset)
|
|
290
|
-
|| !validProductAtomicTerms(action.grossAtomic, action.feeAtomic, action.netAtomic)
|
|
291
|
-
|| !isSha256Hex(action.originalPurchaseReceiptHash) || !key)
|
|
292
|
-
throw protocolFailure();
|
|
293
|
-
return lengthPrefixedSha256(['marketplace-product-refund-approval-v1', action.authority, request.accountId,
|
|
294
|
-
request.identityId, purchaseId, action.originalPurchaseReceiptHash, String(version), action.asset,
|
|
295
|
-
action.grossAtomic, key]);
|
|
296
|
-
}
|
|
297
249
|
if (action.kind === 'identity-link') {
|
|
298
250
|
const operation = action.operation;
|
|
299
251
|
const linkId = uuid(action.linkId);
|
|
@@ -340,64 +292,20 @@ function bindingHash(request) {
|
|
|
340
292
|
throw protocolFailure();
|
|
341
293
|
const publishAttoLimit = atomicOrEmpty(credential.publishAttoLimit);
|
|
342
294
|
const publishXnoLimit = atomicOrEmpty(credential.publishXnoLimit);
|
|
343
|
-
const applyAttoLimit = atomicOrEmpty(credential.applyAttoLimit);
|
|
344
|
-
const applyXnoLimit = atomicOrEmpty(credential.applyXnoLimit);
|
|
345
295
|
const purchaseAttoLimit = atomicOrEmpty(credential.purchaseAttoLimit);
|
|
346
296
|
const purchaseXnoLimit = atomicOrEmpty(credential.purchaseXnoLimit);
|
|
347
297
|
const productPublishAttoLimit = atomicOrEmpty(credential.productPublishAttoLimit);
|
|
348
298
|
const productPublishXnoLimit = atomicOrEmpty(credential.productPublishXnoLimit);
|
|
349
299
|
if ((scopes.includes('tasks:publish')) !== Boolean(publishAttoLimit || publishXnoLimit)
|
|
350
|
-
|| (scopes.includes('applications:apply')) !== Boolean(applyAttoLimit || applyXnoLimit)
|
|
351
300
|
|| (scopes.includes('products:purchase')) !== Boolean(purchaseAttoLimit || purchaseXnoLimit)
|
|
352
301
|
|| (Boolean(productPublishAttoLimit || productPublishXnoLimit) && !scopes.includes('products:publish')))
|
|
353
302
|
throw protocolFailure();
|
|
354
|
-
|
|
355
|
-
|
|
356
|
-
? ['agent-credential-v4', ...orderedFields, applyXnoLimit, purchaseAttoLimit, purchaseXnoLimit,
|
|
357
|
-
productPublishAttoLimit, productPublishXnoLimit].join('\n')
|
|
358
|
-
: scopes.some(scope => SHOP_SCOPES.has(scope))
|
|
359
|
-
? ['agent-credential-v3', ...orderedFields, applyXnoLimit, purchaseAttoLimit, purchaseXnoLimit].join('\n')
|
|
360
|
-
: ['agent-credential-v2', ...orderedFields, applyXnoLimit].join('\n');
|
|
303
|
+
payload = ['marketplace-credential-v1', name, String(expiresInDays), [...scopes].sort().join(','), publishAttoLimit, publishXnoLimit,
|
|
304
|
+
purchaseAttoLimit, purchaseXnoLimit, productPublishAttoLimit, productPublishXnoLimit].join('\n');
|
|
361
305
|
}
|
|
362
306
|
return sha256(['agent-credential-v1', request.accountId, request.identityId, operation,
|
|
363
307
|
target || '', key, payload].join('\n'));
|
|
364
308
|
}
|
|
365
|
-
if (action.kind === 'payout-address') {
|
|
366
|
-
const command = record(action.command);
|
|
367
|
-
const actionName = String(command.action);
|
|
368
|
-
const asset = String(command.asset);
|
|
369
|
-
const key = uuid(command.idempotencyKey);
|
|
370
|
-
const destinationId = command.destinationId === undefined ? '' : uuid(command.destinationId);
|
|
371
|
-
const version = command.expectedSelectionVersion;
|
|
372
|
-
const network = action.network;
|
|
373
|
-
const address = action.canonicalTargetAddress;
|
|
374
|
-
if (!['ENROLL', 'SELECT', 'DISABLE'].includes(actionName) || !['ATTO', 'XNO'].includes(asset) || !key
|
|
375
|
-
|| destinationId === false || typeof network !== 'string' || typeof address !== 'string' || !address
|
|
376
|
-
|| (command.network !== undefined && command.network !== network)
|
|
377
|
-
|| !(version === undefined || (typeof version === 'number' && Number.isSafeInteger(version) && version >= 0))
|
|
378
|
-
|| (actionName === 'ENROLL') !== (typeof command.address === 'string')
|
|
379
|
-
|| (actionName === 'ENROLL') !== (destinationId === ''))
|
|
380
|
-
throw protocolFailure();
|
|
381
|
-
return sha256(['payout-address-v1', request.accountId, request.identityId, actionName, asset,
|
|
382
|
-
network, destinationId || '', address, version === undefined ? '' : String(version), key].join('\n'));
|
|
383
|
-
}
|
|
384
|
-
if (action.kind === 'withdrawal') {
|
|
385
|
-
const command = record(action.command);
|
|
386
|
-
const asset = String(command.asset);
|
|
387
|
-
const amount = command.atomicAmount;
|
|
388
|
-
const destinationId = uuid(command.destinationId);
|
|
389
|
-
const key = uuid(command.idempotencyKey);
|
|
390
|
-
const version = command.expectedSelectionVersion;
|
|
391
|
-
const network = action.network;
|
|
392
|
-
const address = action.destinationAddress;
|
|
393
|
-
if (!['ATTO', 'XNO'].includes(asset) || typeof amount !== 'string' || !/^[1-9][0-9]{0,64}$/.test(amount)
|
|
394
|
-
|| !destinationId || !key || typeof version !== 'number' || !Number.isSafeInteger(version) || version < 0
|
|
395
|
-
|| typeof network !== 'string' || typeof address !== 'string' || !address
|
|
396
|
-
|| (command.network !== undefined && command.network !== network))
|
|
397
|
-
throw protocolFailure();
|
|
398
|
-
return sha256(['withdrawal-create-v2', request.accountId, request.identityId, asset, amount,
|
|
399
|
-
network, destinationId, address, String(version), key].join('\n'));
|
|
400
|
-
}
|
|
401
309
|
if (action.kind === 'adminModeration') {
|
|
402
310
|
const targetKind = action.targetKind;
|
|
403
311
|
const operation = action.action;
|
|
@@ -450,7 +358,7 @@ function bindingHash(request) {
|
|
|
450
358
|
const outcome = action.outcome;
|
|
451
359
|
const rationale = boundedDisputeText(action.rationale);
|
|
452
360
|
const key = uuid(action.idempotencyKey);
|
|
453
|
-
if (!disputeId || version === undefined || (outcome !== '
|
|
361
|
+
if (!disputeId || version === undefined || (outcome !== 'WORKER_SUPPORTED' && outcome !== 'BUYER_SUPPORTED')
|
|
454
362
|
|| rationale === undefined || !key)
|
|
455
363
|
throw protocolFailure();
|
|
456
364
|
return lengthPrefixedSha256(['dispute-admin-resolve-v1', request.accountId, request.identityId,
|
|
@@ -466,23 +374,6 @@ function browserOriginAllowed(connection, proofOrigin) {
|
|
|
466
374
|
function safeVersion(value) {
|
|
467
375
|
return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
|
|
468
376
|
}
|
|
469
|
-
function isAsset(value) {
|
|
470
|
-
return value === 'ATTO' || value === 'XNO';
|
|
471
|
-
}
|
|
472
|
-
function isSha256Hex(value) {
|
|
473
|
-
return typeof value === 'string' && /^[0-9a-f]{64}$/.test(value);
|
|
474
|
-
}
|
|
475
|
-
function validProductAtomicTerms(gross, fee, net) {
|
|
476
|
-
if (typeof gross !== 'string' || !/^[1-9][0-9]{0,64}$/.test(gross)
|
|
477
|
-
|| typeof fee !== 'string' || !/^(?:0|[1-9][0-9]{0,64})$/.test(fee)
|
|
478
|
-
|| typeof net !== 'string' || !/^[1-9][0-9]{0,64}$/.test(net))
|
|
479
|
-
return false;
|
|
480
|
-
return BigInt(gross) === BigInt(fee) + BigInt(net);
|
|
481
|
-
}
|
|
482
|
-
function hasExactKeys(value, keys) {
|
|
483
|
-
const actual = Object.keys(value);
|
|
484
|
-
return actual.length === keys.length && actual.every(key => keys.includes(key));
|
|
485
|
-
}
|
|
486
377
|
function boundedAsciiSpaceReason(value, maximumCodePoints) {
|
|
487
378
|
if (typeof value !== 'string' || /[\u0000-\u001f\u007f]/.test(value))
|
|
488
379
|
return undefined;
|
|
@@ -0,0 +1,58 @@
|
|
|
1
|
+
import { z } from 'zod';
|
|
2
|
+
declare const termsSchema: z.ZodObject<{
|
|
3
|
+
paymentId: z.ZodString;
|
|
4
|
+
purpose: z.ZodEnum<{
|
|
5
|
+
PUBLICATION_FEE: "PUBLICATION_FEE";
|
|
6
|
+
SHOP_ORDER: "SHOP_ORDER";
|
|
7
|
+
TASK_MILESTONE: "TASK_MILESTONE";
|
|
8
|
+
BUYER_REFUND: "BUYER_REFUND";
|
|
9
|
+
}>;
|
|
10
|
+
sourceReference: z.ZodString;
|
|
11
|
+
ownerAccountId: z.ZodString;
|
|
12
|
+
asset: z.ZodEnum<{
|
|
13
|
+
ATTO: "ATTO";
|
|
14
|
+
XNO: "XNO";
|
|
15
|
+
}>;
|
|
16
|
+
network: z.ZodString;
|
|
17
|
+
senderAddress: z.ZodString;
|
|
18
|
+
recipientAddress: z.ZodString;
|
|
19
|
+
amountAtomic: z.ZodString;
|
|
20
|
+
termsHash: z.ZodString;
|
|
21
|
+
versionHash: z.ZodString;
|
|
22
|
+
baselineHeight: z.ZodString;
|
|
23
|
+
baselineFrontier: z.ZodNullable<z.ZodString>;
|
|
24
|
+
}, z.core.$strict>;
|
|
25
|
+
export type RelayTerms = z.infer<typeof termsSchema>;
|
|
26
|
+
export interface RelayRequest {
|
|
27
|
+
requestId: string;
|
|
28
|
+
origin: string;
|
|
29
|
+
audience: string;
|
|
30
|
+
terms: RelayTerms;
|
|
31
|
+
paymentRequired: string;
|
|
32
|
+
index?: number;
|
|
33
|
+
}
|
|
34
|
+
export interface RelayProof {
|
|
35
|
+
challengeId: string;
|
|
36
|
+
message: string;
|
|
37
|
+
signature: string;
|
|
38
|
+
}
|
|
39
|
+
export interface RelayOffer {
|
|
40
|
+
header: string;
|
|
41
|
+
raw: Record<string, unknown>;
|
|
42
|
+
terms: RelayTerms;
|
|
43
|
+
expiresAt: number;
|
|
44
|
+
}
|
|
45
|
+
export interface RelayRecord extends RelayRequest {
|
|
46
|
+
version: 1;
|
|
47
|
+
paymentSignature?: string;
|
|
48
|
+
}
|
|
49
|
+
export declare const MARKETPLACE_BINDING = "marketplace-binding";
|
|
50
|
+
export declare function decodePaymentHeader(header: string): Record<string, unknown>;
|
|
51
|
+
export declare function parseRelayOffer(request: RelayRequest, allowExpired?: boolean, now?: number): RelayOffer;
|
|
52
|
+
/** Only an unused, expired offer window can change; every other offered byte remains semantically identical. */
|
|
53
|
+
export declare function validateRelayOfferRefresh(previous: RelayRequest, next: RelayRequest, now?: number): void;
|
|
54
|
+
export declare function relayEvidenceBinding(terms: RelayTerms, transactionHash: string): string;
|
|
55
|
+
export declare function validateRelayProof(offer: RelayOffer, transactionHash: string, audience: string, proof: RelayProof, allowExpired?: boolean, now?: number): void;
|
|
56
|
+
export declare function relayPaymentPayload(offer: RelayOffer, requestId: string, payload: Record<string, unknown>, proof: RelayProof): string;
|
|
57
|
+
export declare function relayProofFromHeader(header: string): RelayProof;
|
|
58
|
+
export {};
|