blossom-client-sdk 5.1.0 → 5.2.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/README.md +65 -8
- package/lib/actions/delete.js +14 -39
- package/lib/actions/download.js +14 -36
- package/lib/actions/has.d.ts +1 -1
- package/lib/actions/has.js +6 -2
- package/lib/actions/list.js +15 -32
- package/lib/actions/media.js +25 -46
- package/lib/actions/mirror.js +14 -41
- package/lib/actions/multi-server.js +13 -0
- package/lib/actions/resolve.js +5 -0
- package/lib/actions/upload.js +27 -48
- package/lib/helpers/blob.js +4 -3
- package/lib/helpers/signal.d.ts +1 -0
- package/lib/helpers/signal.js +4 -3
- package/lib/index.d.ts +1 -0
- package/lib/index.js +1 -0
- package/lib/internal/bytes.d.ts +2 -0
- package/lib/internal/bytes.js +6 -0
- package/lib/internal/challenges.d.ts +6 -0
- package/lib/internal/challenges.js +15 -0
- package/package.json +21 -17
- package/src/actions/delete.ts +16 -42
- package/src/actions/download.ts +16 -41
- package/src/actions/has.ts +5 -2
- package/src/actions/list.ts +17 -35
- package/src/actions/media.ts +26 -49
- package/src/actions/mirror.ts +16 -45
- package/src/actions/multi-server.ts +13 -0
- package/src/actions/resolve.ts +5 -0
- package/src/actions/upload.ts +28 -50
- package/src/helpers/blob.ts +5 -4
- package/src/helpers/signal.ts +6 -4
- package/src/index.ts +1 -0
- package/src/internal/bytes.ts +6 -0
- package/src/internal/challenges.ts +25 -0
package/src/actions/media.ts
CHANGED
|
@@ -1,11 +1,12 @@
|
|
|
1
1
|
import { ServerType, UploadType } from "../types.js";
|
|
2
2
|
import { BlobDescriptor } from "../types.js";
|
|
3
3
|
import { getBlobSha256, getBlobSize, getBlobType } from "../helpers/index.js";
|
|
4
|
-
import {
|
|
4
|
+
import { handleChallenges } from "../internal/challenges.js";
|
|
5
5
|
import HTTPError from "../error.js";
|
|
6
6
|
import { encodeAuthorizationHeader, getReusableAuthEvent, storeAuthEvent } from "../auth.js";
|
|
7
7
|
import { SignedEvent } from "../types.js";
|
|
8
8
|
import { UploadOptions } from "./upload.js";
|
|
9
|
+
import { toWebBytes } from "../internal/bytes.js";
|
|
9
10
|
|
|
10
11
|
/** Error thrown when /media endpoint is not present on a server */
|
|
11
12
|
export class MediaEndpointMissingError extends Error {}
|
|
@@ -20,6 +21,7 @@ export async function uploadMedia<S extends ServerType, B extends UploadType>(
|
|
|
20
21
|
): Promise<BlobDescriptor> {
|
|
21
22
|
const url = new URL("/media", server);
|
|
22
23
|
const sha256 = await getBlobSha256(blob);
|
|
24
|
+
const body = blob instanceof Blob ? blob : toWebBytes(blob);
|
|
23
25
|
const authEvents = opts?.authEvents as Set<SignedEvent> | undefined;
|
|
24
26
|
const resolveAuth = async (preset: boolean = false) => {
|
|
25
27
|
const reused = authEvents
|
|
@@ -56,69 +58,44 @@ export async function uploadMedia<S extends ServerType, B extends UploadType>(
|
|
|
56
58
|
if (type) checkHeaders["X-Content-Type"] = type;
|
|
57
59
|
|
|
58
60
|
// check upload with HEAD /media
|
|
59
|
-
|
|
61
|
+
const firstTry = await fetch(url, {
|
|
60
62
|
method: "HEAD",
|
|
61
63
|
signal: opts?.signal,
|
|
62
64
|
headers: checkHeaders,
|
|
63
65
|
});
|
|
64
66
|
|
|
65
|
-
let upload: Response | undefined = undefined;
|
|
66
|
-
|
|
67
67
|
if (firstTry.status === 404) {
|
|
68
68
|
// HEAD endpoint is not supported. abort
|
|
69
69
|
throw new MediaEndpointMissingError("/media endpoint not supported");
|
|
70
70
|
}
|
|
71
71
|
|
|
72
|
-
|
|
73
|
-
switch (firstTry.status) {
|
|
74
|
-
case 401: {
|
|
75
|
-
// throw an error if auth is requested and disabled
|
|
76
|
-
if (opts?.auth === false) throw new Error("Authorization disabled");
|
|
77
|
-
|
|
78
|
-
// Request authorization event for this upload
|
|
79
|
-
const auth = await resolveAuth();
|
|
80
|
-
|
|
81
|
-
// Try upload with auth
|
|
82
|
-
upload = await fetch(url, {
|
|
83
|
-
signal: opts?.signal,
|
|
84
|
-
method: "PUT",
|
|
85
|
-
body: blob,
|
|
86
|
-
headers: { ...headers, Authorization: encodeAuthorizationHeader(auth) },
|
|
87
|
-
});
|
|
88
|
-
break;
|
|
89
|
-
}
|
|
90
|
-
case 402: {
|
|
91
|
-
let paymentHeaders: HeadersInit;
|
|
92
|
-
if (opts?.onPaymentRequired)
|
|
93
|
-
paymentHeaders = await opts.onPaymentRequired(server, sha256, blob, firstTry.headers);
|
|
94
|
-
else if (opts?.onPayment) {
|
|
95
|
-
const { encodePaymentToken, getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
|
|
96
|
-
const request = await getPaymentRequestFromHeaders(firstTry.headers);
|
|
97
|
-
paymentHeaders = { "X-Cashu": encodePaymentToken(await opts.onPayment(server, sha256, blob, request)) };
|
|
98
|
-
} else throw new Error("Missing payment handler");
|
|
72
|
+
if (![401, 402].includes(firstTry.status)) await HTTPError.handleErrorResponse(firstTry);
|
|
99
73
|
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
signal: opts?.signal,
|
|
103
|
-
method: "PUT",
|
|
104
|
-
body: blob,
|
|
105
|
-
headers: mergeHeaders(headers, paymentHeaders),
|
|
106
|
-
});
|
|
107
|
-
break;
|
|
108
|
-
}
|
|
109
|
-
}
|
|
110
|
-
|
|
111
|
-
if (firstTry.status >= 500) throw new Error("Server error");
|
|
112
|
-
|
|
113
|
-
// check passed, upload
|
|
114
|
-
if (!upload)
|
|
115
|
-
upload = await fetch(url, {
|
|
74
|
+
const request = (headers: HeadersInit) =>
|
|
75
|
+
fetch(url, {
|
|
116
76
|
signal: opts?.signal,
|
|
117
77
|
method: "PUT",
|
|
118
|
-
body
|
|
119
|
-
headers
|
|
78
|
+
body,
|
|
79
|
+
headers,
|
|
120
80
|
});
|
|
121
81
|
|
|
82
|
+
const upload = await handleChallenges(firstTry.ok ? await request(headers) : firstTry, headers, request, {
|
|
83
|
+
signal: opts?.signal,
|
|
84
|
+
auth: async () => {
|
|
85
|
+
if (opts?.auth === false) throw new Error("Authorization disabled");
|
|
86
|
+
return { Authorization: encodeAuthorizationHeader(await resolveAuth()) };
|
|
87
|
+
},
|
|
88
|
+
payment: async (headers) => {
|
|
89
|
+
if (opts?.onPaymentRequired) return opts.onPaymentRequired(server, sha256, blob, headers);
|
|
90
|
+
if (opts?.onPayment) {
|
|
91
|
+
const { encodePaymentToken, getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
|
|
92
|
+
const request = await getPaymentRequestFromHeaders(headers);
|
|
93
|
+
return { "X-Cashu": encodePaymentToken(await opts.onPayment(server, sha256, blob, request)) };
|
|
94
|
+
}
|
|
95
|
+
throw new Error("Missing payment handler");
|
|
96
|
+
},
|
|
97
|
+
});
|
|
98
|
+
|
|
122
99
|
// handle errors
|
|
123
100
|
await HTTPError.handleErrorResponse(upload);
|
|
124
101
|
|
package/src/actions/mirror.ts
CHANGED
|
@@ -2,7 +2,7 @@ import { encodeAuthorizationHeader, getReusableAuthEvent, storeAuthEvent } from
|
|
|
2
2
|
import { ServerType } from "../types.js";
|
|
3
3
|
import HTTPError from "../error.js";
|
|
4
4
|
import { fetchWithTimeout } from "../helpers/index.js";
|
|
5
|
-
import {
|
|
5
|
+
import { handleChallenges } from "../internal/challenges.js";
|
|
6
6
|
import { BlobDescriptor, PaymentRequest, PaymentToken, SignedEvent } from "../types.js";
|
|
7
7
|
|
|
8
8
|
export type MirrorOptions<S extends ServerType> = {
|
|
@@ -71,53 +71,24 @@ export async function mirrorBlob<S extends ServerType>(
|
|
|
71
71
|
}
|
|
72
72
|
|
|
73
73
|
const body = JSON.stringify({ url: blob.url });
|
|
74
|
-
|
|
75
|
-
method: "PUT",
|
|
74
|
+
const request = (headers: HeadersInit) =>
|
|
75
|
+
fetchWithTimeout(url, { method: "PUT", body, headers, signal: opts?.signal, timeout: opts?.timeout });
|
|
76
|
+
const mirror = await handleChallenges(await request(headers), headers, request, {
|
|
76
77
|
signal: opts?.signal,
|
|
77
|
-
|
|
78
|
-
body,
|
|
79
|
-
timeout: opts?.timeout,
|
|
80
|
-
});
|
|
81
|
-
|
|
82
|
-
switch (mirror.status) {
|
|
83
|
-
case 401: {
|
|
84
|
-
// throw an error if auth is requested and disabled
|
|
78
|
+
auth: async () => {
|
|
85
79
|
if (opts?.auth === false) throw new Error("Authorization disabled");
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
mirror = await fetchWithTimeout(url, {
|
|
92
|
-
signal: opts?.signal,
|
|
93
|
-
method: "PUT",
|
|
94
|
-
body,
|
|
95
|
-
headers: { ...headers, Authorization: encodeAuthorizationHeader(auth) },
|
|
96
|
-
timeout: opts?.timeout,
|
|
97
|
-
});
|
|
98
|
-
break;
|
|
99
|
-
}
|
|
100
|
-
case 402: {
|
|
101
|
-
let paymentHeaders: HeadersInit;
|
|
102
|
-
if (opts?.onPaymentRequired)
|
|
103
|
-
paymentHeaders = await opts.onPaymentRequired(server, blob.sha256, blob, mirror.headers);
|
|
104
|
-
else if (opts?.onPayment) {
|
|
80
|
+
return { Authorization: encodeAuthorizationHeader(await resolveAuth()) };
|
|
81
|
+
},
|
|
82
|
+
payment: async (headers) => {
|
|
83
|
+
if (opts?.onPaymentRequired) return opts.onPaymentRequired(server, blob.sha256, blob, headers);
|
|
84
|
+
if (opts?.onPayment) {
|
|
105
85
|
const { encodePaymentToken, getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
|
|
106
|
-
const request = await getPaymentRequestFromHeaders(
|
|
107
|
-
|
|
108
|
-
}
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
signal: opts?.signal,
|
|
113
|
-
method: "PUT",
|
|
114
|
-
body,
|
|
115
|
-
headers: mergeHeaders(headers, paymentHeaders),
|
|
116
|
-
timeout: opts?.timeout,
|
|
117
|
-
});
|
|
118
|
-
break;
|
|
119
|
-
}
|
|
120
|
-
}
|
|
86
|
+
const request = await getPaymentRequestFromHeaders(headers);
|
|
87
|
+
return { "X-Cashu": encodePaymentToken(await opts.onPayment(server, blob.sha256, blob, request)) };
|
|
88
|
+
}
|
|
89
|
+
throw new Error("Missing payment handler");
|
|
90
|
+
},
|
|
91
|
+
});
|
|
121
92
|
|
|
122
93
|
// handle errors
|
|
123
94
|
await HTTPError.handleErrorResponse(mirror);
|
|
@@ -100,10 +100,12 @@ export async function multiServerUpload<S extends ServerType, B extends UploadTy
|
|
|
100
100
|
opts?: MultiServerUploadOptions<S, B>,
|
|
101
101
|
) {
|
|
102
102
|
const options = { ...defaultMultiServerOptions, ...opts };
|
|
103
|
+
options.signal?.throwIfAborted();
|
|
103
104
|
let initialUpload: BlobDescriptor | undefined;
|
|
104
105
|
const results = new Map<S, BlobDescriptor>();
|
|
105
106
|
const authEvents = options.authEvents ?? new Set<SignedEvent>();
|
|
106
107
|
const blobSha256 = await getBlobSha256(blob);
|
|
108
|
+
options.signal?.throwIfAborted();
|
|
107
109
|
|
|
108
110
|
if (typeof options.auth === "object") authEvents.add(options.auth);
|
|
109
111
|
|
|
@@ -151,6 +153,7 @@ export async function multiServerUpload<S extends ServerType, B extends UploadTy
|
|
|
151
153
|
return { server, exists };
|
|
152
154
|
}),
|
|
153
155
|
);
|
|
156
|
+
options.signal?.throwIfAborted();
|
|
154
157
|
|
|
155
158
|
for (const result of preflightResults) {
|
|
156
159
|
if (result.status === "fulfilled" && result.value.exists) {
|
|
@@ -161,6 +164,7 @@ export async function multiServerUpload<S extends ServerType, B extends UploadTy
|
|
|
161
164
|
|
|
162
165
|
// upload to each server
|
|
163
166
|
for (const server of uploadServers) {
|
|
167
|
+
options.signal?.throwIfAborted();
|
|
164
168
|
const serverHasBlob = serversWithBlob.has(server);
|
|
165
169
|
|
|
166
170
|
try {
|
|
@@ -187,6 +191,7 @@ export async function multiServerUpload<S extends ServerType, B extends UploadTy
|
|
|
187
191
|
timeout: options.mirrorTimeout,
|
|
188
192
|
});
|
|
189
193
|
} catch (error) {
|
|
194
|
+
options.signal?.throwIfAborted();
|
|
190
195
|
// mirror failed, if server already has blob skip upload fallback
|
|
191
196
|
if (serverHasBlob) continue;
|
|
192
197
|
}
|
|
@@ -211,6 +216,7 @@ export async function multiServerUpload<S extends ServerType, B extends UploadTy
|
|
|
211
216
|
results.set(server, metadata);
|
|
212
217
|
options.onUpload?.(server, metadata.sha256, blob);
|
|
213
218
|
} catch (error) {
|
|
219
|
+
options.signal?.throwIfAborted();
|
|
214
220
|
const rejection = await handleRejection(server, blobSha256, error);
|
|
215
221
|
if (rejection === "cancel") return results;
|
|
216
222
|
if (!rejection && error instanceof Error) options.onError?.(server, blobSha256, blob, error);
|
|
@@ -244,10 +250,12 @@ export async function multiServerMediaUpload<S extends ServerType, B extends Upl
|
|
|
244
250
|
opts?: MultiServerMediaUploadOptions<S, B>,
|
|
245
251
|
) {
|
|
246
252
|
const options = { ...defaultMediaUploadOptions, ...opts };
|
|
253
|
+
options.signal?.throwIfAborted();
|
|
247
254
|
let initialUpload: BlobDescriptor | undefined;
|
|
248
255
|
const results = new Map<S, BlobDescriptor>();
|
|
249
256
|
const authEvents = options.authEvents ?? new Set<SignedEvent>();
|
|
250
257
|
const blobSha256 = await getBlobSha256(blob);
|
|
258
|
+
options.signal?.throwIfAborted();
|
|
251
259
|
|
|
252
260
|
if (typeof options.auth === "object") authEvents.add(options.auth);
|
|
253
261
|
|
|
@@ -287,6 +295,7 @@ export async function multiServerMediaUpload<S extends ServerType, B extends Upl
|
|
|
287
295
|
|
|
288
296
|
// phase 1: upload to /media on one server for optimization
|
|
289
297
|
for (const server of mediaServers) {
|
|
298
|
+
options.signal?.throwIfAborted();
|
|
290
299
|
try {
|
|
291
300
|
options.onStart?.(server, blobSha256, blob);
|
|
292
301
|
|
|
@@ -302,6 +311,7 @@ export async function multiServerMediaUpload<S extends ServerType, B extends Upl
|
|
|
302
311
|
mediaUploadServer = server;
|
|
303
312
|
options.onUpload?.(server, initialUpload.sha256, blob);
|
|
304
313
|
} catch (error) {
|
|
314
|
+
options.signal?.throwIfAborted();
|
|
305
315
|
if (error instanceof MediaEndpointMissingError) {
|
|
306
316
|
// ignore, try next server
|
|
307
317
|
} else {
|
|
@@ -341,6 +351,7 @@ export async function multiServerMediaUpload<S extends ServerType, B extends Upl
|
|
|
341
351
|
return { server, exists };
|
|
342
352
|
}),
|
|
343
353
|
);
|
|
354
|
+
options.signal?.throwIfAborted();
|
|
344
355
|
|
|
345
356
|
for (const result of preflightResults) {
|
|
346
357
|
if (result.status === "fulfilled" && result.value.exists) {
|
|
@@ -351,6 +362,7 @@ export async function multiServerMediaUpload<S extends ServerType, B extends Upl
|
|
|
351
362
|
|
|
352
363
|
// mirror to remaining servers
|
|
353
364
|
for (const server of remainingServers) {
|
|
365
|
+
options.signal?.throwIfAborted();
|
|
354
366
|
try {
|
|
355
367
|
options.onStart?.(server, initialUpload.sha256, blob);
|
|
356
368
|
|
|
@@ -366,6 +378,7 @@ export async function multiServerMediaUpload<S extends ServerType, B extends Upl
|
|
|
366
378
|
results.set(server, metadata);
|
|
367
379
|
options.onUpload?.(server, metadata.sha256, blob);
|
|
368
380
|
} catch (error) {
|
|
381
|
+
options.signal?.throwIfAborted();
|
|
369
382
|
const rejection = await handleRejection(server, initialUpload.sha256, error);
|
|
370
383
|
if (rejection === "cancel") return results;
|
|
371
384
|
if (!rejection && error instanceof Error) options.onError?.(server, initialUpload.sha256, blob, error);
|
package/src/actions/resolve.ts
CHANGED
|
@@ -90,12 +90,14 @@ export async function getBlobUrls(uri: string | URL | BlossomURI, opts?: GetBlob
|
|
|
90
90
|
|
|
91
91
|
/** Resolves a blossom URI to a downloaded blob by trying servers from hints sequentially */
|
|
92
92
|
export async function resolveBlob(uri: string | URL | BlossomURI, opts?: ResolveOptions): Promise<Response> {
|
|
93
|
+
opts?.signal?.throwIfAborted();
|
|
93
94
|
const parsed = parseInput(uri);
|
|
94
95
|
const collector = createServerCollector(buildBlobPath(parsed.sha256, parsed.ext));
|
|
95
96
|
|
|
96
97
|
/** Try GET on each URL, return the first successful response */
|
|
97
98
|
const tryUrls = async (urls: string[]): Promise<Response | undefined> => {
|
|
98
99
|
for (const url of urls) {
|
|
100
|
+
opts?.signal?.throwIfAborted();
|
|
99
101
|
try {
|
|
100
102
|
const res = await fetchWithTimeout(new URL(url), {
|
|
101
103
|
signal: opts?.signal,
|
|
@@ -104,6 +106,7 @@ export async function resolveBlob(uri: string | URL | BlossomURI, opts?: Resolve
|
|
|
104
106
|
|
|
105
107
|
if (res.ok) return res;
|
|
106
108
|
} catch {
|
|
109
|
+
opts?.signal?.throwIfAborted();
|
|
107
110
|
// server unreachable or error — try next
|
|
108
111
|
continue;
|
|
109
112
|
}
|
|
@@ -121,7 +124,9 @@ export async function resolveBlob(uri: string | URL | BlossomURI, opts?: Resolve
|
|
|
121
124
|
// 2. resolve and try author hints (deferred — requires relay queries)
|
|
122
125
|
if (opts?.getServers) {
|
|
123
126
|
for (const pubkey of parsed.authors) {
|
|
127
|
+
opts?.signal?.throwIfAborted();
|
|
124
128
|
const authorServers = await opts.getServers(pubkey);
|
|
129
|
+
opts?.signal?.throwIfAborted();
|
|
125
130
|
if (authorServers) {
|
|
126
131
|
const urls = collector.add(authorServers);
|
|
127
132
|
if (urls.length > 0) {
|
package/src/actions/upload.ts
CHANGED
|
@@ -2,8 +2,9 @@ import { encodeAuthorizationHeader, getReusableAuthEvent, storeAuthEvent } from
|
|
|
2
2
|
import { ServerType, UploadType } from "../types.js";
|
|
3
3
|
import HTTPError from "../error.js";
|
|
4
4
|
import { fetchWithTimeout, getBlobSha256, getBlobSize, getBlobType } from "../helpers/index.js";
|
|
5
|
-
import {
|
|
5
|
+
import { handleChallenges } from "../internal/challenges.js";
|
|
6
6
|
import { BlobDescriptor, PaymentRequest, PaymentToken, SignedEvent } from "../types.js";
|
|
7
|
+
import { toWebBytes } from "../internal/bytes.js";
|
|
7
8
|
|
|
8
9
|
export type UploadOptions<S extends ServerType, B extends UploadType> = {
|
|
9
10
|
/** AbortSignal to cancel the action */
|
|
@@ -42,6 +43,7 @@ export async function uploadBlob<S extends ServerType, B extends UploadType>(
|
|
|
42
43
|
): Promise<BlobDescriptor> {
|
|
43
44
|
const url = new URL("/upload", server);
|
|
44
45
|
const sha256 = await getBlobSha256(blob);
|
|
46
|
+
const body = blob instanceof Blob ? blob : toWebBytes(blob);
|
|
45
47
|
const resolveAuth = async (preset: boolean = false) => {
|
|
46
48
|
const reused = opts?.authEvents
|
|
47
49
|
? await getReusableAuthEvent(opts.authEvents, { server, type: "upload", blob: sha256 })
|
|
@@ -86,69 +88,45 @@ export async function uploadBlob<S extends ServerType, B extends UploadType>(
|
|
|
86
88
|
|
|
87
89
|
let upload: Response | undefined = undefined;
|
|
88
90
|
|
|
91
|
+
if (![401, 402, 404].includes(firstTry.status)) await HTTPError.handleErrorResponse(firstTry);
|
|
92
|
+
|
|
89
93
|
if (firstTry.status === 404) {
|
|
90
94
|
// BUD-06 HEAD endpoint is not supported. attempt to upload
|
|
91
95
|
upload = firstTry = await fetchWithTimeout(url, {
|
|
92
|
-
body
|
|
96
|
+
body,
|
|
93
97
|
method: "PUT",
|
|
98
|
+
headers,
|
|
94
99
|
signal: opts?.signal,
|
|
95
100
|
timeout: opts?.timeout,
|
|
96
101
|
});
|
|
97
102
|
}
|
|
98
103
|
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
case 401: {
|
|
102
|
-
// throw an error if auth is requested and disabled
|
|
103
|
-
if (opts?.auth === false) throw new Error("Authorization disabled");
|
|
104
|
-
|
|
105
|
-
// Request authorization event for this upload
|
|
106
|
-
const auth = await resolveAuth();
|
|
107
|
-
|
|
108
|
-
// Try upload with auth
|
|
109
|
-
upload = await fetchWithTimeout(url, {
|
|
110
|
-
method: "PUT",
|
|
111
|
-
body: blob,
|
|
112
|
-
headers: { ...headers, Authorization: encodeAuthorizationHeader(auth) },
|
|
113
|
-
signal: opts?.signal,
|
|
114
|
-
timeout: opts?.timeout,
|
|
115
|
-
});
|
|
116
|
-
break;
|
|
117
|
-
}
|
|
118
|
-
case 402: {
|
|
119
|
-
let paymentHeaders: HeadersInit;
|
|
120
|
-
if (opts?.onPaymentRequired)
|
|
121
|
-
paymentHeaders = await opts.onPaymentRequired(server, sha256, blob, firstTry.headers);
|
|
122
|
-
else if (opts?.onPayment) {
|
|
123
|
-
const { encodePaymentToken, getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
|
|
124
|
-
const request = await getPaymentRequestFromHeaders(firstTry.headers);
|
|
125
|
-
paymentHeaders = { "X-Cashu": encodePaymentToken(await opts.onPayment(server, sha256, blob, request)) };
|
|
126
|
-
} else throw new Error("Missing payment handler");
|
|
127
|
-
|
|
128
|
-
// Try upload with payment
|
|
129
|
-
upload = await fetchWithTimeout(url, {
|
|
130
|
-
method: "PUT",
|
|
131
|
-
body: blob,
|
|
132
|
-
headers: mergeHeaders(headers, paymentHeaders),
|
|
133
|
-
signal: opts?.signal,
|
|
134
|
-
timeout: opts?.timeout,
|
|
135
|
-
});
|
|
136
|
-
break;
|
|
137
|
-
}
|
|
138
|
-
}
|
|
139
|
-
|
|
140
|
-
if (firstTry.status >= 500) throw new Error("Server error");
|
|
141
|
-
|
|
142
|
-
// check passed, upload
|
|
143
|
-
if (!upload)
|
|
144
|
-
upload = await fetchWithTimeout(url, {
|
|
104
|
+
const request = (headers: HeadersInit) =>
|
|
105
|
+
fetchWithTimeout(url, {
|
|
145
106
|
method: "PUT",
|
|
146
|
-
body
|
|
147
|
-
headers
|
|
107
|
+
body,
|
|
108
|
+
headers,
|
|
148
109
|
signal: opts?.signal,
|
|
149
110
|
timeout: opts?.timeout,
|
|
150
111
|
});
|
|
151
112
|
|
|
113
|
+
upload = await handleChallenges(upload ?? (firstTry.ok ? await request(headers) : firstTry), headers, request, {
|
|
114
|
+
signal: opts?.signal,
|
|
115
|
+
auth: async () => {
|
|
116
|
+
if (opts?.auth === false) throw new Error("Authorization disabled");
|
|
117
|
+
return { Authorization: encodeAuthorizationHeader(await resolveAuth()) };
|
|
118
|
+
},
|
|
119
|
+
payment: async (headers) => {
|
|
120
|
+
if (opts?.onPaymentRequired) return opts.onPaymentRequired(server, sha256, blob, headers);
|
|
121
|
+
if (opts?.onPayment) {
|
|
122
|
+
const { encodePaymentToken, getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
|
|
123
|
+
const request = await getPaymentRequestFromHeaders(headers);
|
|
124
|
+
return { "X-Cashu": encodePaymentToken(await opts.onPayment(server, sha256, blob, request)) };
|
|
125
|
+
}
|
|
126
|
+
throw new Error("Missing payment handler");
|
|
127
|
+
},
|
|
128
|
+
});
|
|
129
|
+
|
|
152
130
|
// handle errors
|
|
153
131
|
await HTTPError.handleErrorResponse(upload);
|
|
154
132
|
|
package/src/helpers/blob.ts
CHANGED
|
@@ -1,5 +1,6 @@
|
|
|
1
|
-
import { bytesToHex } from "@noble/hashes/utils";
|
|
1
|
+
import { bytesToHex } from "@noble/hashes/utils.js";
|
|
2
2
|
import { UploadType } from "../types.js";
|
|
3
|
+
import { toWebBytes } from "../internal/bytes.js";
|
|
3
4
|
|
|
4
5
|
/** Checks if a string is a 64 length hex string */
|
|
5
6
|
export function isSha256(str: string) {
|
|
@@ -21,14 +22,14 @@ export function getBlobSha256(blob: UploadType) {
|
|
|
21
22
|
|
|
22
23
|
/** Calculates the sha2456 of a Blob */
|
|
23
24
|
export async function computeBlobSha256(blob: UploadType) {
|
|
24
|
-
let buffer: ArrayBuffer |
|
|
25
|
+
let buffer: ArrayBuffer | Uint8Array<ArrayBuffer>;
|
|
25
26
|
|
|
26
27
|
// NOTE: use typeof File !== "undefined" to check if File is supported (required to support node 18)
|
|
27
28
|
if ((typeof File !== "undefined" && blob instanceof File) || blob instanceof Blob) {
|
|
28
29
|
buffer = await blob.arrayBuffer();
|
|
29
30
|
} else {
|
|
30
31
|
// nodejs Buffer
|
|
31
|
-
buffer = blob;
|
|
32
|
+
buffer = toWebBytes(blob);
|
|
32
33
|
}
|
|
33
34
|
|
|
34
35
|
let hash: Uint8Array;
|
|
@@ -36,7 +37,7 @@ export async function computeBlobSha256(blob: UploadType) {
|
|
|
36
37
|
const hashBuffer = await crypto.subtle.digest("SHA-256", buffer);
|
|
37
38
|
hash = new Uint8Array(hashBuffer);
|
|
38
39
|
} else {
|
|
39
|
-
const { sha256 } = await import("@noble/hashes/sha2");
|
|
40
|
+
const { sha256 } = await import("@noble/hashes/sha2.js");
|
|
40
41
|
hash = sha256.create().update(new Uint8Array(buffer)).digest();
|
|
41
42
|
}
|
|
42
43
|
|
package/src/helpers/signal.ts
CHANGED
|
@@ -1,4 +1,6 @@
|
|
|
1
|
-
export class TimeoutError extends Error {
|
|
1
|
+
export class TimeoutError extends Error {
|
|
2
|
+
name = "TimeoutError";
|
|
3
|
+
}
|
|
2
4
|
|
|
3
5
|
/** Creates and optionally wraps an AbortSignal with a timeout */
|
|
4
6
|
export function wrapSignalWithTimeout(
|
|
@@ -8,13 +10,13 @@ export function wrapSignalWithTimeout(
|
|
|
8
10
|
): { cancel: () => void; signal: AbortSignal } {
|
|
9
11
|
const controller = new AbortController();
|
|
10
12
|
|
|
11
|
-
if (signal) signal.addEventListener("abort", (err) => controller.abort(err), { once: true });
|
|
12
|
-
|
|
13
13
|
const t = setTimeout(() => {
|
|
14
14
|
controller.abort(new TimeoutError(message));
|
|
15
15
|
}, timeout);
|
|
16
16
|
|
|
17
17
|
const cancel = () => clearTimeout(t);
|
|
18
18
|
|
|
19
|
-
|
|
19
|
+
// Native composition preserves existing abort reasons and avoids retaining listeners
|
|
20
|
+
// on a caller's long-lived signal. It also keeps cancellation working after headers arrive.
|
|
21
|
+
return { cancel, signal: signal ? AbortSignal.any([signal, controller.signal]) : controller.signal };
|
|
20
22
|
}
|
package/src/index.ts
CHANGED
|
@@ -0,0 +1,6 @@
|
|
|
1
|
+
/** Return a Web API-compatible view, copying only shared-memory-backed inputs. */
|
|
2
|
+
export function toWebBytes(bytes: Uint8Array): Uint8Array<ArrayBuffer> {
|
|
3
|
+
return bytes.buffer instanceof ArrayBuffer
|
|
4
|
+
? new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength)
|
|
5
|
+
: Uint8Array.from(bytes);
|
|
6
|
+
}
|
|
@@ -0,0 +1,25 @@
|
|
|
1
|
+
import { mergeHeaders } from "../helpers/headers.js";
|
|
2
|
+
|
|
3
|
+
/** Handle each challenge at most once, including challenges from a preflight response. */
|
|
4
|
+
export async function handleChallenges(
|
|
5
|
+
response: Response,
|
|
6
|
+
headers: HeadersInit,
|
|
7
|
+
request: (headers: HeadersInit) => Promise<Response>,
|
|
8
|
+
handlers: {
|
|
9
|
+
auth: () => Promise<HeadersInit>;
|
|
10
|
+
payment: (headers: Headers) => Promise<HeadersInit>;
|
|
11
|
+
signal?: AbortSignal;
|
|
12
|
+
},
|
|
13
|
+
): Promise<Response> {
|
|
14
|
+
const handled = new Set<number>();
|
|
15
|
+
while ((response.status === 401 || response.status === 402) && !handled.has(response.status)) {
|
|
16
|
+
handlers.signal?.throwIfAborted();
|
|
17
|
+
handled.add(response.status);
|
|
18
|
+
const nextHeaders = response.status === 401 ? await handlers.auth() : await handlers.payment(response.headers);
|
|
19
|
+
handlers.signal?.throwIfAborted();
|
|
20
|
+
headers = mergeHeaders(headers, nextHeaders);
|
|
21
|
+
await response.body?.cancel();
|
|
22
|
+
response = await request(headers);
|
|
23
|
+
}
|
|
24
|
+
return response;
|
|
25
|
+
}
|