@moonpay/platform-sdk-web 0.0.0 → 0.2.1
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/index.cjs +690 -0
- package/dist/index.cjs.map +1 -0
- package/dist/index.d.cts +163 -0
- package/dist/index.d.ts +163 -0
- package/dist/index.js +673 -0
- package/dist/index.js.map +1 -0
- package/package.json +38 -5
- package/README.md +0 -3
- package/index.js +0 -1
package/dist/index.js
ADDED
|
@@ -0,0 +1,673 @@
|
|
|
1
|
+
// src/client.ts
|
|
2
|
+
import {
|
|
3
|
+
ConnectionStatus,
|
|
4
|
+
err,
|
|
5
|
+
ok
|
|
6
|
+
} from "@moonpay/platform-protocol";
|
|
7
|
+
import {
|
|
8
|
+
buildFrameUrl,
|
|
9
|
+
createClientCore,
|
|
10
|
+
createFrameOrchestrator,
|
|
11
|
+
decryptCredentials,
|
|
12
|
+
FRAME_PATHS,
|
|
13
|
+
generateKeyPair
|
|
14
|
+
} from "@moonpay/platform-sdk-core";
|
|
15
|
+
|
|
16
|
+
// src/iframe-transport.ts
|
|
17
|
+
var ALLOWED_ORIGIN_PATTERNS = [
|
|
18
|
+
/^https:\/\/([a-zA-Z0-9-]+\.)*moonpay\.com$/,
|
|
19
|
+
/^https:\/\/([a-zA-Z0-9-]+\.)*moonpaycloud\.com$/,
|
|
20
|
+
/^https:\/\/([a-zA-Z0-9-]+\.)*preview\.moonpay-dev\.com$/,
|
|
21
|
+
/^http:\/\/localhost(:\d+)?$/
|
|
22
|
+
];
|
|
23
|
+
function isAllowedOrigin(origin) {
|
|
24
|
+
return ALLOWED_ORIGIN_PATTERNS.some((pattern) => pattern.test(origin));
|
|
25
|
+
}
|
|
26
|
+
var IframeTransport = class {
|
|
27
|
+
iframe = null;
|
|
28
|
+
container = null;
|
|
29
|
+
trustedOrigin = null;
|
|
30
|
+
handlers = [];
|
|
31
|
+
boundListener = null;
|
|
32
|
+
create(url, options) {
|
|
33
|
+
const container = options.container;
|
|
34
|
+
this.container = container;
|
|
35
|
+
const iframe = document.createElement("iframe");
|
|
36
|
+
iframe.src = url;
|
|
37
|
+
iframe.style.border = "none";
|
|
38
|
+
if (options.hidden) {
|
|
39
|
+
iframe.style.width = "0";
|
|
40
|
+
iframe.style.height = "0";
|
|
41
|
+
iframe.style.position = "absolute";
|
|
42
|
+
iframe.style.overflow = "hidden";
|
|
43
|
+
} else {
|
|
44
|
+
iframe.style.width = "100%";
|
|
45
|
+
iframe.style.height = "100%";
|
|
46
|
+
}
|
|
47
|
+
iframe.allow = "accelerometer; autoplay; camera; encrypted-media; gyroscope; payment";
|
|
48
|
+
this.iframe = iframe;
|
|
49
|
+
this.boundListener = this.handleMessage.bind(this);
|
|
50
|
+
window.addEventListener("message", this.boundListener);
|
|
51
|
+
container.appendChild(iframe);
|
|
52
|
+
}
|
|
53
|
+
sendMessage(message) {
|
|
54
|
+
if (!this.iframe?.contentWindow) {
|
|
55
|
+
throw new Error("Cannot send message: iframe not initialized");
|
|
56
|
+
}
|
|
57
|
+
if (!this.trustedOrigin) {
|
|
58
|
+
throw new Error("Cannot send message: no trusted origin established");
|
|
59
|
+
}
|
|
60
|
+
this.iframe.contentWindow.postMessage(JSON.stringify(message), this.trustedOrigin);
|
|
61
|
+
}
|
|
62
|
+
onMessage(handler) {
|
|
63
|
+
this.handlers.push(handler);
|
|
64
|
+
return () => {
|
|
65
|
+
const idx = this.handlers.indexOf(handler);
|
|
66
|
+
if (idx >= 0)
|
|
67
|
+
this.handlers.splice(idx, 1);
|
|
68
|
+
};
|
|
69
|
+
}
|
|
70
|
+
dispose() {
|
|
71
|
+
if (this.boundListener) {
|
|
72
|
+
window.removeEventListener("message", this.boundListener);
|
|
73
|
+
this.boundListener = null;
|
|
74
|
+
}
|
|
75
|
+
this.handlers.length = 0;
|
|
76
|
+
if (this.iframe && this.container?.contains(this.iframe)) {
|
|
77
|
+
this.iframe.remove();
|
|
78
|
+
}
|
|
79
|
+
this.iframe = null;
|
|
80
|
+
this.container = null;
|
|
81
|
+
this.trustedOrigin = null;
|
|
82
|
+
}
|
|
83
|
+
// ---------------------------------------------------------------------------
|
|
84
|
+
// Private
|
|
85
|
+
// ---------------------------------------------------------------------------
|
|
86
|
+
handleMessage(event) {
|
|
87
|
+
if (!isAllowedOrigin(event.origin))
|
|
88
|
+
return;
|
|
89
|
+
let msg;
|
|
90
|
+
try {
|
|
91
|
+
msg = typeof event.data === "string" ? JSON.parse(event.data) : event.data;
|
|
92
|
+
if (!msg.kind)
|
|
93
|
+
return;
|
|
94
|
+
} catch {
|
|
95
|
+
return;
|
|
96
|
+
}
|
|
97
|
+
if (!this.trustedOrigin) {
|
|
98
|
+
this.trustedOrigin = event.origin;
|
|
99
|
+
} else if (event.origin !== this.trustedOrigin) {
|
|
100
|
+
return;
|
|
101
|
+
}
|
|
102
|
+
for (const handler of this.handlers) {
|
|
103
|
+
handler(msg);
|
|
104
|
+
}
|
|
105
|
+
}
|
|
106
|
+
};
|
|
107
|
+
|
|
108
|
+
// src/client.ts
|
|
109
|
+
function createClient(options) {
|
|
110
|
+
const { sessionToken, apiBaseUrl, frameBaseUrl } = options;
|
|
111
|
+
const core = createClientCore({
|
|
112
|
+
apiBaseUrl,
|
|
113
|
+
frameBaseUrl,
|
|
114
|
+
createTransport: () => new IframeTransport()
|
|
115
|
+
});
|
|
116
|
+
async function getConnection() {
|
|
117
|
+
const { privateKey, publicKey } = generateKeyPair();
|
|
118
|
+
const channelId = `check-${crypto.randomUUID()}`;
|
|
119
|
+
const url = buildFrameUrl(
|
|
120
|
+
FRAME_PATHS.checkConnection,
|
|
121
|
+
{ sessionToken, channelId, publicKey },
|
|
122
|
+
{ frameBaseUrl }
|
|
123
|
+
);
|
|
124
|
+
const transport = core.createTransport();
|
|
125
|
+
try {
|
|
126
|
+
const handle = await createFrameOrchestrator({
|
|
127
|
+
transport,
|
|
128
|
+
channelId,
|
|
129
|
+
url,
|
|
130
|
+
container: document.body,
|
|
131
|
+
hidden: true,
|
|
132
|
+
handshakeTimeout: 1e4
|
|
133
|
+
});
|
|
134
|
+
return new Promise((resolve) => {
|
|
135
|
+
const timeout = setTimeout(() => {
|
|
136
|
+
handle.dispose();
|
|
137
|
+
resolve(err({ message: "Get connection timed out" }));
|
|
138
|
+
}, 1e4);
|
|
139
|
+
handle.onMessage((msg) => {
|
|
140
|
+
if (msg.kind === "error") {
|
|
141
|
+
clearTimeout(timeout);
|
|
142
|
+
handle.dispose();
|
|
143
|
+
const payload = msg.payload;
|
|
144
|
+
resolve(err({ message: payload.message }));
|
|
145
|
+
return;
|
|
146
|
+
}
|
|
147
|
+
if (msg.kind === "complete") {
|
|
148
|
+
clearTimeout(timeout);
|
|
149
|
+
handle.dispose();
|
|
150
|
+
const connection = msg.payload;
|
|
151
|
+
if (connection.status === ConnectionStatus.active) {
|
|
152
|
+
const creds = decryptCredentials(connection.credentials, privateKey);
|
|
153
|
+
core.context.setAccessToken(creds.accessToken);
|
|
154
|
+
core.context.setClientToken(creds.clientToken);
|
|
155
|
+
} else if (connection.status === ConnectionStatus.connectionRequired) {
|
|
156
|
+
const creds = decryptCredentials(connection.credentials, privateKey);
|
|
157
|
+
core.context.setAccessToken(creds.accessToken);
|
|
158
|
+
core.context.setClientToken(creds.clientToken);
|
|
159
|
+
}
|
|
160
|
+
resolve(ok(connection));
|
|
161
|
+
}
|
|
162
|
+
});
|
|
163
|
+
});
|
|
164
|
+
} catch (e) {
|
|
165
|
+
return err({
|
|
166
|
+
message: e instanceof Error ? e.message : "Failed to connect"
|
|
167
|
+
});
|
|
168
|
+
}
|
|
169
|
+
}
|
|
170
|
+
async function connect(opts) {
|
|
171
|
+
const { privateKey, publicKey } = generateKeyPair();
|
|
172
|
+
const channelId = `connect-${crypto.randomUUID()}`;
|
|
173
|
+
const url = buildFrameUrl(
|
|
174
|
+
FRAME_PATHS.connect,
|
|
175
|
+
{
|
|
176
|
+
sessionToken,
|
|
177
|
+
channelId,
|
|
178
|
+
publicKey,
|
|
179
|
+
...opts.theme?.appearance && { appearance: opts.theme.appearance }
|
|
180
|
+
},
|
|
181
|
+
{ frameBaseUrl }
|
|
182
|
+
);
|
|
183
|
+
const transport = core.createTransport();
|
|
184
|
+
try {
|
|
185
|
+
const handle = await createFrameOrchestrator({
|
|
186
|
+
transport,
|
|
187
|
+
channelId,
|
|
188
|
+
url,
|
|
189
|
+
container: opts.container
|
|
190
|
+
});
|
|
191
|
+
return new Promise((resolve) => {
|
|
192
|
+
handle.onMessage((msg) => {
|
|
193
|
+
if (msg.kind === "ready") {
|
|
194
|
+
opts.onEvent?.({ kind: "ready" });
|
|
195
|
+
return;
|
|
196
|
+
}
|
|
197
|
+
if (msg.kind === "error") {
|
|
198
|
+
const payload = msg.payload;
|
|
199
|
+
opts.onEvent?.({ kind: "error", payload });
|
|
200
|
+
handle.dispose();
|
|
201
|
+
resolve(err({ message: "Connection error" }));
|
|
202
|
+
return;
|
|
203
|
+
}
|
|
204
|
+
if (msg.kind === "complete") {
|
|
205
|
+
const connection = msg.payload;
|
|
206
|
+
if (connection.status === ConnectionStatus.active) {
|
|
207
|
+
const creds = decryptCredentials(connection.credentials, privateKey);
|
|
208
|
+
core.context.setAccessToken(creds.accessToken);
|
|
209
|
+
core.context.setClientToken(creds.clientToken);
|
|
210
|
+
}
|
|
211
|
+
opts.onEvent?.({ kind: "complete", payload: connection });
|
|
212
|
+
resolve(ok({ dispose: () => handle.dispose() }));
|
|
213
|
+
}
|
|
214
|
+
});
|
|
215
|
+
});
|
|
216
|
+
} catch (e) {
|
|
217
|
+
return err({
|
|
218
|
+
message: e instanceof Error ? e.message : "Connect failed"
|
|
219
|
+
});
|
|
220
|
+
}
|
|
221
|
+
}
|
|
222
|
+
async function setupWidget(opts) {
|
|
223
|
+
const channelId = `widget-${crypto.randomUUID()}`;
|
|
224
|
+
const url = buildFrameUrl(
|
|
225
|
+
FRAME_PATHS.widget,
|
|
226
|
+
{
|
|
227
|
+
flow: "buy",
|
|
228
|
+
clientToken: core.context.clientToken,
|
|
229
|
+
quoteSignature: opts.quote,
|
|
230
|
+
channelId
|
|
231
|
+
},
|
|
232
|
+
{ frameBaseUrl }
|
|
233
|
+
);
|
|
234
|
+
const transport = core.createTransport();
|
|
235
|
+
try {
|
|
236
|
+
const handle = await createFrameOrchestrator({
|
|
237
|
+
transport,
|
|
238
|
+
channelId,
|
|
239
|
+
url,
|
|
240
|
+
container: opts.container
|
|
241
|
+
});
|
|
242
|
+
handle.onMessage((msg) => {
|
|
243
|
+
switch (msg.kind) {
|
|
244
|
+
case "ready":
|
|
245
|
+
opts.onEvent?.({ kind: "ready" });
|
|
246
|
+
break;
|
|
247
|
+
case "transactionCreated":
|
|
248
|
+
opts.onEvent?.({
|
|
249
|
+
kind: "transactionCreated",
|
|
250
|
+
payload: msg.payload
|
|
251
|
+
});
|
|
252
|
+
break;
|
|
253
|
+
case "complete":
|
|
254
|
+
opts.onEvent?.({
|
|
255
|
+
kind: "complete",
|
|
256
|
+
payload: msg.payload
|
|
257
|
+
});
|
|
258
|
+
break;
|
|
259
|
+
case "error": {
|
|
260
|
+
const payload = msg.payload;
|
|
261
|
+
opts.onEvent?.({
|
|
262
|
+
kind: "error",
|
|
263
|
+
payload: {
|
|
264
|
+
code: payload.code,
|
|
265
|
+
message: payload.message
|
|
266
|
+
}
|
|
267
|
+
});
|
|
268
|
+
break;
|
|
269
|
+
}
|
|
270
|
+
case "close":
|
|
271
|
+
opts.onEvent?.({ kind: "close" });
|
|
272
|
+
break;
|
|
273
|
+
}
|
|
274
|
+
});
|
|
275
|
+
return ok({ dispose: () => handle.dispose() });
|
|
276
|
+
} catch (e) {
|
|
277
|
+
return err({
|
|
278
|
+
kind: "genericError",
|
|
279
|
+
message: e instanceof Error ? e.message : "Widget setup failed"
|
|
280
|
+
});
|
|
281
|
+
}
|
|
282
|
+
}
|
|
283
|
+
async function setupApplePay(opts) {
|
|
284
|
+
const channelId = `applepay-${crypto.randomUUID()}`;
|
|
285
|
+
const url = buildFrameUrl(
|
|
286
|
+
FRAME_PATHS.applePay,
|
|
287
|
+
{
|
|
288
|
+
clientToken: core.context.clientToken,
|
|
289
|
+
signature: opts.quote,
|
|
290
|
+
channelId
|
|
291
|
+
},
|
|
292
|
+
{ frameBaseUrl }
|
|
293
|
+
);
|
|
294
|
+
const transport = core.createTransport();
|
|
295
|
+
try {
|
|
296
|
+
const handle = await createFrameOrchestrator({
|
|
297
|
+
transport,
|
|
298
|
+
channelId,
|
|
299
|
+
url,
|
|
300
|
+
container: opts.container
|
|
301
|
+
});
|
|
302
|
+
const setQuote = (signature) => {
|
|
303
|
+
handle.sendMessage({
|
|
304
|
+
version: 2,
|
|
305
|
+
meta: { channelId },
|
|
306
|
+
kind: "setQuote",
|
|
307
|
+
payload: { quote: { signature } }
|
|
308
|
+
});
|
|
309
|
+
};
|
|
310
|
+
handle.onMessage((msg) => {
|
|
311
|
+
switch (msg.kind) {
|
|
312
|
+
case "ready":
|
|
313
|
+
opts.onEvent?.({ kind: "ready" });
|
|
314
|
+
break;
|
|
315
|
+
case "complete":
|
|
316
|
+
opts.onEvent?.({
|
|
317
|
+
kind: "complete",
|
|
318
|
+
payload: msg.payload
|
|
319
|
+
});
|
|
320
|
+
break;
|
|
321
|
+
case "error": {
|
|
322
|
+
const payload = msg.payload;
|
|
323
|
+
if (payload.code === "quoteExpired") {
|
|
324
|
+
opts.onEvent?.({
|
|
325
|
+
kind: "quoteExpired",
|
|
326
|
+
payload: { setQuote }
|
|
327
|
+
});
|
|
328
|
+
} else if (payload.code === "applePayUnavailable") {
|
|
329
|
+
opts.onEvent?.({ kind: "unsupported" });
|
|
330
|
+
} else {
|
|
331
|
+
const kind = payload.code === "generic" ? "genericError" : payload.code;
|
|
332
|
+
opts.onEvent?.({
|
|
333
|
+
kind: "error",
|
|
334
|
+
payload: { kind, message: payload.message }
|
|
335
|
+
});
|
|
336
|
+
}
|
|
337
|
+
break;
|
|
338
|
+
}
|
|
339
|
+
}
|
|
340
|
+
});
|
|
341
|
+
return ok({ setQuote, dispose: () => handle.dispose() });
|
|
342
|
+
} catch (e) {
|
|
343
|
+
return err({
|
|
344
|
+
kind: "genericError",
|
|
345
|
+
message: e instanceof Error ? e.message : "Apple Pay setup failed"
|
|
346
|
+
});
|
|
347
|
+
}
|
|
348
|
+
}
|
|
349
|
+
async function setupGooglePay(opts) {
|
|
350
|
+
const channelId = `googlepay-${crypto.randomUUID()}`;
|
|
351
|
+
const url = buildFrameUrl(
|
|
352
|
+
FRAME_PATHS.googlePay,
|
|
353
|
+
{
|
|
354
|
+
clientToken: core.context.clientToken,
|
|
355
|
+
signature: opts.quote,
|
|
356
|
+
channelId,
|
|
357
|
+
...opts.externalTransactionId && { externalTransactionId: opts.externalTransactionId }
|
|
358
|
+
},
|
|
359
|
+
{ frameBaseUrl }
|
|
360
|
+
);
|
|
361
|
+
const transport = core.createTransport();
|
|
362
|
+
try {
|
|
363
|
+
const handle = await createFrameOrchestrator({
|
|
364
|
+
transport,
|
|
365
|
+
channelId,
|
|
366
|
+
url,
|
|
367
|
+
container: opts.container
|
|
368
|
+
});
|
|
369
|
+
const setQuote = (signature) => {
|
|
370
|
+
handle.sendMessage({
|
|
371
|
+
version: 2,
|
|
372
|
+
meta: { channelId },
|
|
373
|
+
kind: "setQuote",
|
|
374
|
+
payload: { quote: { signature } }
|
|
375
|
+
});
|
|
376
|
+
};
|
|
377
|
+
handle.onMessage((msg) => {
|
|
378
|
+
switch (msg.kind) {
|
|
379
|
+
case "ready":
|
|
380
|
+
opts.onEvent?.({ kind: "ready" });
|
|
381
|
+
break;
|
|
382
|
+
case "complete":
|
|
383
|
+
opts.onEvent?.({
|
|
384
|
+
kind: "complete",
|
|
385
|
+
payload: msg.payload
|
|
386
|
+
});
|
|
387
|
+
break;
|
|
388
|
+
case "challenge":
|
|
389
|
+
opts.onEvent?.({
|
|
390
|
+
kind: "challenge",
|
|
391
|
+
payload: msg.payload
|
|
392
|
+
});
|
|
393
|
+
break;
|
|
394
|
+
case "error": {
|
|
395
|
+
const payload = msg.payload;
|
|
396
|
+
if (payload.code === "quoteExpired") {
|
|
397
|
+
opts.onEvent?.({
|
|
398
|
+
kind: "quoteExpired",
|
|
399
|
+
payload: { setQuote }
|
|
400
|
+
});
|
|
401
|
+
} else if (payload.code === "googlePayUnavailable") {
|
|
402
|
+
opts.onEvent?.({ kind: "unsupported" });
|
|
403
|
+
} else {
|
|
404
|
+
const kind = payload.code === "generic" ? "genericError" : payload.code;
|
|
405
|
+
opts.onEvent?.({
|
|
406
|
+
kind: "error",
|
|
407
|
+
payload: { kind, message: payload.message }
|
|
408
|
+
});
|
|
409
|
+
}
|
|
410
|
+
break;
|
|
411
|
+
}
|
|
412
|
+
}
|
|
413
|
+
});
|
|
414
|
+
return ok({ setQuote, dispose: () => handle.dispose() });
|
|
415
|
+
} catch (e) {
|
|
416
|
+
return err({
|
|
417
|
+
kind: "genericError",
|
|
418
|
+
message: e instanceof Error ? e.message : "Google Pay setup failed"
|
|
419
|
+
});
|
|
420
|
+
}
|
|
421
|
+
}
|
|
422
|
+
async function resetConnection() {
|
|
423
|
+
const channelId = `reset-${crypto.randomUUID()}`;
|
|
424
|
+
const url = buildFrameUrl(FRAME_PATHS.reset, { sessionToken, channelId }, { frameBaseUrl });
|
|
425
|
+
const transport = core.createTransport();
|
|
426
|
+
try {
|
|
427
|
+
const handle = await createFrameOrchestrator({
|
|
428
|
+
transport,
|
|
429
|
+
channelId,
|
|
430
|
+
url,
|
|
431
|
+
container: document.body,
|
|
432
|
+
hidden: true,
|
|
433
|
+
handshakeTimeout: 5e3
|
|
434
|
+
});
|
|
435
|
+
return new Promise((resolve) => {
|
|
436
|
+
const timeout = setTimeout(() => {
|
|
437
|
+
handle.dispose();
|
|
438
|
+
resolve(ok(void 0));
|
|
439
|
+
}, 5e3);
|
|
440
|
+
handle.onMessage((msg) => {
|
|
441
|
+
if (msg.kind === "complete" || msg.kind === "error") {
|
|
442
|
+
clearTimeout(timeout);
|
|
443
|
+
handle.dispose();
|
|
444
|
+
resolve(ok(void 0));
|
|
445
|
+
}
|
|
446
|
+
});
|
|
447
|
+
});
|
|
448
|
+
} catch {
|
|
449
|
+
return ok(void 0);
|
|
450
|
+
}
|
|
451
|
+
}
|
|
452
|
+
async function setupBuy(opts) {
|
|
453
|
+
const channelId = `buy-${crypto.randomUUID()}`;
|
|
454
|
+
const url = buildFrameUrl(
|
|
455
|
+
FRAME_PATHS.buy,
|
|
456
|
+
{
|
|
457
|
+
channelId,
|
|
458
|
+
clientToken: core.context.clientToken,
|
|
459
|
+
signature: opts.quote,
|
|
460
|
+
...opts.externalTransactionId && { externalTransactionId: opts.externalTransactionId }
|
|
461
|
+
},
|
|
462
|
+
{ frameBaseUrl }
|
|
463
|
+
);
|
|
464
|
+
const transport = core.createTransport();
|
|
465
|
+
try {
|
|
466
|
+
const handle = await createFrameOrchestrator({
|
|
467
|
+
transport,
|
|
468
|
+
channelId,
|
|
469
|
+
url,
|
|
470
|
+
container: opts.container,
|
|
471
|
+
hidden: true
|
|
472
|
+
});
|
|
473
|
+
const setQuote = (signature) => {
|
|
474
|
+
handle.sendMessage({
|
|
475
|
+
version: 2,
|
|
476
|
+
meta: { channelId },
|
|
477
|
+
kind: "setQuote",
|
|
478
|
+
payload: { quote: { signature } }
|
|
479
|
+
});
|
|
480
|
+
};
|
|
481
|
+
handle.onMessage((msg) => {
|
|
482
|
+
switch (msg.kind) {
|
|
483
|
+
case "ready":
|
|
484
|
+
opts.onEvent?.({ kind: "ready" });
|
|
485
|
+
break;
|
|
486
|
+
case "complete":
|
|
487
|
+
opts.onEvent?.({
|
|
488
|
+
kind: "complete",
|
|
489
|
+
payload: msg.payload
|
|
490
|
+
});
|
|
491
|
+
break;
|
|
492
|
+
case "challenge":
|
|
493
|
+
opts.onEvent?.({
|
|
494
|
+
kind: "challenge",
|
|
495
|
+
payload: msg.payload
|
|
496
|
+
});
|
|
497
|
+
break;
|
|
498
|
+
case "error":
|
|
499
|
+
opts.onEvent?.({
|
|
500
|
+
kind: "error",
|
|
501
|
+
payload: msg.payload
|
|
502
|
+
});
|
|
503
|
+
break;
|
|
504
|
+
}
|
|
505
|
+
});
|
|
506
|
+
return ok({ setQuote, dispose: () => handle.dispose() });
|
|
507
|
+
} catch (e) {
|
|
508
|
+
return err({
|
|
509
|
+
kind: "genericError",
|
|
510
|
+
message: e instanceof Error ? e.message : "Buy setup failed"
|
|
511
|
+
});
|
|
512
|
+
}
|
|
513
|
+
}
|
|
514
|
+
async function setupBuyButton(opts) {
|
|
515
|
+
const channelId = `buy-button-${crypto.randomUUID()}`;
|
|
516
|
+
const url = buildFrameUrl(
|
|
517
|
+
FRAME_PATHS.buyButton,
|
|
518
|
+
{
|
|
519
|
+
channelId,
|
|
520
|
+
clientToken: core.context.clientToken,
|
|
521
|
+
signature: opts.quote
|
|
522
|
+
},
|
|
523
|
+
{ frameBaseUrl }
|
|
524
|
+
);
|
|
525
|
+
const transport = core.createTransport();
|
|
526
|
+
try {
|
|
527
|
+
const handle = await createFrameOrchestrator({
|
|
528
|
+
transport,
|
|
529
|
+
channelId,
|
|
530
|
+
url,
|
|
531
|
+
container: opts.container
|
|
532
|
+
});
|
|
533
|
+
const setQuote = (signature) => {
|
|
534
|
+
handle.sendMessage({
|
|
535
|
+
version: 2,
|
|
536
|
+
meta: { channelId },
|
|
537
|
+
kind: "setQuote",
|
|
538
|
+
payload: { quote: { signature } }
|
|
539
|
+
});
|
|
540
|
+
};
|
|
541
|
+
handle.onMessage((msg) => {
|
|
542
|
+
switch (msg.kind) {
|
|
543
|
+
case "complete":
|
|
544
|
+
opts.onEvent?.({
|
|
545
|
+
kind: "complete",
|
|
546
|
+
payload: msg.payload
|
|
547
|
+
});
|
|
548
|
+
break;
|
|
549
|
+
case "challenge":
|
|
550
|
+
opts.onEvent?.({
|
|
551
|
+
kind: "challenge",
|
|
552
|
+
payload: msg.payload
|
|
553
|
+
});
|
|
554
|
+
break;
|
|
555
|
+
case "error":
|
|
556
|
+
opts.onEvent?.({
|
|
557
|
+
kind: "error",
|
|
558
|
+
payload: msg.payload
|
|
559
|
+
});
|
|
560
|
+
break;
|
|
561
|
+
}
|
|
562
|
+
});
|
|
563
|
+
return ok({ setQuote, dispose: () => handle.dispose() });
|
|
564
|
+
} catch (e) {
|
|
565
|
+
return err({
|
|
566
|
+
kind: "genericError",
|
|
567
|
+
message: e instanceof Error ? e.message : "Buy button setup failed"
|
|
568
|
+
});
|
|
569
|
+
}
|
|
570
|
+
}
|
|
571
|
+
async function setupChallenge(opts) {
|
|
572
|
+
let channelId;
|
|
573
|
+
try {
|
|
574
|
+
channelId = new URL(opts.url).searchParams.get("channelId") ?? "";
|
|
575
|
+
if (!channelId)
|
|
576
|
+
throw new Error("missing channelId");
|
|
577
|
+
} catch {
|
|
578
|
+
return err({ kind: "configurationError", message: "Challenge URL is missing channelId" });
|
|
579
|
+
}
|
|
580
|
+
const transport = core.createTransport();
|
|
581
|
+
try {
|
|
582
|
+
const handle = await createFrameOrchestrator({
|
|
583
|
+
transport,
|
|
584
|
+
channelId,
|
|
585
|
+
url: opts.url,
|
|
586
|
+
container: opts.container
|
|
587
|
+
});
|
|
588
|
+
handle.onMessage((msg) => {
|
|
589
|
+
switch (msg.kind) {
|
|
590
|
+
case "ready":
|
|
591
|
+
opts.onEvent?.({ kind: "ready" });
|
|
592
|
+
break;
|
|
593
|
+
case "complete":
|
|
594
|
+
opts.onEvent?.({ kind: "complete", payload: msg.payload });
|
|
595
|
+
break;
|
|
596
|
+
case "cancelled":
|
|
597
|
+
opts.onEvent?.({ kind: "cancelled", payload: msg.payload });
|
|
598
|
+
break;
|
|
599
|
+
case "error":
|
|
600
|
+
opts.onEvent?.({
|
|
601
|
+
kind: "error",
|
|
602
|
+
payload: msg.payload
|
|
603
|
+
});
|
|
604
|
+
break;
|
|
605
|
+
}
|
|
606
|
+
});
|
|
607
|
+
return ok({ dispose: () => handle.dispose() });
|
|
608
|
+
} catch (e) {
|
|
609
|
+
return err({
|
|
610
|
+
kind: "genericError",
|
|
611
|
+
message: e instanceof Error ? e.message : "Challenge setup failed"
|
|
612
|
+
});
|
|
613
|
+
}
|
|
614
|
+
}
|
|
615
|
+
async function setupAddCard(opts) {
|
|
616
|
+
const channelId = `add-card-${crypto.randomUUID()}`;
|
|
617
|
+
const url = buildFrameUrl(
|
|
618
|
+
FRAME_PATHS.addCard,
|
|
619
|
+
{ channelId, clientToken: core.context.clientToken },
|
|
620
|
+
{ frameBaseUrl }
|
|
621
|
+
);
|
|
622
|
+
const transport = core.createTransport();
|
|
623
|
+
try {
|
|
624
|
+
const handle = await createFrameOrchestrator({
|
|
625
|
+
transport,
|
|
626
|
+
channelId,
|
|
627
|
+
url,
|
|
628
|
+
container: opts.container
|
|
629
|
+
});
|
|
630
|
+
handle.onMessage((msg) => {
|
|
631
|
+
switch (msg.kind) {
|
|
632
|
+
case "complete":
|
|
633
|
+
opts.onEvent?.({ kind: "complete", payload: msg.payload });
|
|
634
|
+
break;
|
|
635
|
+
case "error":
|
|
636
|
+
opts.onEvent?.({
|
|
637
|
+
kind: "error",
|
|
638
|
+
payload: msg.payload
|
|
639
|
+
});
|
|
640
|
+
break;
|
|
641
|
+
}
|
|
642
|
+
});
|
|
643
|
+
return ok({ dispose: () => handle.dispose() });
|
|
644
|
+
} catch (e) {
|
|
645
|
+
return err({
|
|
646
|
+
kind: "genericError",
|
|
647
|
+
message: e instanceof Error ? e.message : "Add card setup failed"
|
|
648
|
+
});
|
|
649
|
+
}
|
|
650
|
+
}
|
|
651
|
+
return {
|
|
652
|
+
getConnection,
|
|
653
|
+
connect,
|
|
654
|
+
getPaymentMethods: () => core.getPaymentMethods(),
|
|
655
|
+
getQuote: (params) => core.getQuote(params),
|
|
656
|
+
listTransactions: (params) => core.listTransactions(params),
|
|
657
|
+
getTransaction: (id) => core.getTransaction(id),
|
|
658
|
+
deletePaymentMethod: (id) => core.deletePaymentMethod(id),
|
|
659
|
+
resetConnection,
|
|
660
|
+
setupWidget,
|
|
661
|
+
setupApplePay,
|
|
662
|
+
setupGooglePay,
|
|
663
|
+
setupBuy,
|
|
664
|
+
setupBuyButton,
|
|
665
|
+
setupChallenge,
|
|
666
|
+
setupAddCard
|
|
667
|
+
};
|
|
668
|
+
}
|
|
669
|
+
export {
|
|
670
|
+
IframeTransport,
|
|
671
|
+
createClient
|
|
672
|
+
};
|
|
673
|
+
//# sourceMappingURL=index.js.map
|