blossom-client-sdk 5.0.0 → 5.1.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.
@@ -9,12 +9,15 @@ export type DeleteOptions<S extends ServerType> = {
9
9
  authEvents?: Set<SignedEvent>;
10
10
  /** Request timeout */
11
11
  timeout?: number;
12
+ /** Return headers to retry a request rejected with HTTP 402. */
13
+ onPaymentRequired?: (server: S, sha256: string, headers: Headers) => Promise<HeadersInit>;
12
14
  /**
13
15
  * A method used to request payment when deleting
14
16
  * @param server the server requiring payment
15
17
  * @param sha256 the sha256 of the blob being uploaded or mirrored
16
18
  * @param request the payment request
17
19
  */
20
+ /** @deprecated Use onPaymentRequired to handle payment schemes generically. */
18
21
  onPayment?: (server: S, sha256: string, request: PaymentRequest) => Promise<PaymentToken>;
19
22
  /**
20
23
  * A method used to request a signed auth event for a server and sha256
@@ -1,6 +1,7 @@
1
1
  import { encodeAuthorizationHeader, getReusableAuthEvent, storeAuthEvent } from "../auth.js";
2
2
  import HTTPError from "../error.js";
3
3
  import { fetchWithTimeout } from "../helpers/fetch.js";
4
+ import { mergeHeaders } from "../helpers/headers.js";
4
5
  /** Deletes a blob to a server */
5
6
  export async function deleteBlob(server, hash, opts) {
6
7
  const url = new URL("/" + hash, server);
@@ -51,18 +52,21 @@ export async function deleteBlob(server, hash, opts) {
51
52
  break;
52
53
  }
53
54
  case 402: {
54
- if (!opts?.onPayment)
55
+ let paymentHeaders;
56
+ if (opts?.onPaymentRequired)
57
+ paymentHeaders = await opts.onPaymentRequired(server, hash, res.headers);
58
+ else if (opts?.onPayment) {
59
+ const { encodePaymentToken, getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
60
+ const request = await getPaymentRequestFromHeaders(res.headers);
61
+ paymentHeaders = { "X-Cashu": encodePaymentToken(await opts.onPayment(server, hash, request)) };
62
+ }
63
+ else
55
64
  throw new Error("Missing payment handler");
56
- const { getEncodedToken } = await import("@cashu/cashu-ts");
57
- const { getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
58
- const request = await getPaymentRequestFromHeaders(res.headers);
59
- const token = await opts.onPayment(server, hash, request);
60
- const payment = getEncodedToken(token);
61
65
  // Try delete with payment
62
66
  res = await fetchWithTimeout(url, {
63
67
  signal: opts?.signal,
64
68
  method: "DELETE",
65
- headers: { ...headers, "X-Cashu": payment },
69
+ headers: mergeHeaders(headers, paymentHeaders),
66
70
  timeout: opts?.timeout,
67
71
  });
68
72
  break;
@@ -9,12 +9,15 @@ export type DownloadOptions<S extends ServerType> = {
9
9
  authEvents?: Set<SignedEvent>;
10
10
  /** Request timeout */
11
11
  timeout?: number;
12
+ /** Return headers to retry a request rejected with HTTP 402. */
13
+ onPaymentRequired?: (server: S, sha256: string, headers: Headers) => Promise<HeadersInit>;
12
14
  /**
13
15
  * A method used to request payment when downloading
14
16
  * @param server the server requiring payment
15
17
  * @param sha256 the sha256 of the blob being uploaded or mirrored
16
18
  * @param request the payment request
17
19
  */
20
+ /** @deprecated Use onPaymentRequired to handle payment schemes generically. */
18
21
  onPayment?: (server: S, sha256: string, request: PaymentRequest) => Promise<PaymentToken>;
19
22
  /**
20
23
  * A method used to request a signed auth event for a server and sha256
@@ -1,6 +1,7 @@
1
1
  import HTTPError from "../error.js";
2
2
  import { encodeAuthorizationHeader, getReusableAuthEvent, storeAuthEvent } from "../auth.js";
3
3
  import { fetchWithTimeout } from "../helpers/index.js";
4
+ import { mergeHeaders } from "../helpers/headers.js";
4
5
  /** Downloads a blob from a server and returns the Response */
5
6
  export async function downloadBlob(server, hash, opts) {
6
7
  const url = new URL("/" + hash, server);
@@ -49,16 +50,19 @@ export async function downloadBlob(server, hash, opts) {
49
50
  break;
50
51
  }
51
52
  case 402: {
52
- if (!opts?.onPayment)
53
+ let paymentHeaders;
54
+ if (opts?.onPaymentRequired)
55
+ paymentHeaders = await opts.onPaymentRequired(server, hash, download.headers);
56
+ else if (opts?.onPayment) {
57
+ const { encodePaymentToken, getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
58
+ const request = await getPaymentRequestFromHeaders(download.headers);
59
+ paymentHeaders = { "X-Cashu": encodePaymentToken(await opts.onPayment(server, hash, request)) };
60
+ }
61
+ else
53
62
  throw new Error("Missing payment handler");
54
- const { getEncodedToken } = await import("@cashu/cashu-ts");
55
- const { getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
56
- const request = await getPaymentRequestFromHeaders(download.headers);
57
- const token = await opts.onPayment(server, hash, request);
58
- const payment = getEncodedToken(token);
59
63
  // Try download with payment
60
64
  download = await fetchWithTimeout(url, {
61
- headers: { ...headers, "X-Cashu": payment },
65
+ headers: mergeHeaders(headers, paymentHeaders),
62
66
  signal: opts?.signal,
63
67
  timeout: opts?.timeout,
64
68
  });
@@ -13,11 +13,14 @@ export type ListOptions<S extends ServerType> = {
13
13
  limit?: number;
14
14
  since?: number;
15
15
  until?: number;
16
+ /** Return headers to retry a request rejected with HTTP 402. */
17
+ onPaymentRequired?: (server: S, headers: Headers) => Promise<HeadersInit>;
16
18
  /**
17
19
  * A method used to request payment
18
20
  * @param server the server requiring payment
19
21
  * @param request the payment request
20
22
  */
23
+ /** @deprecated Use onPaymentRequired to handle payment schemes generically. */
21
24
  onPayment?: (server: S, request: PaymentRequest) => Promise<PaymentToken>;
22
25
  /**
23
26
  * A method used to request a signed auth event for a server
@@ -1,6 +1,7 @@
1
1
  import HTTPError from "../error.js";
2
2
  import { encodeAuthorizationHeader, getReusableAuthEvent, storeAuthEvent } from "../auth.js";
3
3
  import { fetchWithTimeout } from "../helpers/index.js";
4
+ import { mergeHeaders } from "../helpers/headers.js";
4
5
  /** Lists a page of blobs from a server */
5
6
  export async function listBlobs(server, pubkey, opts) {
6
7
  const url = new URL(`/list/` + pubkey, server);
@@ -51,16 +52,19 @@ export async function listBlobs(server, pubkey, opts) {
51
52
  break;
52
53
  }
53
54
  case 402: {
54
- if (!opts?.onPayment)
55
+ let paymentHeaders;
56
+ if (opts?.onPaymentRequired)
57
+ paymentHeaders = await opts.onPaymentRequired(server, list.headers);
58
+ else if (opts?.onPayment) {
59
+ const { encodePaymentToken, getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
60
+ const request = await getPaymentRequestFromHeaders(list.headers);
61
+ paymentHeaders = { "X-Cashu": encodePaymentToken(await opts.onPayment(server, request)) };
62
+ }
63
+ else
55
64
  throw new Error("Missing payment handler");
56
- const { getEncodedToken } = await import("@cashu/cashu-ts");
57
- const { getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
58
- const request = await getPaymentRequestFromHeaders(list.headers);
59
- const token = await opts.onPayment(server, request);
60
- const payment = getEncodedToken(token);
61
65
  // Try list with payment
62
66
  list = await fetchWithTimeout(url, {
63
- headers: { ...headers, "X-Cashu": payment },
67
+ headers: mergeHeaders(headers, paymentHeaders),
64
68
  signal: opts?.signal,
65
69
  timeout: opts?.timeout,
66
70
  });
@@ -1,4 +1,5 @@
1
1
  import { getBlobSha256, getBlobSize, getBlobType } from "../helpers/index.js";
2
+ import { mergeHeaders } from "../helpers/headers.js";
2
3
  import HTTPError from "../error.js";
3
4
  import { encodeAuthorizationHeader, getReusableAuthEvent, storeAuthEvent } from "../auth.js";
4
5
  /** Error thrown when /media endpoint is not present on a server */
@@ -71,19 +72,22 @@ export async function uploadMedia(server, blob, opts) {
71
72
  break;
72
73
  }
73
74
  case 402: {
74
- if (!opts?.onPayment)
75
+ let paymentHeaders;
76
+ if (opts?.onPaymentRequired)
77
+ paymentHeaders = await opts.onPaymentRequired(server, sha256, blob, firstTry.headers);
78
+ else if (opts?.onPayment) {
79
+ const { encodePaymentToken, getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
80
+ const request = await getPaymentRequestFromHeaders(firstTry.headers);
81
+ paymentHeaders = { "X-Cashu": encodePaymentToken(await opts.onPayment(server, sha256, blob, request)) };
82
+ }
83
+ else
75
84
  throw new Error("Missing payment handler");
76
- const { getEncodedToken } = await import("@cashu/cashu-ts");
77
- const { getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
78
- const request = await getPaymentRequestFromHeaders(firstTry.headers);
79
- const token = await opts.onPayment(server, sha256, blob, request);
80
- const payment = getEncodedToken(token);
81
85
  // Try upload with payment
82
86
  upload = await fetch(url, {
83
87
  signal: opts?.signal,
84
88
  method: "PUT",
85
89
  body: blob,
86
- headers: { ...headers, "X-Cashu": payment },
90
+ headers: mergeHeaders(headers, paymentHeaders),
87
91
  });
88
92
  break;
89
93
  }
@@ -9,6 +9,8 @@ export type MirrorOptions<S extends ServerType> = {
9
9
  authEvents?: Set<SignedEvent>;
10
10
  /** Request timeout */
11
11
  timeout?: number;
12
+ /** Return headers to retry a request rejected with HTTP 402. */
13
+ onPaymentRequired?: (server: S, sha256: string, blob: BlobDescriptor, headers: Headers) => Promise<HeadersInit>;
12
14
  /**
13
15
  * A method used to request payment when uploading or mirroring a blob
14
16
  * @param server the server requiring payment
@@ -16,6 +18,7 @@ export type MirrorOptions<S extends ServerType> = {
16
18
  * @param blob the original blob
17
19
  * @param request the payment request
18
20
  */
21
+ /** @deprecated Use onPaymentRequired to handle payment schemes generically. */
19
22
  onPayment?: (server: S, sha256: string, blob: BlobDescriptor, request: PaymentRequest) => Promise<PaymentToken>;
20
23
  /**
21
24
  * A method used to request a signed auth event for a server and sha256
@@ -1,6 +1,7 @@
1
1
  import { encodeAuthorizationHeader, getReusableAuthEvent, storeAuthEvent } from "../auth.js";
2
2
  import HTTPError from "../error.js";
3
3
  import { fetchWithTimeout } from "../helpers/index.js";
4
+ import { mergeHeaders } from "../helpers/headers.js";
4
5
  /** Mirrors a blob to a server */
5
6
  export async function mirrorBlob(server, blob, opts) {
6
7
  const url = new URL("/mirror", server);
@@ -59,19 +60,22 @@ export async function mirrorBlob(server, blob, opts) {
59
60
  break;
60
61
  }
61
62
  case 402: {
62
- if (!opts?.onPayment)
63
+ let paymentHeaders;
64
+ if (opts?.onPaymentRequired)
65
+ paymentHeaders = await opts.onPaymentRequired(server, blob.sha256, blob, mirror.headers);
66
+ else if (opts?.onPayment) {
67
+ const { encodePaymentToken, getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
68
+ const request = await getPaymentRequestFromHeaders(mirror.headers);
69
+ paymentHeaders = { "X-Cashu": encodePaymentToken(await opts.onPayment(server, blob.sha256, blob, request)) };
70
+ }
71
+ else
63
72
  throw new Error("Missing payment handler");
64
- const { getEncodedToken } = await import("@cashu/cashu-ts");
65
- const { getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
66
- const request = await getPaymentRequestFromHeaders(mirror.headers);
67
- const token = await opts.onPayment(server, blob.sha256, blob, request);
68
- const payment = getEncodedToken(token);
69
73
  // Try mirror with payment
70
74
  mirror = await fetchWithTimeout(url, {
71
75
  signal: opts?.signal,
72
76
  method: "PUT",
73
77
  body,
74
- headers: { ...headers, "X-Cashu": payment },
78
+ headers: mergeHeaders(headers, paymentHeaders),
75
79
  timeout: opts?.timeout,
76
80
  });
77
81
  break;
@@ -56,6 +56,11 @@ export async function multiServerUpload(servers, blob, opts) {
56
56
  throw new Error("Missing payment handler");
57
57
  return options.onPayment(server, sha256, blob, request);
58
58
  };
59
+ const handlePaymentRequired = (server, sha256, _blob, headers) => {
60
+ if (!options.onPaymentRequired)
61
+ throw new Error("Missing payment handler");
62
+ return options.onPaymentRequired(server, sha256, blob, headers);
63
+ };
59
64
  const handleRejection = async (server, sha256, error) => {
60
65
  if (!HTTPError.isRejection(error))
61
66
  return false;
@@ -102,6 +107,7 @@ export async function multiServerUpload(servers, blob, opts) {
102
107
  auth: typeof options.auth === "boolean" ? options.auth : undefined,
103
108
  onAuth: (server, sha256) => handleAuthRequest(server, sha256, "upload"),
104
109
  onPayment: handlePaymentRequest,
110
+ onPaymentRequired: options.onPaymentRequired ? handlePaymentRequired : undefined,
105
111
  timeout: options.mirrorTimeout,
106
112
  });
107
113
  }
@@ -119,6 +125,7 @@ export async function multiServerUpload(servers, blob, opts) {
119
125
  auth: typeof options.auth === "boolean" ? options.auth : undefined,
120
126
  onAuth: handleAuthRequest,
121
127
  onPayment: handlePaymentRequest,
128
+ onPaymentRequired: options.onPaymentRequired ? handlePaymentRequired : undefined,
122
129
  timeout: options.mirrorTimeout,
123
130
  });
124
131
  if (!initialUpload)
@@ -179,6 +186,11 @@ export async function multiServerMediaUpload(servers, blob, opts) {
179
186
  throw new Error("Missing payment handler");
180
187
  return options.onPayment(server, sha256, blob, request);
181
188
  };
189
+ const handlePaymentRequired = (server, sha256, _blob, headers) => {
190
+ if (!options.onPaymentRequired)
191
+ throw new Error("Missing payment handler");
192
+ return options.onPaymentRequired(server, sha256, blob, headers);
193
+ };
182
194
  const handleRejection = async (server, sha256, error) => {
183
195
  if (!HTTPError.isRejection(error))
184
196
  return false;
@@ -200,6 +212,7 @@ export async function multiServerMediaUpload(servers, blob, opts) {
200
212
  auth: typeof options.auth === "boolean" ? options.auth : undefined,
201
213
  onAuth: handleAuthRequest,
202
214
  onPayment: handlePaymentRequest,
215
+ onPaymentRequired: options.onPaymentRequired ? handlePaymentRequired : undefined,
203
216
  });
204
217
  results.set(server, initialUpload);
205
218
  mediaUploadServer = server;
@@ -256,6 +269,7 @@ export async function multiServerMediaUpload(servers, blob, opts) {
256
269
  auth: typeof options.auth === "boolean" ? options.auth : undefined,
257
270
  onAuth: (server, sha256) => handleAuthRequest(server, sha256, "upload"),
258
271
  onPayment: handlePaymentRequest,
272
+ onPaymentRequired: options.onPaymentRequired ? handlePaymentRequired : undefined,
259
273
  timeout: options.mirrorTimeout,
260
274
  });
261
275
  results.set(server, metadata);
@@ -9,6 +9,8 @@ export type UploadOptions<S extends ServerType, B extends UploadType> = {
9
9
  authEvents?: Set<SignedEvent>;
10
10
  /** Request timeout */
11
11
  timeout?: number;
12
+ /** Return headers to retry a request rejected with HTTP 402. */
13
+ onPaymentRequired?: (server: S, sha256: string, blob: B, headers: Headers) => Promise<HeadersInit>;
12
14
  /**
13
15
  * A method used to request payment when uploading or mirroring a blob
14
16
  * @param server the server requiring payment
@@ -16,6 +18,7 @@ export type UploadOptions<S extends ServerType, B extends UploadType> = {
16
18
  * @param blob the original blob
17
19
  * @param request the payment request
18
20
  */
21
+ /** @deprecated Use onPaymentRequired to handle payment schemes generically. */
19
22
  onPayment?: (server: S, sha256: string, blob: B, request: PaymentRequest) => Promise<PaymentToken>;
20
23
  /**
21
24
  * A method used to request a signed auth event for a server and sha256
@@ -1,6 +1,7 @@
1
1
  import { encodeAuthorizationHeader, getReusableAuthEvent, storeAuthEvent } from "../auth.js";
2
2
  import HTTPError from "../error.js";
3
3
  import { fetchWithTimeout, getBlobSha256, getBlobSize, getBlobType } from "../helpers/index.js";
4
+ import { mergeHeaders } from "../helpers/headers.js";
4
5
  /** Upload a blob to a server, handles payment and auth */
5
6
  export async function uploadBlob(server, blob, opts) {
6
7
  const url = new URL("/upload", server);
@@ -74,18 +75,21 @@ export async function uploadBlob(server, blob, opts) {
74
75
  break;
75
76
  }
76
77
  case 402: {
77
- if (!opts?.onPayment)
78
+ let paymentHeaders;
79
+ if (opts?.onPaymentRequired)
80
+ paymentHeaders = await opts.onPaymentRequired(server, sha256, blob, firstTry.headers);
81
+ else if (opts?.onPayment) {
82
+ const { encodePaymentToken, getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
83
+ const request = await getPaymentRequestFromHeaders(firstTry.headers);
84
+ paymentHeaders = { "X-Cashu": encodePaymentToken(await opts.onPayment(server, sha256, blob, request)) };
85
+ }
86
+ else
78
87
  throw new Error("Missing payment handler");
79
- const { getEncodedToken } = await import("@cashu/cashu-ts");
80
- const { getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
81
- const request = await getPaymentRequestFromHeaders(firstTry.headers);
82
- const token = await opts.onPayment(server, sha256, blob, request);
83
- const payment = getEncodedToken(token);
84
88
  // Try upload with payment
85
89
  upload = await fetchWithTimeout(url, {
86
90
  method: "PUT",
87
91
  body: blob,
88
- headers: { ...headers, "X-Cashu": payment },
92
+ headers: mergeHeaders(headers, paymentHeaders),
89
93
  signal: opts?.signal,
90
94
  timeout: opts?.timeout,
91
95
  });
@@ -1,5 +1,7 @@
1
1
  import { PaymentRequest } from "../types.js";
2
- /** Extracts a cashu-ts PaymentRequest from Headers. Loads @cashu/cashu-ts on demand. */
2
+ /** Extracts a Cashu PaymentRequest-compatible object from Headers. */
3
3
  export declare function getPaymentRequestFromHeaders(headers: Headers): Promise<PaymentRequest>;
4
4
  export declare function getPaymentRequestFromHeaders(headers: Headers, quite: false): Promise<PaymentRequest>;
5
5
  export declare function getPaymentRequestFromHeaders(headers: Headers, quite: true): Promise<PaymentRequest | undefined>;
6
+ /** Encodes the legacy Cashu token shape used by the deprecated onPayment callback. */
7
+ export declare function encodePaymentToken(token: unknown): string;
@@ -1,3 +1,142 @@
1
+ const decodeBase64 = (value) => {
2
+ const base64 = value
3
+ .replace(/-/g, "+")
4
+ .replace(/_/g, "/")
5
+ .padEnd(Math.ceil(value.length / 4) * 4, "=");
6
+ return Uint8Array.from(atob(base64), (character) => character.charCodeAt(0));
7
+ };
8
+ const encodedRequests = new WeakMap();
9
+ class PaymentRequestCompatibility {
10
+ transport;
11
+ id;
12
+ amount;
13
+ unit;
14
+ mints;
15
+ description;
16
+ singleUse;
17
+ constructor(transport, id, amount, unit, mints, description, singleUse = false) {
18
+ this.transport = transport;
19
+ this.id = id;
20
+ this.amount = amount;
21
+ this.unit = unit;
22
+ this.mints = mints;
23
+ this.description = description;
24
+ this.singleUse = singleUse;
25
+ }
26
+ toRawRequest() {
27
+ return {
28
+ t: this.transport.map((item) => ({ t: item.type, a: item.target, g: item.tags })),
29
+ ...(this.id ? { i: this.id } : {}),
30
+ ...(this.amount ? { a: this.amount } : {}),
31
+ ...(this.unit ? { u: this.unit } : {}),
32
+ ...(this.mints ? { m: this.mints } : {}),
33
+ ...(this.description ? { d: this.description } : {}),
34
+ ...(this.singleUse ? { s: true } : {}),
35
+ };
36
+ }
37
+ toEncodedRequest() {
38
+ return encodedRequests.get(this);
39
+ }
40
+ getTransport(type) {
41
+ return this.transport.find((item) => item.type === type);
42
+ }
43
+ }
44
+ function decodeCbor(data) {
45
+ const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
46
+ const decodeLength = (offset, info) => {
47
+ if (info < 24)
48
+ return [info, offset];
49
+ if (info === 24)
50
+ return [view.getUint8(offset), offset + 1];
51
+ if (info === 25)
52
+ return [view.getUint16(offset), offset + 2];
53
+ if (info === 26)
54
+ return [view.getUint32(offset), offset + 4];
55
+ throw new Error("Unsupported CBOR length");
56
+ };
57
+ const decode = (offset) => {
58
+ const byte = view.getUint8(offset++);
59
+ const type = byte >> 5;
60
+ const info = byte & 0x1f;
61
+ const [length, next] = decodeLength(offset, info);
62
+ if (type === 0)
63
+ return [length, next];
64
+ if (type === 2)
65
+ return [data.slice(next, next + length), next + length];
66
+ if (type === 3)
67
+ return [new TextDecoder().decode(data.slice(next, next + length)), next + length];
68
+ if (type === 4) {
69
+ const values = [];
70
+ let cursor = next;
71
+ for (let index = 0; index < length; index++) {
72
+ const [value, end] = decode(cursor);
73
+ values.push(value);
74
+ cursor = end;
75
+ }
76
+ return [values, cursor];
77
+ }
78
+ if (type === 5) {
79
+ const value = {};
80
+ let cursor = next;
81
+ for (let index = 0; index < length; index++) {
82
+ const [key, keyEnd] = decode(cursor);
83
+ const [item, itemEnd] = decode(keyEnd);
84
+ value[String(key)] = item;
85
+ cursor = itemEnd;
86
+ }
87
+ return [value, cursor];
88
+ }
89
+ if (type === 7 && info >= 20 && info <= 23)
90
+ return [[false, true, null, undefined][info - 20], offset];
91
+ throw new Error("Unsupported CBOR value");
92
+ };
93
+ return decode(0)[0];
94
+ }
95
+ function encodeCbor(value) {
96
+ const output = [];
97
+ const length = (major, value) => {
98
+ if (value < 24)
99
+ output.push((major << 5) | value);
100
+ else if (value < 256)
101
+ output.push((major << 5) | 24, value);
102
+ else if (value < 65536)
103
+ output.push((major << 5) | 25, value >> 8, value & 0xff);
104
+ else
105
+ output.push((major << 5) | 26, value >> 24, (value >> 16) & 0xff, (value >> 8) & 0xff, value & 0xff);
106
+ };
107
+ const encode = (item) => {
108
+ if (typeof item === "number")
109
+ length(0, item);
110
+ else if (typeof item === "string") {
111
+ const bytes = new TextEncoder().encode(item);
112
+ length(3, bytes.length);
113
+ output.push(...bytes);
114
+ }
115
+ else if (item instanceof Uint8Array) {
116
+ length(2, item.length);
117
+ output.push(...item);
118
+ }
119
+ else if (Array.isArray(item)) {
120
+ length(4, item.length);
121
+ item.forEach(encode);
122
+ }
123
+ else if (item && typeof item === "object") {
124
+ const entries = Object.entries(item);
125
+ length(5, entries.length);
126
+ entries.forEach(([key, entry]) => {
127
+ encode(key);
128
+ encode(entry);
129
+ });
130
+ }
131
+ else if (typeof item === "boolean")
132
+ output.push(item ? 0xf5 : 0xf4);
133
+ else
134
+ throw new Error("Unsupported CBOR value");
135
+ };
136
+ encode(value);
137
+ return Uint8Array.from(output);
138
+ }
139
+ const hexToBytes = (hex) => Uint8Array.from(hex.match(/.{1,2}/g) ?? [], (value) => Number.parseInt(value, 16));
1
140
  export async function getPaymentRequestFromHeaders(headers, quite = false) {
2
141
  const header = headers.get("X-Cashu");
3
142
  if (!header) {
@@ -6,9 +145,51 @@ export async function getPaymentRequestFromHeaders(headers, quite = false) {
6
145
  else
7
146
  return undefined;
8
147
  }
9
- const { decodePaymentRequest } = await import("@cashu/cashu-ts");
10
- const request = decodePaymentRequest(header);
11
- // Clear the transport, since NUT-23 is only in-band payments
12
- request.transport = [];
148
+ if (!header.startsWith("creqA"))
149
+ throw new Error("Unsupported cashu payment request");
150
+ const raw = decodeCbor(decodeBase64(header.slice(5)));
151
+ const request = new PaymentRequestCompatibility([], raw.i, raw.a, raw.u, raw.m, raw.d, raw.s);
152
+ encodedRequests.set(request, header);
13
153
  return request;
14
154
  }
155
+ /** Encodes the legacy Cashu token shape used by the deprecated onPayment callback. */
156
+ export function encodePaymentToken(token) {
157
+ const value = token;
158
+ const nonHex = value.proofs.some((proof) => !/^[0-9a-fA-F]+$/.test(proof.id));
159
+ if (nonHex) {
160
+ const json = JSON.stringify({
161
+ token: [{ mint: value.mint, proofs: value.proofs }],
162
+ unit: value.unit,
163
+ memo: value.memo,
164
+ });
165
+ const bytes = new TextEncoder().encode(json);
166
+ let binary = "";
167
+ for (const byte of bytes)
168
+ binary += String.fromCharCode(byte);
169
+ return "cashuA" + btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
170
+ }
171
+ const groups = new Map();
172
+ for (const proof of value.proofs)
173
+ groups.set(proof.id, [...(groups.get(proof.id) ?? []), proof]);
174
+ const template = {
175
+ m: value.mint,
176
+ u: value.unit || "sat",
177
+ t: [...groups].map(([id, proofs]) => ({
178
+ i: hexToBytes(id),
179
+ p: proofs.map((proof) => ({
180
+ a: proof.amount,
181
+ s: proof.secret,
182
+ c: hexToBytes(proof.C),
183
+ ...(proof.dleq
184
+ ? { d: { e: hexToBytes(proof.dleq.e), s: hexToBytes(proof.dleq.s), r: hexToBytes(proof.dleq.r ?? "00") } }
185
+ : {}),
186
+ })),
187
+ })),
188
+ ...(value.memo ? { d: value.memo } : {}),
189
+ };
190
+ const bytes = encodeCbor(template);
191
+ let binary = "";
192
+ for (const byte of bytes)
193
+ binary += String.fromCharCode(byte);
194
+ return "cashuB" + btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
195
+ }
@@ -0,0 +1 @@
1
+ export declare function mergeHeaders(base: HeadersInit, extra: HeadersInit): Headers;
@@ -0,0 +1,5 @@
1
+ export function mergeHeaders(base, extra) {
2
+ const headers = new Headers(base);
3
+ new Headers(extra).forEach((value, name) => headers.set(name, value));
4
+ return headers;
5
+ }
@@ -1,6 +1,6 @@
1
1
  export * from "./blob.js";
2
2
  export * from "./blossom-uri.js";
3
- export * from "./cashu.js";
3
+ export { getPaymentRequestFromHeaders } from "./cashu.js";
4
4
  export * from "./fetch.js";
5
5
  export * from "./signal.js";
6
6
  export * from "./url.js";
@@ -1,6 +1,6 @@
1
1
  export * from "./blob.js";
2
2
  export * from "./blossom-uri.js";
3
- export * from "./cashu.js";
3
+ export { getPaymentRequestFromHeaders } from "./cashu.js";
4
4
  export * from "./fetch.js";
5
5
  export * from "./signal.js";
6
6
  export * from "./url.js";
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "blossom-client-sdk",
3
- "version": "5.0.0",
3
+ "version": "5.1.0",
4
4
  "description": "Client SDK for talking to blossom servers",
5
5
  "type": "module",
6
6
  "main": "./lib/index.js",
@@ -57,13 +57,9 @@
57
57
  "@noble/hashes": "^1.8.0"
58
58
  },
59
59
  "peerDependencies": {
60
- "@cashu/cashu-ts": "^2.4.3",
61
60
  "hls.js": "^1.6.16"
62
61
  },
63
62
  "peerDependenciesMeta": {
64
- "@cashu/cashu-ts": {
65
- "optional": true
66
- },
67
63
  "hls.js": {
68
64
  "optional": true
69
65
  }
@@ -2,6 +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/fetch.js";
5
+ import { mergeHeaders } from "../helpers/headers.js";
5
6
  import { PaymentRequest, PaymentToken, SignedEvent } from "../types.js";
6
7
 
7
8
  export type DeleteOptions<S extends ServerType> = {
@@ -13,12 +14,15 @@ export type DeleteOptions<S extends ServerType> = {
13
14
  authEvents?: Set<SignedEvent>;
14
15
  /** Request timeout */
15
16
  timeout?: number;
17
+ /** Return headers to retry a request rejected with HTTP 402. */
18
+ onPaymentRequired?: (server: S, sha256: string, headers: Headers) => Promise<HeadersInit>;
16
19
  /**
17
20
  * A method used to request payment when deleting
18
21
  * @param server the server requiring payment
19
22
  * @param sha256 the sha256 of the blob being uploaded or mirrored
20
23
  * @param request the payment request
21
24
  */
25
+ /** @deprecated Use onPaymentRequired to handle payment schemes generically. */
22
26
  onPayment?: (server: S, sha256: string, request: PaymentRequest) => Promise<PaymentToken>;
23
27
  /**
24
28
  * A method used to request a signed auth event for a server and sha256
@@ -81,19 +85,19 @@ export async function deleteBlob<S extends ServerType>(server: S, hash: string,
81
85
  break;
82
86
  }
83
87
  case 402: {
84
- if (!opts?.onPayment) throw new Error("Missing payment handler");
85
- const { getEncodedToken } = await import("@cashu/cashu-ts");
86
- const { getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
87
- const request = await getPaymentRequestFromHeaders(res.headers);
88
-
89
- const token = await opts.onPayment(server, hash, request);
90
- const payment = getEncodedToken(token);
88
+ let paymentHeaders: HeadersInit;
89
+ if (opts?.onPaymentRequired) paymentHeaders = await opts.onPaymentRequired(server, hash, res.headers);
90
+ else if (opts?.onPayment) {
91
+ const { encodePaymentToken, getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
92
+ const request = await getPaymentRequestFromHeaders(res.headers);
93
+ paymentHeaders = { "X-Cashu": encodePaymentToken(await opts.onPayment(server, hash, request)) };
94
+ } else throw new Error("Missing payment handler");
91
95
 
92
96
  // Try delete with payment
93
97
  res = await fetchWithTimeout(url, {
94
98
  signal: opts?.signal,
95
99
  method: "DELETE",
96
- headers: { ...headers, "X-Cashu": payment },
100
+ headers: mergeHeaders(headers, paymentHeaders),
97
101
  timeout: opts?.timeout,
98
102
  });
99
103
  break;
@@ -3,6 +3,7 @@ import { PaymentRequest, PaymentToken, SignedEvent } from "../types.js";
3
3
  import HTTPError from "../error.js";
4
4
  import { encodeAuthorizationHeader, getReusableAuthEvent, storeAuthEvent } from "../auth.js";
5
5
  import { fetchWithTimeout } from "../helpers/index.js";
6
+ import { mergeHeaders } from "../helpers/headers.js";
6
7
 
7
8
  export type DownloadOptions<S extends ServerType> = {
8
9
  /** AbortSignal to cancel the action */
@@ -13,12 +14,15 @@ export type DownloadOptions<S extends ServerType> = {
13
14
  authEvents?: Set<SignedEvent>;
14
15
  /** Request timeout */
15
16
  timeout?: number;
17
+ /** Return headers to retry a request rejected with HTTP 402. */
18
+ onPaymentRequired?: (server: S, sha256: string, headers: Headers) => Promise<HeadersInit>;
16
19
  /**
17
20
  * A method used to request payment when downloading
18
21
  * @param server the server requiring payment
19
22
  * @param sha256 the sha256 of the blob being uploaded or mirrored
20
23
  * @param request the payment request
21
24
  */
25
+ /** @deprecated Use onPaymentRequired to handle payment schemes generically. */
22
26
  onPayment?: (server: S, sha256: string, request: PaymentRequest) => Promise<PaymentToken>;
23
27
  /**
24
28
  * A method used to request a signed auth event for a server and sha256
@@ -80,17 +84,17 @@ export async function downloadBlob<S extends ServerType>(server: S, hash: string
80
84
  break;
81
85
  }
82
86
  case 402: {
83
- if (!opts?.onPayment) throw new Error("Missing payment handler");
84
- const { getEncodedToken } = await import("@cashu/cashu-ts");
85
- const { getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
86
- const request = await getPaymentRequestFromHeaders(download.headers);
87
-
88
- const token = await opts.onPayment(server, hash, request);
89
- const payment = getEncodedToken(token);
87
+ let paymentHeaders: HeadersInit;
88
+ if (opts?.onPaymentRequired) paymentHeaders = await opts.onPaymentRequired(server, hash, download.headers);
89
+ else if (opts?.onPayment) {
90
+ const { encodePaymentToken, getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
91
+ const request = await getPaymentRequestFromHeaders(download.headers);
92
+ paymentHeaders = { "X-Cashu": encodePaymentToken(await opts.onPayment(server, hash, request)) };
93
+ } else throw new Error("Missing payment handler");
90
94
 
91
95
  // Try download with payment
92
96
  download = await fetchWithTimeout(url, {
93
- headers: { ...headers, "X-Cashu": payment },
97
+ headers: mergeHeaders(headers, paymentHeaders),
94
98
  signal: opts?.signal,
95
99
  timeout: opts?.timeout,
96
100
  });
@@ -3,6 +3,7 @@ import { ServerType } from "../types.js";
3
3
  import { BlobDescriptor, PaymentRequest, PaymentToken, SignedEvent } from "../types.js";
4
4
  import { encodeAuthorizationHeader, getReusableAuthEvent, storeAuthEvent } from "../auth.js";
5
5
  import { fetchWithTimeout } from "../helpers/index.js";
6
+ import { mergeHeaders } from "../helpers/headers.js";
6
7
 
7
8
  export type ListOptions<S extends ServerType> = {
8
9
  /** AbortSignal to cancel the action */
@@ -17,11 +18,14 @@ export type ListOptions<S extends ServerType> = {
17
18
  limit?: number;
18
19
  since?: number;
19
20
  until?: number;
21
+ /** Return headers to retry a request rejected with HTTP 402. */
22
+ onPaymentRequired?: (server: S, headers: Headers) => Promise<HeadersInit>;
20
23
  /**
21
24
  * A method used to request payment
22
25
  * @param server the server requiring payment
23
26
  * @param request the payment request
24
27
  */
28
+ /** @deprecated Use onPaymentRequired to handle payment schemes generically. */
25
29
  onPayment?: (server: S, request: PaymentRequest) => Promise<PaymentToken>;
26
30
  /**
27
31
  * A method used to request a signed auth event for a server
@@ -83,17 +87,17 @@ export async function listBlobs<S extends ServerType>(
83
87
  break;
84
88
  }
85
89
  case 402: {
86
- if (!opts?.onPayment) throw new Error("Missing payment handler");
87
- const { getEncodedToken } = await import("@cashu/cashu-ts");
88
- const { getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
89
- const request = await getPaymentRequestFromHeaders(list.headers);
90
-
91
- const token = await opts.onPayment(server, request);
92
- const payment = getEncodedToken(token);
90
+ let paymentHeaders: HeadersInit;
91
+ if (opts?.onPaymentRequired) paymentHeaders = await opts.onPaymentRequired(server, list.headers);
92
+ else if (opts?.onPayment) {
93
+ const { encodePaymentToken, getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
94
+ const request = await getPaymentRequestFromHeaders(list.headers);
95
+ paymentHeaders = { "X-Cashu": encodePaymentToken(await opts.onPayment(server, request)) };
96
+ } else throw new Error("Missing payment handler");
93
97
 
94
98
  // Try list with payment
95
99
  list = await fetchWithTimeout(url, {
96
- headers: { ...headers, "X-Cashu": payment },
100
+ headers: mergeHeaders(headers, paymentHeaders),
97
101
  signal: opts?.signal,
98
102
  timeout: opts?.timeout,
99
103
  });
@@ -1,6 +1,7 @@
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 { mergeHeaders } from "../helpers/headers.js";
4
5
  import HTTPError from "../error.js";
5
6
  import { encodeAuthorizationHeader, getReusableAuthEvent, storeAuthEvent } from "../auth.js";
6
7
  import { SignedEvent } from "../types.js";
@@ -87,20 +88,21 @@ export async function uploadMedia<S extends ServerType, B extends UploadType>(
87
88
  break;
88
89
  }
89
90
  case 402: {
90
- if (!opts?.onPayment) throw new Error("Missing payment handler");
91
- const { getEncodedToken } = await import("@cashu/cashu-ts");
92
- const { getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
93
- const request = await getPaymentRequestFromHeaders(firstTry.headers);
94
-
95
- const token = await opts.onPayment(server, sha256, blob, request);
96
- const payment = getEncodedToken(token);
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");
97
99
 
98
100
  // Try upload with payment
99
101
  upload = await fetch(url, {
100
102
  signal: opts?.signal,
101
103
  method: "PUT",
102
104
  body: blob,
103
- headers: { ...headers, "X-Cashu": payment },
105
+ headers: mergeHeaders(headers, paymentHeaders),
104
106
  });
105
107
  break;
106
108
  }
@@ -2,6 +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 { mergeHeaders } from "../helpers/headers.js";
5
6
  import { BlobDescriptor, PaymentRequest, PaymentToken, SignedEvent } from "../types.js";
6
7
 
7
8
  export type MirrorOptions<S extends ServerType> = {
@@ -13,6 +14,8 @@ export type MirrorOptions<S extends ServerType> = {
13
14
  authEvents?: Set<SignedEvent>;
14
15
  /** Request timeout */
15
16
  timeout?: number;
17
+ /** Return headers to retry a request rejected with HTTP 402. */
18
+ onPaymentRequired?: (server: S, sha256: string, blob: BlobDescriptor, headers: Headers) => Promise<HeadersInit>;
16
19
  /**
17
20
  * A method used to request payment when uploading or mirroring a blob
18
21
  * @param server the server requiring payment
@@ -20,6 +23,7 @@ export type MirrorOptions<S extends ServerType> = {
20
23
  * @param blob the original blob
21
24
  * @param request the payment request
22
25
  */
26
+ /** @deprecated Use onPaymentRequired to handle payment schemes generically. */
23
27
  onPayment?: (server: S, sha256: string, blob: BlobDescriptor, request: PaymentRequest) => Promise<PaymentToken>;
24
28
  /**
25
29
  * A method used to request a signed auth event for a server and sha256
@@ -94,20 +98,21 @@ export async function mirrorBlob<S extends ServerType>(
94
98
  break;
95
99
  }
96
100
  case 402: {
97
- if (!opts?.onPayment) throw new Error("Missing payment handler");
98
- const { getEncodedToken } = await import("@cashu/cashu-ts");
99
- const { getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
100
- const request = await getPaymentRequestFromHeaders(mirror.headers);
101
-
102
- const token = await opts.onPayment(server, blob.sha256, blob, request);
103
- const payment = getEncodedToken(token);
101
+ let paymentHeaders: HeadersInit;
102
+ if (opts?.onPaymentRequired)
103
+ paymentHeaders = await opts.onPaymentRequired(server, blob.sha256, blob, mirror.headers);
104
+ else if (opts?.onPayment) {
105
+ const { encodePaymentToken, getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
106
+ const request = await getPaymentRequestFromHeaders(mirror.headers);
107
+ paymentHeaders = { "X-Cashu": encodePaymentToken(await opts.onPayment(server, blob.sha256, blob, request)) };
108
+ } else throw new Error("Missing payment handler");
104
109
 
105
110
  // Try mirror with payment
106
111
  mirror = await fetchWithTimeout(url, {
107
112
  signal: opts?.signal,
108
113
  method: "PUT",
109
114
  body,
110
- headers: { ...headers, "X-Cashu": payment },
115
+ headers: mergeHeaders(headers, paymentHeaders),
111
116
  timeout: opts?.timeout,
112
117
  });
113
118
  break;
@@ -121,6 +121,10 @@ export async function multiServerUpload<S extends ServerType, B extends UploadTy
121
121
  if (!options.onPayment) throw new Error("Missing payment handler");
122
122
  return options.onPayment(server, sha256, blob, request);
123
123
  };
124
+ const handlePaymentRequired = (server: S, sha256: string, _blob: any, headers: Headers) => {
125
+ if (!options.onPaymentRequired) throw new Error("Missing payment handler");
126
+ return options.onPaymentRequired(server, sha256, blob, headers);
127
+ };
124
128
 
125
129
  const handleRejection = async (server: S, sha256: string, error: unknown): Promise<RejectionAction | false> => {
126
130
  if (!HTTPError.isRejection(error)) return false;
@@ -179,6 +183,7 @@ export async function multiServerUpload<S extends ServerType, B extends UploadTy
179
183
  auth: typeof options.auth === "boolean" ? options.auth : undefined,
180
184
  onAuth: (server, sha256) => handleAuthRequest(server, sha256, "upload"),
181
185
  onPayment: handlePaymentRequest,
186
+ onPaymentRequired: options.onPaymentRequired ? handlePaymentRequired : undefined,
182
187
  timeout: options.mirrorTimeout,
183
188
  });
184
189
  } catch (error) {
@@ -196,6 +201,7 @@ export async function multiServerUpload<S extends ServerType, B extends UploadTy
196
201
  auth: typeof options.auth === "boolean" ? options.auth : undefined,
197
202
  onAuth: handleAuthRequest,
198
203
  onPayment: handlePaymentRequest,
204
+ onPaymentRequired: options.onPaymentRequired ? handlePaymentRequired : undefined,
199
205
  timeout: options.mirrorTimeout,
200
206
  });
201
207
 
@@ -259,6 +265,10 @@ export async function multiServerMediaUpload<S extends ServerType, B extends Upl
259
265
  if (!options.onPayment) throw new Error("Missing payment handler");
260
266
  return options.onPayment(server, sha256, blob, request);
261
267
  };
268
+ const handlePaymentRequired = (server: S, sha256: string, _blob: any, headers: Headers) => {
269
+ if (!options.onPaymentRequired) throw new Error("Missing payment handler");
270
+ return options.onPaymentRequired(server, sha256, blob, headers);
271
+ };
262
272
 
263
273
  const handleRejection = async (server: S, sha256: string, error: unknown): Promise<RejectionAction | false> => {
264
274
  if (!HTTPError.isRejection(error)) return false;
@@ -285,6 +295,7 @@ export async function multiServerMediaUpload<S extends ServerType, B extends Upl
285
295
  auth: typeof options.auth === "boolean" ? options.auth : undefined,
286
296
  onAuth: handleAuthRequest,
287
297
  onPayment: handlePaymentRequest,
298
+ onPaymentRequired: options.onPaymentRequired ? handlePaymentRequired : undefined,
288
299
  });
289
300
 
290
301
  results.set(server, initialUpload);
@@ -348,6 +359,7 @@ export async function multiServerMediaUpload<S extends ServerType, B extends Upl
348
359
  auth: typeof options.auth === "boolean" ? options.auth : undefined,
349
360
  onAuth: (server, sha256) => handleAuthRequest(server, sha256, "upload"),
350
361
  onPayment: handlePaymentRequest,
362
+ onPaymentRequired: options.onPaymentRequired ? handlePaymentRequired : undefined,
351
363
  timeout: options.mirrorTimeout,
352
364
  });
353
365
 
@@ -2,6 +2,7 @@ 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 { mergeHeaders } from "../helpers/headers.js";
5
6
  import { BlobDescriptor, PaymentRequest, PaymentToken, SignedEvent } from "../types.js";
6
7
 
7
8
  export type UploadOptions<S extends ServerType, B extends UploadType> = {
@@ -13,6 +14,8 @@ export type UploadOptions<S extends ServerType, B extends UploadType> = {
13
14
  authEvents?: Set<SignedEvent>;
14
15
  /** Request timeout */
15
16
  timeout?: number;
17
+ /** Return headers to retry a request rejected with HTTP 402. */
18
+ onPaymentRequired?: (server: S, sha256: string, blob: B, headers: Headers) => Promise<HeadersInit>;
16
19
  /**
17
20
  * A method used to request payment when uploading or mirroring a blob
18
21
  * @param server the server requiring payment
@@ -20,6 +23,7 @@ export type UploadOptions<S extends ServerType, B extends UploadType> = {
20
23
  * @param blob the original blob
21
24
  * @param request the payment request
22
25
  */
26
+ /** @deprecated Use onPaymentRequired to handle payment schemes generically. */
23
27
  onPayment?: (server: S, sha256: string, blob: B, request: PaymentRequest) => Promise<PaymentToken>;
24
28
  /**
25
29
  * A method used to request a signed auth event for a server and sha256
@@ -112,19 +116,20 @@ export async function uploadBlob<S extends ServerType, B extends UploadType>(
112
116
  break;
113
117
  }
114
118
  case 402: {
115
- if (!opts?.onPayment) throw new Error("Missing payment handler");
116
- const { getEncodedToken } = await import("@cashu/cashu-ts");
117
- const { getPaymentRequestFromHeaders } = await import("../helpers/cashu.js");
118
- const request = await getPaymentRequestFromHeaders(firstTry.headers);
119
-
120
- const token = await opts.onPayment(server, sha256, blob, request);
121
- const payment = getEncodedToken(token);
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");
122
127
 
123
128
  // Try upload with payment
124
129
  upload = await fetchWithTimeout(url, {
125
130
  method: "PUT",
126
131
  body: blob,
127
- headers: { ...headers, "X-Cashu": payment },
132
+ headers: mergeHeaders(headers, paymentHeaders),
128
133
  signal: opts?.signal,
129
134
  timeout: opts?.timeout,
130
135
  });
@@ -1,21 +1,198 @@
1
1
  import { PaymentRequest } from "../types.js";
2
2
 
3
- /** Extracts a cashu-ts PaymentRequest from Headers. Loads @cashu/cashu-ts on demand. */
3
+ const decodeBase64 = (value: string) => {
4
+ const base64 = value
5
+ .replace(/-/g, "+")
6
+ .replace(/_/g, "/")
7
+ .padEnd(Math.ceil(value.length / 4) * 4, "=");
8
+ return Uint8Array.from(atob(base64), (character) => character.charCodeAt(0));
9
+ };
10
+ const encodedRequests = new WeakMap<object, string>();
11
+
12
+ class PaymentRequestCompatibility implements PaymentRequest {
13
+ constructor(
14
+ public transport: PaymentRequest["transport"],
15
+ public id?: string,
16
+ public amount?: number,
17
+ public unit?: string,
18
+ public mints?: string[],
19
+ public description?: string,
20
+ public singleUse = false,
21
+ ) {}
22
+
23
+ toRawRequest(): ReturnType<PaymentRequest["toRawRequest"]> {
24
+ return {
25
+ t: this.transport.map((item) => ({ t: item.type, a: item.target, g: item.tags })),
26
+ ...(this.id ? { i: this.id } : {}),
27
+ ...(this.amount ? { a: this.amount } : {}),
28
+ ...(this.unit ? { u: this.unit } : {}),
29
+ ...(this.mints ? { m: this.mints } : {}),
30
+ ...(this.description ? { d: this.description } : {}),
31
+ ...(this.singleUse ? { s: true } : {}),
32
+ };
33
+ }
34
+
35
+ toEncodedRequest() {
36
+ return encodedRequests.get(this)!;
37
+ }
38
+
39
+ getTransport(type: string) {
40
+ return this.transport.find((item) => item.type === type);
41
+ }
42
+ }
43
+
44
+ function decodeCbor(data: Uint8Array): unknown {
45
+ const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
46
+
47
+ const decodeLength = (offset: number, info: number): [number, number] => {
48
+ if (info < 24) return [info, offset];
49
+ if (info === 24) return [view.getUint8(offset), offset + 1];
50
+ if (info === 25) return [view.getUint16(offset), offset + 2];
51
+ if (info === 26) return [view.getUint32(offset), offset + 4];
52
+ throw new Error("Unsupported CBOR length");
53
+ };
54
+
55
+ const decode = (offset: number): [unknown, number] => {
56
+ const byte = view.getUint8(offset++);
57
+ const type = byte >> 5;
58
+ const info = byte & 0x1f;
59
+ const [length, next] = decodeLength(offset, info);
60
+
61
+ if (type === 0) return [length, next];
62
+ if (type === 2) return [data.slice(next, next + length), next + length];
63
+ if (type === 3) return [new TextDecoder().decode(data.slice(next, next + length)), next + length];
64
+ if (type === 4) {
65
+ const values: unknown[] = [];
66
+ let cursor = next;
67
+ for (let index = 0; index < length; index++) {
68
+ const [value, end] = decode(cursor);
69
+ values.push(value);
70
+ cursor = end;
71
+ }
72
+ return [values, cursor];
73
+ }
74
+ if (type === 5) {
75
+ const value: Record<string, unknown> = {};
76
+ let cursor = next;
77
+ for (let index = 0; index < length; index++) {
78
+ const [key, keyEnd] = decode(cursor);
79
+ const [item, itemEnd] = decode(keyEnd);
80
+ value[String(key)] = item;
81
+ cursor = itemEnd;
82
+ }
83
+ return [value, cursor];
84
+ }
85
+ if (type === 7 && info >= 20 && info <= 23) return [[false, true, null, undefined][info - 20], offset];
86
+ throw new Error("Unsupported CBOR value");
87
+ };
88
+
89
+ return decode(0)[0];
90
+ }
91
+
92
+ function encodeCbor(value: unknown): Uint8Array {
93
+ const output: number[] = [];
94
+ const length = (major: number, value: number) => {
95
+ if (value < 24) output.push((major << 5) | value);
96
+ else if (value < 256) output.push((major << 5) | 24, value);
97
+ else if (value < 65536) output.push((major << 5) | 25, value >> 8, value & 0xff);
98
+ else output.push((major << 5) | 26, value >> 24, (value >> 16) & 0xff, (value >> 8) & 0xff, value & 0xff);
99
+ };
100
+ const encode = (item: unknown) => {
101
+ if (typeof item === "number") length(0, item);
102
+ else if (typeof item === "string") {
103
+ const bytes = new TextEncoder().encode(item);
104
+ length(3, bytes.length);
105
+ output.push(...bytes);
106
+ } else if (item instanceof Uint8Array) {
107
+ length(2, item.length);
108
+ output.push(...item);
109
+ } else if (Array.isArray(item)) {
110
+ length(4, item.length);
111
+ item.forEach(encode);
112
+ } else if (item && typeof item === "object") {
113
+ const entries = Object.entries(item);
114
+ length(5, entries.length);
115
+ entries.forEach(([key, entry]) => {
116
+ encode(key);
117
+ encode(entry);
118
+ });
119
+ } else if (typeof item === "boolean") output.push(item ? 0xf5 : 0xf4);
120
+ else throw new Error("Unsupported CBOR value");
121
+ };
122
+ encode(value);
123
+ return Uint8Array.from(output);
124
+ }
125
+
126
+ const hexToBytes = (hex: string) => Uint8Array.from(hex.match(/.{1,2}/g) ?? [], (value) => Number.parseInt(value, 16));
127
+
128
+ /** Extracts a Cashu PaymentRequest-compatible object from Headers. */
4
129
  export async function getPaymentRequestFromHeaders(headers: Headers): Promise<PaymentRequest>;
5
130
  export async function getPaymentRequestFromHeaders(headers: Headers, quite: false): Promise<PaymentRequest>;
6
131
  export async function getPaymentRequestFromHeaders(headers: Headers, quite: true): Promise<PaymentRequest | undefined>;
7
- export async function getPaymentRequestFromHeaders(headers: Headers, quite = false) {
132
+ export async function getPaymentRequestFromHeaders(
133
+ headers: Headers,
134
+ quite = false,
135
+ ): Promise<PaymentRequest | undefined> {
8
136
  const header = headers.get("X-Cashu");
9
137
  if (!header) {
10
138
  if (!quite) throw new Error("Missing cashu header");
11
139
  else return undefined;
12
140
  }
13
141
 
14
- const { decodePaymentRequest } = await import("@cashu/cashu-ts");
15
- const request = decodePaymentRequest(header) as PaymentRequest;
142
+ if (!header.startsWith("creqA")) throw new Error("Unsupported cashu payment request");
143
+ const raw = decodeCbor(decodeBase64(header.slice(5))) as ReturnType<PaymentRequest["toRawRequest"]>;
144
+ const request = new PaymentRequestCompatibility([], raw.i, raw.a, raw.u, raw.m, raw.d, raw.s);
145
+ encodedRequests.set(request, header);
146
+ return request;
147
+ }
16
148
 
17
- // Clear the transport, since NUT-23 is only in-band payments
18
- request.transport = [];
149
+ /** Encodes the legacy Cashu token shape used by the deprecated onPayment callback. */
150
+ export function encodePaymentToken(token: unknown): string {
151
+ const value = token as {
152
+ mint: string;
153
+ unit?: string;
154
+ memo?: string;
155
+ proofs: Array<{
156
+ id: string;
157
+ amount: number;
158
+ secret: string;
159
+ C: string;
160
+ dleq?: { e: string; s: string; r?: string };
161
+ }>;
162
+ };
163
+ const nonHex = value.proofs.some((proof) => !/^[0-9a-fA-F]+$/.test(proof.id));
164
+ if (nonHex) {
165
+ const json = JSON.stringify({
166
+ token: [{ mint: value.mint, proofs: value.proofs }],
167
+ unit: value.unit,
168
+ memo: value.memo,
169
+ });
170
+ const bytes = new TextEncoder().encode(json);
171
+ let binary = "";
172
+ for (const byte of bytes) binary += String.fromCharCode(byte);
173
+ return "cashuA" + btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
174
+ }
19
175
 
20
- return request;
176
+ const groups = new Map<string, typeof value.proofs>();
177
+ for (const proof of value.proofs) groups.set(proof.id, [...(groups.get(proof.id) ?? []), proof]);
178
+ const template = {
179
+ m: value.mint,
180
+ u: value.unit || "sat",
181
+ t: [...groups].map(([id, proofs]) => ({
182
+ i: hexToBytes(id),
183
+ p: proofs.map((proof) => ({
184
+ a: proof.amount,
185
+ s: proof.secret,
186
+ c: hexToBytes(proof.C),
187
+ ...(proof.dleq
188
+ ? { d: { e: hexToBytes(proof.dleq.e), s: hexToBytes(proof.dleq.s), r: hexToBytes(proof.dleq.r ?? "00") } }
189
+ : {}),
190
+ })),
191
+ })),
192
+ ...(value.memo ? { d: value.memo } : {}),
193
+ };
194
+ const bytes = encodeCbor(template);
195
+ let binary = "";
196
+ for (const byte of bytes) binary += String.fromCharCode(byte);
197
+ return "cashuB" + btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
21
198
  }
@@ -0,0 +1,5 @@
1
+ export function mergeHeaders(base: HeadersInit, extra: HeadersInit): Headers {
2
+ const headers = new Headers(base);
3
+ new Headers(extra).forEach((value, name) => headers.set(name, value));
4
+ return headers;
5
+ }
@@ -1,6 +1,6 @@
1
1
  export * from "./blob.js";
2
2
  export * from "./blossom-uri.js";
3
- export * from "./cashu.js";
3
+ export { getPaymentRequestFromHeaders } from "./cashu.js";
4
4
  export * from "./fetch.js";
5
5
  export * from "./signal.js";
6
6
  export * from "./url.js";
package/src/types.ts CHANGED
@@ -40,8 +40,7 @@ export type BlobDescriptor = {
40
40
 
41
41
  export type RejectionAction = "skip" | "cancel";
42
42
 
43
- // NOTE: structural copies of cashu-ts types so @cashu/cashu-ts can stay an
44
- // optional peer dependency. Keep field shapes in sync with cashu-ts upstream.
43
+ // NOTE: structural copies retained for compatibility with the deprecated Cashu payment handlers.
45
44
 
46
45
  export type PaymentRequestTransport = {
47
46
  type: string;