@sats-connect/core 0.1.2-1c4c44f → 0.1.2-515ef3b

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.
Files changed (3) hide show
  1. package/dist/index.d.mts +24 -1
  2. package/dist/index.mjs +768 -725
  3. package/package.json +2 -2
package/dist/index.mjs CHANGED
@@ -1,24 +1,84 @@
1
- // src/types.ts
1
+ // src/provider/index.ts
2
+ import omit from "lodash.omit";
3
+
4
+ // src/provider/types.ts
2
5
  import * as v from "valibot";
6
+ var accountChangeEventName = "accountChange";
7
+ var accountChangeSchema = v.object({
8
+ type: v.literal(accountChangeEventName)
9
+ });
10
+ var networkChangeEventName = "networkChange";
11
+ var networkChangeSchema = v.object({
12
+ type: v.literal(networkChangeEventName)
13
+ });
14
+ var walletEventSchema = v.variant("type", [accountChangeSchema, networkChangeSchema]);
15
+
16
+ // src/provider/index.ts
17
+ async function getProviderOrThrow(getProvider) {
18
+ const provider = await getProvider?.() || window.XverseProviders?.BitcoinProvider || window.BitcoinProvider;
19
+ if (!provider) {
20
+ throw new Error("No Bitcoin wallet installed");
21
+ }
22
+ return provider;
23
+ }
24
+ function getProviders() {
25
+ if (!window.btc_providers)
26
+ window.btc_providers = [];
27
+ return window.btc_providers;
28
+ }
29
+ function getProviderById(providerId) {
30
+ return providerId?.split(".").reduce((acc, part) => acc?.[part], window);
31
+ }
32
+ function isProviderInstalled(providerId) {
33
+ return !!getProviderById(providerId);
34
+ }
35
+ function setDefaultProvider(providerId) {
36
+ localStorage.setItem("sats-connect_defaultProvider", providerId);
37
+ }
38
+ function getDefaultProvider() {
39
+ return localStorage.getItem("sats-connect_defaultProvider");
40
+ }
41
+ function removeDefaultProvider() {
42
+ localStorage.removeItem("sats-connect_defaultProvider");
43
+ }
44
+ function getSupportedWallets() {
45
+ const btc_providers = getProviders();
46
+ const allProviders = [...btc_providers];
47
+ for (const key in omit(DefaultAdaptersInfo, ["xverse"])) {
48
+ allProviders.push(DefaultAdaptersInfo[key]);
49
+ }
50
+ const wallets = allProviders.map((provider) => {
51
+ {
52
+ return {
53
+ ...provider,
54
+ isInstalled: isProviderInstalled(provider.id)
55
+ };
56
+ }
57
+ });
58
+ return wallets;
59
+ }
60
+
61
+ // src/types.ts
62
+ import * as v2 from "valibot";
3
63
  var BitcoinNetworkType = /* @__PURE__ */ ((BitcoinNetworkType3) => {
4
64
  BitcoinNetworkType3["Mainnet"] = "Mainnet";
5
65
  BitcoinNetworkType3["Testnet"] = "Testnet";
6
66
  BitcoinNetworkType3["Signet"] = "Signet";
7
67
  return BitcoinNetworkType3;
8
68
  })(BitcoinNetworkType || {});
9
- var RpcIdSchema = v.optional(v.union([v.string(), v.number(), v.null()]));
10
- var rpcRequestMessageSchema = v.object({
11
- jsonrpc: v.literal("2.0"),
12
- method: v.string(),
13
- params: v.optional(
14
- v.union([
15
- v.array(v.unknown()),
16
- v.looseObject({}),
69
+ var RpcIdSchema = v2.optional(v2.union([v2.string(), v2.number(), v2.null()]));
70
+ var rpcRequestMessageSchema = v2.object({
71
+ jsonrpc: v2.literal("2.0"),
72
+ method: v2.string(),
73
+ params: v2.optional(
74
+ v2.union([
75
+ v2.array(v2.unknown()),
76
+ v2.looseObject({}),
17
77
  // Note: This is to support current incorrect usage of RPC 2.0. Params need
18
78
  // to be either an array or an object when provided. Changing this now would
19
79
  // be a breaking change, so accepting null values for now. Tracking in
20
80
  // https://linear.app/xverseapp/issue/ENG-4538.
21
- v.null()
81
+ v2.null()
22
82
  ])
23
83
  ),
24
84
  id: RpcIdSchema
@@ -34,687 +94,181 @@ var RpcErrorCode = /* @__PURE__ */ ((RpcErrorCode2) => {
34
94
  RpcErrorCode2[RpcErrorCode2["ACCESS_DENIED"] = -32002] = "ACCESS_DENIED";
35
95
  return RpcErrorCode2;
36
96
  })(RpcErrorCode || {});
37
- var rpcSuccessResponseMessageSchema = v.object({
38
- jsonrpc: v.literal("2.0"),
39
- result: v.nonOptional(v.unknown()),
97
+ var rpcSuccessResponseMessageSchema = v2.object({
98
+ jsonrpc: v2.literal("2.0"),
99
+ result: v2.nonOptional(v2.unknown()),
40
100
  id: RpcIdSchema
41
101
  });
42
- var rpcErrorResponseMessageSchema = v.object({
43
- jsonrpc: v.literal("2.0"),
44
- error: v.nonOptional(v.unknown()),
102
+ var rpcErrorResponseMessageSchema = v2.object({
103
+ jsonrpc: v2.literal("2.0"),
104
+ error: v2.nonOptional(v2.unknown()),
45
105
  id: RpcIdSchema
46
106
  });
47
- var rpcResponseMessageSchema = v.union([
107
+ var rpcResponseMessageSchema = v2.union([
48
108
  rpcSuccessResponseMessageSchema,
49
109
  rpcErrorResponseMessageSchema
50
110
  ]);
51
111
 
52
- // src/runes/api.ts
53
- import axios from "axios";
54
- var urlNetworkSuffix = {
55
- ["Mainnet" /* Mainnet */]: "",
56
- ["Testnet" /* Testnet */]: "-testnet",
57
- ["Signet" /* Signet */]: "-signet"
58
- };
59
- var ORDINALS_API_BASE_URL = (network = "Mainnet" /* Mainnet */) => `https://ordinals${urlNetworkSuffix[network]}.xverse.app/v1`;
60
- var RunesApi = class {
61
- client;
62
- constructor(network) {
63
- this.client = axios.create({
64
- baseURL: ORDINALS_API_BASE_URL(network)
65
- });
112
+ // src/request/index.ts
113
+ import * as v10 from "valibot";
114
+
115
+ // src/addresses/index.ts
116
+ import { createUnsecuredToken } from "jsontokens";
117
+
118
+ // src/addresses/types.ts
119
+ import * as v3 from "valibot";
120
+ var AddressPurpose = /* @__PURE__ */ ((AddressPurpose2) => {
121
+ AddressPurpose2["Ordinals"] = "ordinals";
122
+ AddressPurpose2["Payment"] = "payment";
123
+ AddressPurpose2["Stacks"] = "stacks";
124
+ return AddressPurpose2;
125
+ })(AddressPurpose || {});
126
+ var AddressType = /* @__PURE__ */ ((AddressType3) => {
127
+ AddressType3["p2pkh"] = "p2pkh";
128
+ AddressType3["p2sh"] = "p2sh";
129
+ AddressType3["p2wpkh"] = "p2wpkh";
130
+ AddressType3["p2wsh"] = "p2wsh";
131
+ AddressType3["p2tr"] = "p2tr";
132
+ AddressType3["stacks"] = "stacks";
133
+ return AddressType3;
134
+ })(AddressType || {});
135
+ var addressSchema = v3.object({
136
+ address: v3.string(),
137
+ publicKey: v3.string(),
138
+ purpose: v3.enum(AddressPurpose),
139
+ addressType: v3.enum(AddressType)
140
+ });
141
+
142
+ // src/addresses/index.ts
143
+ var getAddress = async (options) => {
144
+ const provider = await getProviderOrThrow(options.getProvider);
145
+ const { purposes } = options.payload;
146
+ if (!purposes) {
147
+ throw new Error("Address purposes are required");
66
148
  }
67
- parseError = (error) => {
68
- return {
69
- code: error.response?.status,
70
- message: JSON.stringify(error.response?.data)
71
- };
72
- };
73
- estimateMintCost = async (mintParams) => {
74
- try {
75
- const response = await this.client.post("/runes/mint/estimate", {
76
- ...mintParams
77
- });
78
- return {
79
- data: response.data
80
- };
81
- } catch (error) {
82
- const err = error;
83
- return {
84
- error: this.parseError(err)
85
- };
86
- }
87
- };
88
- estimateEtchCost = async (etchParams) => {
89
- try {
90
- const response = await this.client.post("/runes/etch/estimate", {
91
- ...etchParams
92
- });
93
- return {
94
- data: response.data
95
- };
96
- } catch (error) {
97
- const err = error;
98
- return {
99
- error: this.parseError(err)
100
- };
101
- }
102
- };
103
- createMintOrder = async (mintOrderParams) => {
104
- try {
105
- const response = await this.client.post("/runes/mint/orders", {
106
- ...mintOrderParams
107
- });
108
- return {
109
- data: response.data
110
- };
111
- } catch (error) {
112
- const err = error;
113
- return {
114
- error: this.parseError(err)
115
- };
116
- }
117
- };
118
- createEtchOrder = async (etchOrderParams) => {
119
- try {
120
- const response = await this.client.post("/runes/etch/orders", {
121
- ...etchOrderParams
122
- });
123
- return {
124
- data: response.data
125
- };
126
- } catch (error) {
127
- const err = error;
128
- return {
129
- error: this.parseError(err)
130
- };
131
- }
132
- };
133
- executeMint = async (orderId, fundTransactionId) => {
134
- try {
135
- const response = await this.client.post(`/runes/mint/orders/${orderId}/execute`, {
136
- fundTransactionId
137
- });
138
- return {
139
- data: response.data
140
- };
141
- } catch (error) {
142
- const err = error;
143
- return {
144
- error: this.parseError(err)
145
- };
146
- }
147
- };
148
- executeEtch = async (orderId, fundTransactionId) => {
149
- try {
150
- const response = await this.client.post(`/runes/etch/orders/${orderId}/execute`, {
151
- fundTransactionId
152
- });
153
- return {
154
- data: response.data
155
- };
156
- } catch (error) {
157
- const err = error;
158
- return {
159
- error: this.parseError(err)
160
- };
161
- }
162
- };
163
- getOrder = async (orderId) => {
164
- try {
165
- const response = await this.client.get(`/orders/${orderId}`);
166
- return {
167
- data: response.data
168
- };
169
- } catch (error) {
170
- const err = error;
171
- return {
172
- error: this.parseError(err)
173
- };
174
- }
175
- };
176
- rbfOrder = async (rbfRequest) => {
177
- const { orderId, newFeeRate } = rbfRequest;
178
- try {
179
- const response = await this.client.post(`/orders/${orderId}/rbf-estimate`, {
180
- newFeeRate
181
- });
182
- return {
183
- data: response.data
184
- };
185
- } catch (error) {
186
- const err = error;
187
- return {
188
- error: this.parseError(err)
189
- };
190
- }
191
- };
192
- };
193
- var clients = {};
194
- var getRunesApiClient = (network = "Mainnet" /* Mainnet */) => {
195
- if (!clients[network]) {
196
- clients[network] = new RunesApi(network);
197
- }
198
- return clients[network];
199
- };
200
-
201
- // src/adapters/satsConnectAdapter.ts
202
- var SatsConnectAdapter = class {
203
- async mintRunes(params) {
204
- try {
205
- const walletInfo = await this.requestInternal("getInfo", null).catch(() => null);
206
- if (walletInfo && walletInfo.status === "success") {
207
- const isMintSupported = walletInfo.result.methods?.includes("runes_mint");
208
- if (isMintSupported) {
209
- const response = await this.requestInternal("runes_mint", params);
210
- if (response) {
211
- if (response.status === "success") {
212
- return response;
213
- }
214
- if (response.status === "error" && response.error.code !== -32601 /* METHOD_NOT_FOUND */) {
215
- return response;
216
- }
217
- }
218
- }
219
- }
220
- const mintRequest = {
221
- destinationAddress: params.destinationAddress,
222
- feeRate: params.feeRate,
223
- refundAddress: params.refundAddress,
224
- repeats: params.repeats,
225
- runeName: params.runeName,
226
- appServiceFee: params.appServiceFee,
227
- appServiceFeeAddress: params.appServiceFeeAddress
228
- };
229
- const orderResponse = await new RunesApi(params.network).createMintOrder(mintRequest);
230
- if (!orderResponse.data) {
231
- return {
232
- status: "error",
233
- error: {
234
- code: orderResponse.error.code === 400 ? -32600 /* INVALID_REQUEST */ : -32603 /* INTERNAL_ERROR */,
235
- message: orderResponse.error.message
236
- }
237
- };
238
- }
239
- const paymentResponse = await this.requestInternal("sendTransfer", {
240
- recipients: [
241
- {
242
- address: orderResponse.data.fundAddress,
243
- amount: orderResponse.data.fundAmount
244
- }
245
- ]
246
- });
247
- if (paymentResponse.status !== "success") {
248
- return paymentResponse;
249
- }
250
- await new RunesApi(params.network).executeMint(
251
- orderResponse.data.orderId,
252
- paymentResponse.result.txid
253
- );
254
- return {
255
- status: "success",
256
- result: {
257
- orderId: orderResponse.data.orderId,
258
- fundTransactionId: paymentResponse.result.txid,
259
- fundingAddress: orderResponse.data.fundAddress
260
- }
261
- };
262
- } catch (error) {
263
- return {
264
- status: "error",
265
- error: {
266
- code: -32603 /* INTERNAL_ERROR */,
267
- message: error.message
268
- }
269
- };
270
- }
271
- }
272
- async etchRunes(params) {
273
- const etchRequest = {
274
- destinationAddress: params.destinationAddress,
275
- refundAddress: params.refundAddress,
276
- feeRate: params.feeRate,
277
- runeName: params.runeName,
278
- divisibility: params.divisibility,
279
- symbol: params.symbol,
280
- premine: params.premine,
281
- isMintable: params.isMintable,
282
- terms: params.terms,
283
- inscriptionDetails: params.inscriptionDetails,
284
- delegateInscriptionId: params.delegateInscriptionId,
285
- appServiceFee: params.appServiceFee,
286
- appServiceFeeAddress: params.appServiceFeeAddress
287
- };
288
- try {
289
- const walletInfo = await this.requestInternal("getInfo", null).catch(() => null);
290
- if (walletInfo && walletInfo.status === "success") {
291
- const isEtchSupported = walletInfo.result.methods?.includes("runes_etch");
292
- if (isEtchSupported) {
293
- const response = await this.requestInternal("runes_etch", params);
294
- if (response) {
295
- if (response.status === "success") {
296
- return response;
297
- }
298
- if (response.status === "error" && response.error.code !== -32601 /* METHOD_NOT_FOUND */) {
299
- return response;
300
- }
301
- }
302
- }
303
- }
304
- const orderResponse = await new RunesApi(params.network).createEtchOrder(etchRequest);
305
- if (!orderResponse.data) {
306
- return {
307
- status: "error",
308
- error: {
309
- code: orderResponse.error.code === 400 ? -32600 /* INVALID_REQUEST */ : -32603 /* INTERNAL_ERROR */,
310
- message: orderResponse.error.message
311
- }
312
- };
313
- }
314
- const paymentResponse = await this.requestInternal("sendTransfer", {
315
- recipients: [
316
- {
317
- address: orderResponse.data.fundAddress,
318
- amount: orderResponse.data.fundAmount
319
- }
320
- ]
321
- });
322
- if (paymentResponse.status !== "success") {
323
- return paymentResponse;
324
- }
325
- await new RunesApi(params.network).executeEtch(
326
- orderResponse.data.orderId,
327
- paymentResponse.result.txid
328
- );
329
- return {
330
- status: "success",
331
- result: {
332
- orderId: orderResponse.data.orderId,
333
- fundTransactionId: paymentResponse.result.txid,
334
- fundingAddress: orderResponse.data.fundAddress
335
- }
336
- };
337
- } catch (error) {
338
- return {
339
- status: "error",
340
- error: {
341
- code: -32603 /* INTERNAL_ERROR */,
342
- message: error.message
343
- }
344
- };
345
- }
346
- }
347
- async estimateMint(params) {
348
- const estimateMintRequest = {
349
- destinationAddress: params.destinationAddress,
350
- feeRate: params.feeRate,
351
- repeats: params.repeats,
352
- runeName: params.runeName,
353
- appServiceFee: params.appServiceFee,
354
- appServiceFeeAddress: params.appServiceFeeAddress
355
- };
356
- const response = await getRunesApiClient(
357
- params.network
358
- ).estimateMintCost(estimateMintRequest);
359
- if (response.data) {
360
- return {
361
- status: "success",
362
- result: response.data
363
- };
364
- }
365
- return {
366
- status: "error",
367
- error: {
368
- code: response.error.code === 400 ? -32600 /* INVALID_REQUEST */ : -32603 /* INTERNAL_ERROR */,
369
- message: response.error.message
370
- }
371
- };
372
- }
373
- async estimateEtch(params) {
374
- const estimateEtchRequest = {
375
- destinationAddress: params.destinationAddress,
376
- feeRate: params.feeRate,
377
- runeName: params.runeName,
378
- divisibility: params.divisibility,
379
- symbol: params.symbol,
380
- premine: params.premine,
381
- isMintable: params.isMintable,
382
- terms: params.terms,
383
- inscriptionDetails: params.inscriptionDetails,
384
- delegateInscriptionId: params.delegateInscriptionId,
385
- appServiceFee: params.appServiceFee,
386
- appServiceFeeAddress: params.appServiceFeeAddress
387
- };
388
- const response = await getRunesApiClient(params.network).estimateEtchCost(estimateEtchRequest);
389
- if (response.data) {
390
- return {
391
- status: "success",
392
- result: response.data
393
- };
394
- }
395
- return {
396
- status: "error",
397
- error: {
398
- code: response.error.code === 400 ? -32600 /* INVALID_REQUEST */ : -32603 /* INTERNAL_ERROR */,
399
- message: response.error.message
400
- }
401
- };
402
- }
403
- async getOrder(params) {
404
- const response = await getRunesApiClient(params.network).getOrder(params.id);
405
- if (response.data) {
406
- return {
407
- status: "success",
408
- result: response.data
409
- };
410
- }
411
- return {
412
- status: "error",
413
- error: {
414
- code: response.error.code === 400 || response.error.code === 404 ? -32600 /* INVALID_REQUEST */ : -32603 /* INTERNAL_ERROR */,
415
- message: response.error.message
416
- }
417
- };
418
- }
419
- async estimateRbfOrder(params) {
420
- const rbfOrderRequest = {
421
- newFeeRate: params.newFeeRate,
422
- orderId: params.orderId
423
- };
424
- const response = await getRunesApiClient(params.network).rbfOrder(rbfOrderRequest);
425
- if (response.data) {
426
- return {
427
- status: "success",
428
- result: {
429
- fundingAddress: response.data.fundingAddress,
430
- rbfCost: response.data.rbfCost
431
- }
432
- };
433
- }
434
- return {
435
- status: "error",
436
- error: {
437
- code: response.error.code === 400 || response.error.code === 404 ? -32600 /* INVALID_REQUEST */ : -32603 /* INTERNAL_ERROR */,
438
- message: response.error.message
439
- }
440
- };
441
- }
442
- async rbfOrder(params) {
443
- try {
444
- const rbfOrderRequest = {
445
- newFeeRate: params.newFeeRate,
446
- orderId: params.orderId
447
- };
448
- const orderResponse = await getRunesApiClient(params.network).rbfOrder(rbfOrderRequest);
449
- if (!orderResponse.data) {
450
- return {
451
- status: "error",
452
- error: {
453
- code: orderResponse.error.code === 400 || orderResponse.error.code === 404 ? -32600 /* INVALID_REQUEST */ : -32603 /* INTERNAL_ERROR */,
454
- message: orderResponse.error.message
455
- }
456
- };
457
- }
458
- const paymentResponse = await this.requestInternal("sendTransfer", {
459
- recipients: [
460
- {
461
- address: orderResponse.data.fundingAddress,
462
- amount: orderResponse.data.rbfCost
463
- }
464
- ]
465
- });
466
- if (paymentResponse.status !== "success") {
467
- return paymentResponse;
468
- }
469
- return {
470
- status: "success",
471
- result: {
472
- fundingAddress: orderResponse.data.fundingAddress,
473
- orderId: rbfOrderRequest.orderId,
474
- fundRBFTransactionId: paymentResponse.result.txid
475
- }
476
- };
477
- } catch (error) {
478
- return {
479
- status: "error",
480
- error: {
481
- code: -32603 /* INTERNAL_ERROR */,
482
- message: error.message
483
- }
484
- };
485
- }
486
- }
487
- async request(method, params) {
488
- switch (method) {
489
- case "runes_mint":
490
- return this.mintRunes(params);
491
- case "runes_etch":
492
- return this.etchRunes(params);
493
- case "runes_estimateMint":
494
- return this.estimateMint(params);
495
- case "runes_estimateEtch":
496
- return this.estimateEtch(params);
497
- case "runes_getOrder": {
498
- return this.getOrder(params);
499
- }
500
- case "runes_estimateRbfOrder": {
501
- return this.estimateRbfOrder(params);
502
- }
503
- case "runes_rbfOrder": {
504
- return this.rbfOrder(params);
505
- }
506
- default:
507
- return this.requestInternal(method, params);
508
- }
509
- }
510
- };
511
-
512
- // src/provider/index.ts
513
- import omit from "lodash.omit";
514
- async function getProviderOrThrow(getProvider) {
515
- const provider = await getProvider?.() || window.XverseProviders?.BitcoinProvider || window.BitcoinProvider;
516
- if (!provider) {
517
- throw new Error("No Bitcoin wallet installed");
518
- }
519
- return provider;
520
- }
521
- function getProviders() {
522
- if (!window.btc_providers)
523
- window.btc_providers = [];
524
- return window.btc_providers;
525
- }
526
- function getProviderById(providerId) {
527
- return providerId?.split(".").reduce((acc, part) => acc?.[part], window);
528
- }
529
- function isProviderInstalled(providerId) {
530
- return !!getProviderById(providerId);
531
- }
532
- function setDefaultProvider(providerId) {
533
- localStorage.setItem("sats-connect_defaultProvider", providerId);
534
- }
535
- function getDefaultProvider() {
536
- return localStorage.getItem("sats-connect_defaultProvider");
537
- }
538
- function removeDefaultProvider() {
539
- localStorage.removeItem("sats-connect_defaultProvider");
540
- }
541
- function getSupportedWallets() {
542
- const btc_providers = getProviders();
543
- const allProviders = [...btc_providers];
544
- for (const key in omit(DefaultAdaptersInfo, ["xverse"])) {
545
- allProviders.push(DefaultAdaptersInfo[key]);
546
- }
547
- const wallets = allProviders.map((provider) => {
548
- {
549
- return {
550
- ...provider,
551
- isInstalled: isProviderInstalled(provider.id)
552
- };
553
- }
554
- });
555
- return wallets;
556
- }
557
-
558
- // src/request/index.ts
559
- import * as v9 from "valibot";
560
-
561
- // src/addresses/index.ts
562
- import { createUnsecuredToken } from "jsontokens";
563
-
564
- // src/addresses/types.ts
565
- import * as v2 from "valibot";
566
- var AddressPurpose = /* @__PURE__ */ ((AddressPurpose2) => {
567
- AddressPurpose2["Ordinals"] = "ordinals";
568
- AddressPurpose2["Payment"] = "payment";
569
- AddressPurpose2["Stacks"] = "stacks";
570
- return AddressPurpose2;
571
- })(AddressPurpose || {});
572
- var AddressType = /* @__PURE__ */ ((AddressType3) => {
573
- AddressType3["p2pkh"] = "p2pkh";
574
- AddressType3["p2sh"] = "p2sh";
575
- AddressType3["p2wpkh"] = "p2wpkh";
576
- AddressType3["p2wsh"] = "p2wsh";
577
- AddressType3["p2tr"] = "p2tr";
578
- AddressType3["stacks"] = "stacks";
579
- return AddressType3;
580
- })(AddressType || {});
581
- var addressSchema = v2.object({
582
- address: v2.string(),
583
- publicKey: v2.string(),
584
- purpose: v2.enum(AddressPurpose),
585
- addressType: v2.enum(AddressType)
586
- });
587
-
588
- // src/addresses/index.ts
589
- var getAddress = async (options) => {
590
- const provider = await getProviderOrThrow(options.getProvider);
591
- const { purposes } = options.payload;
592
- if (!purposes) {
593
- throw new Error("Address purposes are required");
594
- }
595
- try {
596
- const request2 = createUnsecuredToken(options.payload);
597
- const response = await provider.connect(request2);
598
- options.onFinish?.(response);
599
- } catch (error) {
600
- console.error("[Connect] Error during address request", error);
601
- options.onCancel?.();
149
+ try {
150
+ const request2 = createUnsecuredToken(options.payload);
151
+ const response = await provider.connect(request2);
152
+ options.onFinish?.(response);
153
+ } catch (error) {
154
+ console.error("[Connect] Error during address request", error);
155
+ options.onCancel?.();
602
156
  }
603
157
  };
604
158
 
605
159
  // src/request/types/stxMethods.ts
606
- import * as v3 from "valibot";
160
+ import * as v4 from "valibot";
607
161
  var stxGetAddressesMethodName = "stx_getAddresses";
608
- var stxGetAddressesParamsSchema = v3.nullish(
609
- v3.object({
162
+ var stxGetAddressesParamsSchema = v4.nullish(
163
+ v4.object({
610
164
  /**
611
165
  * A message to be displayed to the user in the request prompt.
612
166
  */
613
- message: v3.optional(v3.string())
167
+ message: v4.optional(v4.string())
614
168
  })
615
169
  );
616
- var stxGetAddressesResultSchema = v3.object({
170
+ var stxGetAddressesResultSchema = v4.object({
617
171
  /**
618
172
  * The addresses generated for the given purposes.
619
173
  */
620
- addresses: v3.array(addressSchema)
174
+ addresses: v4.array(addressSchema)
621
175
  });
622
- var stxGetAddressesRequestMessageSchema = v3.object({
176
+ var stxGetAddressesRequestMessageSchema = v4.object({
623
177
  ...rpcRequestMessageSchema.entries,
624
- ...v3.object({
625
- method: v3.literal(stxGetAddressesMethodName),
178
+ ...v4.object({
179
+ method: v4.literal(stxGetAddressesMethodName),
626
180
  params: stxGetAddressesParamsSchema,
627
- id: v3.string()
181
+ id: v4.string()
628
182
  }).entries
629
183
  });
630
184
  var stxSignTransactionMethodName = "stx_signTransaction";
631
- var stxSignTransactionParamsSchema = v3.object({
185
+ var stxSignTransactionParamsSchema = v4.object({
632
186
  /**
633
187
  * The transaction to sign as a hex-encoded string.
634
188
  */
635
- transaction: v3.string(),
189
+ transaction: v4.string(),
636
190
  /**
637
191
  * The public key to sign the transaction with. The wallet may use any key
638
192
  * when not provided.
639
193
  */
640
- pubkey: v3.optional(v3.string()),
194
+ pubkey: v4.optional(v4.string()),
641
195
  /**
642
196
  * Whether to broadcast the transaction after signing. Defaults to `true`.
643
197
  */
644
- broadcast: v3.optional(v3.boolean())
198
+ broadcast: v4.optional(v4.boolean())
645
199
  });
646
- var stxSignTransactionResultSchema = v3.object({
200
+ var stxSignTransactionResultSchema = v4.object({
647
201
  /**
648
202
  * The signed transaction as a hex-encoded string.
649
203
  */
650
- transaction: v3.string()
204
+ transaction: v4.string()
651
205
  });
652
- var stxSignTransactionRequestMessageSchema = v3.object({
206
+ var stxSignTransactionRequestMessageSchema = v4.object({
653
207
  ...rpcRequestMessageSchema.entries,
654
- ...v3.object({
655
- method: v3.literal(stxSignTransactionMethodName),
208
+ ...v4.object({
209
+ method: v4.literal(stxSignTransactionMethodName),
656
210
  params: stxSignTransactionParamsSchema,
657
- id: v3.string()
211
+ id: v4.string()
658
212
  }).entries
659
213
  });
660
214
 
661
215
  // src/request/types/btcMethods.ts
662
- import * as v5 from "valibot";
216
+ import * as v6 from "valibot";
663
217
 
664
218
  // src/request/types/common.ts
665
- import * as v4 from "valibot";
219
+ import * as v5 from "valibot";
666
220
  var walletTypes = ["software", "ledger"];
667
- var walletTypeSchema = v4.picklist(walletTypes);
221
+ var walletTypeSchema = v5.picklist(walletTypes);
668
222
 
669
223
  // src/request/types/btcMethods.ts
670
224
  var getInfoMethodName = "getInfo";
671
- var getInfoParamsSchema = v5.nullish(v5.null());
672
- var getInfoResultSchema = v5.object({
225
+ var getInfoParamsSchema = v6.nullish(v6.null());
226
+ var getInfoResultSchema = v6.object({
673
227
  /**
674
228
  * Version of the wallet.
675
229
  */
676
- version: v5.string(),
230
+ version: v6.string(),
677
231
  /**
678
232
  * [WBIP](https://wbips.netlify.app/wbips/WBIP002) methods supported by the wallet.
679
233
  */
680
- methods: v5.optional(v5.array(v5.string())),
234
+ methods: v6.optional(v6.array(v6.string())),
681
235
  /**
682
236
  * List of WBIP standards supported by the wallet. Not currently used.
683
237
  */
684
- supports: v5.array(v5.string())
238
+ supports: v6.array(v6.string())
685
239
  });
686
- var getInfoRequestMessageSchema = v5.object({
240
+ var getInfoRequestMessageSchema = v6.object({
687
241
  ...rpcRequestMessageSchema.entries,
688
- ...v5.object({
689
- method: v5.literal(getInfoMethodName),
242
+ ...v6.object({
243
+ method: v6.literal(getInfoMethodName),
690
244
  params: getInfoParamsSchema,
691
- id: v5.string()
245
+ id: v6.string()
692
246
  }).entries
693
247
  });
694
248
  var getAddressesMethodName = "getAddresses";
695
- var getAddressesParamsSchema = v5.object({
249
+ var getAddressesParamsSchema = v6.object({
696
250
  /**
697
251
  * The purposes for which to generate addresses. See
698
252
  * {@linkcode AddressPurpose} for available purposes.
699
253
  */
700
- purposes: v5.array(v5.enum(AddressPurpose)),
254
+ purposes: v6.array(v6.enum(AddressPurpose)),
701
255
  /**
702
256
  * A message to be displayed to the user in the request prompt.
703
257
  */
704
- message: v5.optional(v5.string())
258
+ message: v6.optional(v6.string())
705
259
  });
706
- var getAddressesResultSchema = v5.object({
260
+ var getAddressesResultSchema = v6.object({
707
261
  /**
708
262
  * The addresses generated for the given purposes.
709
263
  */
710
- addresses: v5.array(addressSchema)
264
+ addresses: v6.array(addressSchema)
711
265
  });
712
- var getAddressesRequestMessageSchema = v5.object({
266
+ var getAddressesRequestMessageSchema = v6.object({
713
267
  ...rpcRequestMessageSchema.entries,
714
- ...v5.object({
715
- method: v5.literal(getAddressesMethodName),
268
+ ...v6.object({
269
+ method: v6.literal(getAddressesMethodName),
716
270
  params: getAddressesParamsSchema,
717
- id: v5.string()
271
+ id: v6.string()
718
272
  }).entries
719
273
  });
720
274
  var signMessageMethodName = "signMessage";
@@ -723,216 +277,216 @@ var MessageSigningProtocols = /* @__PURE__ */ ((MessageSigningProtocols2) => {
723
277
  MessageSigningProtocols2["BIP322"] = "BIP322";
724
278
  return MessageSigningProtocols2;
725
279
  })(MessageSigningProtocols || {});
726
- var signMessageParamsSchema = v5.object({
280
+ var signMessageParamsSchema = v6.object({
727
281
  /**
728
282
  * The address used for signing.
729
283
  **/
730
- address: v5.string(),
284
+ address: v6.string(),
731
285
  /**
732
286
  * The message to sign.
733
287
  **/
734
- message: v5.string(),
288
+ message: v6.string(),
735
289
  /**
736
290
  * The protocol to use for signing the message.
737
291
  */
738
- protocol: v5.optional(v5.enum(MessageSigningProtocols))
292
+ protocol: v6.optional(v6.enum(MessageSigningProtocols))
739
293
  });
740
- var signMessageResultSchema = v5.object({
294
+ var signMessageResultSchema = v6.object({
741
295
  /**
742
296
  * The signature of the message.
743
297
  */
744
- signature: v5.string(),
298
+ signature: v6.string(),
745
299
  /**
746
300
  * hash of the message.
747
301
  */
748
- messageHash: v5.string(),
302
+ messageHash: v6.string(),
749
303
  /**
750
304
  * The address used for signing.
751
305
  */
752
- address: v5.string(),
306
+ address: v6.string(),
753
307
  /**
754
308
  * The protocol to use for signing the message.
755
309
  */
756
- protocol: v5.enum(MessageSigningProtocols)
310
+ protocol: v6.enum(MessageSigningProtocols)
757
311
  });
758
- var signMessageRequestMessageSchema = v5.object({
312
+ var signMessageRequestMessageSchema = v6.object({
759
313
  ...rpcRequestMessageSchema.entries,
760
- ...v5.object({
761
- method: v5.literal(signMessageMethodName),
314
+ ...v6.object({
315
+ method: v6.literal(signMessageMethodName),
762
316
  params: signMessageParamsSchema,
763
- id: v5.string()
317
+ id: v6.string()
764
318
  }).entries
765
319
  });
766
320
  var getAccountsMethodName = "getAccounts";
767
- var getAccountsParamsSchema = v5.object({
321
+ var getAccountsParamsSchema = v6.object({
768
322
  /**
769
323
  * The purposes for which to generate addresses. See
770
324
  * {@linkcode AddressPurpose} for available purposes.
771
325
  */
772
- purposes: v5.array(v5.enum(AddressPurpose)),
326
+ purposes: v6.array(v6.enum(AddressPurpose)),
773
327
  /**
774
328
  * A message to be displayed to the user in the request prompt.
775
329
  */
776
- message: v5.optional(v5.string())
330
+ message: v6.optional(v6.string())
777
331
  });
778
- var getAccountsResultSchema = v5.array(
779
- v5.object({
332
+ var getAccountsResultSchema = v6.array(
333
+ v6.object({
780
334
  ...addressSchema.entries,
781
- ...v5.object({
335
+ ...v6.object({
782
336
  walletType: walletTypeSchema
783
337
  }).entries
784
338
  })
785
339
  );
786
- var getAccountsRequestMessageSchema = v5.object({
340
+ var getAccountsRequestMessageSchema = v6.object({
787
341
  ...rpcRequestMessageSchema.entries,
788
- ...v5.object({
789
- method: v5.literal(getAccountsMethodName),
342
+ ...v6.object({
343
+ method: v6.literal(getAccountsMethodName),
790
344
  params: getAccountsParamsSchema,
791
- id: v5.string()
345
+ id: v6.string()
792
346
  }).entries
793
347
  });
794
348
  var getBalanceMethodName = "getBalance";
795
- var getBalanceParamsSchema = v5.nullish(v5.null());
796
- var getBalanceResultSchema = v5.object({
349
+ var getBalanceParamsSchema = v6.nullish(v6.null());
350
+ var getBalanceResultSchema = v6.object({
797
351
  /**
798
352
  * The confirmed balance of the wallet in sats. Using a string due to chrome
799
353
  * messages not supporting bigint
800
354
  * (https://issues.chromium.org/issues/40116184).
801
355
  */
802
- confirmed: v5.string(),
356
+ confirmed: v6.string(),
803
357
  /**
804
358
  * The unconfirmed balance of the wallet in sats. Using a string due to chrome
805
359
  * messages not supporting bigint
806
360
  * (https://issues.chromium.org/issues/40116184).
807
361
  */
808
- unconfirmed: v5.string(),
362
+ unconfirmed: v6.string(),
809
363
  /**
810
364
  * The total balance (both confirmed and unconfrimed UTXOs) of the wallet in
811
365
  * sats. Using a string due to chrome messages not supporting bigint
812
366
  * (https://issues.chromium.org/issues/40116184).
813
367
  */
814
- total: v5.string()
368
+ total: v6.string()
815
369
  });
816
- var getBalanceRequestMessageSchema = v5.object({
370
+ var getBalanceRequestMessageSchema = v6.object({
817
371
  ...rpcRequestMessageSchema.entries,
818
- ...v5.object({
819
- method: v5.literal(getBalanceMethodName),
820
- id: v5.string()
372
+ ...v6.object({
373
+ method: v6.literal(getBalanceMethodName),
374
+ id: v6.string()
821
375
  }).entries
822
376
  });
823
377
 
824
378
  // src/request/types/walletMethods.ts
825
- import * as v6 from "valibot";
379
+ import * as v7 from "valibot";
826
380
  var requestPermissionsMethodName = "wallet_requestPermissions";
827
- var requestPermissionsParamsSchema = v6.undefined();
828
- var requestPermissionsResultSchema = v6.literal(true);
829
- var requestPermissionsRequestMessageSchema = v6.object({
381
+ var requestPermissionsParamsSchema = v7.undefined();
382
+ var requestPermissionsResultSchema = v7.literal(true);
383
+ var requestPermissionsRequestMessageSchema = v7.object({
830
384
  ...rpcRequestMessageSchema.entries,
831
- ...v6.object({
832
- method: v6.literal(requestPermissionsMethodName),
385
+ ...v7.object({
386
+ method: v7.literal(requestPermissionsMethodName),
833
387
  params: requestPermissionsParamsSchema,
834
- id: v6.string()
388
+ id: v7.string()
835
389
  }).entries
836
390
  });
837
391
  var renouncePermissionsMethodName = "wallet_renouncePermissions";
838
- var renouncePermissionsParamsSchema = v6.undefined();
839
- var renouncePermissionsResultSchema = v6.literal(true);
840
- var renouncePermissionsRequestMessageSchema = v6.object({
392
+ var renouncePermissionsParamsSchema = v7.undefined();
393
+ var renouncePermissionsResultSchema = v7.literal(true);
394
+ var renouncePermissionsRequestMessageSchema = v7.object({
841
395
  ...rpcRequestMessageSchema.entries,
842
- ...v6.object({
843
- method: v6.literal(renouncePermissionsMethodName),
396
+ ...v7.object({
397
+ method: v7.literal(renouncePermissionsMethodName),
844
398
  params: renouncePermissionsParamsSchema,
845
- id: v6.string()
399
+ id: v7.string()
846
400
  }).entries
847
401
  });
848
402
  var getWalletTypeMethodName = "wallet_getWalletType";
849
- var getWalletTypeParamsSchema = v6.nullish(v6.null());
403
+ var getWalletTypeParamsSchema = v7.nullish(v7.null());
850
404
  var getWalletTypeResultSchema = walletTypeSchema;
851
- var getWalletTypeRequestMessageSchema = v6.object({
405
+ var getWalletTypeRequestMessageSchema = v7.object({
852
406
  ...rpcRequestMessageSchema.entries,
853
- ...v6.object({
854
- method: v6.literal(getWalletTypeMethodName),
855
- id: v6.string()
407
+ ...v7.object({
408
+ method: v7.literal(getWalletTypeMethodName),
409
+ id: v7.string()
856
410
  }).entries
857
411
  });
858
412
 
859
413
  // src/request/types/runesMethods.ts
860
- import * as v7 from "valibot";
414
+ import * as v8 from "valibot";
861
415
  var getRunesBalanceMethodName = "runes_getBalance";
862
- var getRunesBalanceParamsSchema = v7.nullish(v7.null());
863
- var getRunesBalanceResultSchema = v7.object({
864
- balances: v7.array(
865
- v7.object({
866
- runeName: v7.string(),
867
- amount: v7.string(),
868
- divisibility: v7.number(),
869
- symbol: v7.string(),
870
- inscriptionId: v7.nullish(v7.string())
416
+ var getRunesBalanceParamsSchema = v8.nullish(v8.null());
417
+ var getRunesBalanceResultSchema = v8.object({
418
+ balances: v8.array(
419
+ v8.object({
420
+ runeName: v8.string(),
421
+ amount: v8.string(),
422
+ divisibility: v8.number(),
423
+ symbol: v8.string(),
424
+ inscriptionId: v8.nullish(v8.string())
871
425
  })
872
426
  )
873
427
  });
874
- var getRunesBalanceRequestMessageSchema = v7.object({
428
+ var getRunesBalanceRequestMessageSchema = v8.object({
875
429
  ...rpcRequestMessageSchema.entries,
876
- ...v7.object({
877
- method: v7.literal(getRunesBalanceMethodName),
430
+ ...v8.object({
431
+ method: v8.literal(getRunesBalanceMethodName),
878
432
  params: getRunesBalanceParamsSchema,
879
- id: v7.string()
433
+ id: v8.string()
880
434
  }).entries
881
435
  });
882
436
 
883
437
  // src/request/types/ordinalsMethods.ts
884
- import * as v8 from "valibot";
438
+ import * as v9 from "valibot";
885
439
  var getInscriptionsMethodName = "ord_getInscriptions";
886
- var getInscriptionsParamsSchema = v8.object({
887
- offset: v8.number(),
888
- limit: v8.number()
440
+ var getInscriptionsParamsSchema = v9.object({
441
+ offset: v9.number(),
442
+ limit: v9.number()
889
443
  });
890
- var getInscriptionsResultSchema = v8.object({
891
- total: v8.number(),
892
- limit: v8.number(),
893
- offset: v8.number(),
894
- inscriptions: v8.array(
895
- v8.object({
896
- inscriptionId: v8.string(),
897
- inscriptionNumber: v8.string(),
898
- address: v8.string(),
899
- collectionName: v8.optional(v8.string()),
900
- postage: v8.string(),
901
- contentLength: v8.string(),
902
- contentType: v8.string(),
903
- timestamp: v8.number(),
904
- offset: v8.number(),
905
- genesisTransaction: v8.string(),
906
- output: v8.string()
444
+ var getInscriptionsResultSchema = v9.object({
445
+ total: v9.number(),
446
+ limit: v9.number(),
447
+ offset: v9.number(),
448
+ inscriptions: v9.array(
449
+ v9.object({
450
+ inscriptionId: v9.string(),
451
+ inscriptionNumber: v9.string(),
452
+ address: v9.string(),
453
+ collectionName: v9.optional(v9.string()),
454
+ postage: v9.string(),
455
+ contentLength: v9.string(),
456
+ contentType: v9.string(),
457
+ timestamp: v9.number(),
458
+ offset: v9.number(),
459
+ genesisTransaction: v9.string(),
460
+ output: v9.string()
907
461
  })
908
462
  )
909
463
  });
910
- var getInscriptionsSchema = v8.object({
464
+ var getInscriptionsSchema = v9.object({
911
465
  ...rpcRequestMessageSchema.entries,
912
- ...v8.object({
913
- method: v8.literal(getInscriptionsMethodName),
466
+ ...v9.object({
467
+ method: v9.literal(getInscriptionsMethodName),
914
468
  params: getInscriptionsParamsSchema,
915
- id: v8.string()
469
+ id: v9.string()
916
470
  }).entries
917
471
  });
918
472
  var sendInscriptionsMethodName = "ord_sendInscriptions";
919
- var sendInscriptionsParamsSchema = v8.object({
920
- transfers: v8.array(
921
- v8.object({
922
- address: v8.string(),
923
- inscriptionId: v8.string()
473
+ var sendInscriptionsParamsSchema = v9.object({
474
+ transfers: v9.array(
475
+ v9.object({
476
+ address: v9.string(),
477
+ inscriptionId: v9.string()
924
478
  })
925
479
  )
926
480
  });
927
- var sendInscriptionsResultSchema = v8.object({
928
- txid: v8.string()
481
+ var sendInscriptionsResultSchema = v9.object({
482
+ txid: v9.string()
929
483
  });
930
- var sendInscriptionsSchema = v8.object({
484
+ var sendInscriptionsSchema = v9.object({
931
485
  ...rpcRequestMessageSchema.entries,
932
- ...v8.object({
933
- method: v8.literal(sendInscriptionsMethodName),
486
+ ...v9.object({
487
+ method: v9.literal(sendInscriptionsMethodName),
934
488
  params: sendInscriptionsParamsSchema,
935
- id: v8.string()
489
+ id: v9.string()
936
490
  }).entries
937
491
  });
938
492
 
@@ -942,33 +496,503 @@ var request = async (method, params, providerId) => {
942
496
  if (providerId) {
943
497
  provider = await getProviderById(providerId);
944
498
  }
945
- if (!provider) {
946
- throw new Error("no wallet provider was found");
499
+ if (!provider) {
500
+ throw new Error("no wallet provider was found");
501
+ }
502
+ if (!method) {
503
+ throw new Error("A wallet method is required");
504
+ }
505
+ const response = await provider.request(method, params);
506
+ if (v10.is(rpcErrorResponseMessageSchema, response)) {
507
+ return {
508
+ status: "error",
509
+ error: response.error
510
+ };
511
+ }
512
+ if (v10.is(rpcSuccessResponseMessageSchema, response)) {
513
+ return {
514
+ status: "success",
515
+ result: response.result
516
+ };
517
+ }
518
+ return {
519
+ status: "error",
520
+ error: {
521
+ code: -32603 /* INTERNAL_ERROR */,
522
+ message: "Received unknown response from provider.",
523
+ data: response
524
+ }
525
+ };
526
+ };
527
+ var addListener = (event, cb, providerId) => {
528
+ let provider = window.XverseProviders?.BitcoinProvider || window.BitcoinProvider;
529
+ if (providerId) {
530
+ provider = getProviderById(providerId);
531
+ }
532
+ if (!provider) {
533
+ throw new Error("no wallet provider was found");
534
+ }
535
+ return provider.addListener(event, cb);
536
+ };
537
+
538
+ // src/runes/api.ts
539
+ import axios from "axios";
540
+ var urlNetworkSuffix = {
541
+ ["Mainnet" /* Mainnet */]: "",
542
+ ["Testnet" /* Testnet */]: "-testnet",
543
+ ["Signet" /* Signet */]: "-signet"
544
+ };
545
+ var ORDINALS_API_BASE_URL = (network = "Mainnet" /* Mainnet */) => `https://ordinals${urlNetworkSuffix[network]}.xverse.app/v1`;
546
+ var RunesApi = class {
547
+ client;
548
+ constructor(network) {
549
+ this.client = axios.create({
550
+ baseURL: ORDINALS_API_BASE_URL(network)
551
+ });
552
+ }
553
+ parseError = (error) => {
554
+ return {
555
+ code: error.response?.status,
556
+ message: JSON.stringify(error.response?.data)
557
+ };
558
+ };
559
+ estimateMintCost = async (mintParams) => {
560
+ try {
561
+ const response = await this.client.post("/runes/mint/estimate", {
562
+ ...mintParams
563
+ });
564
+ return {
565
+ data: response.data
566
+ };
567
+ } catch (error) {
568
+ const err = error;
569
+ return {
570
+ error: this.parseError(err)
571
+ };
572
+ }
573
+ };
574
+ estimateEtchCost = async (etchParams) => {
575
+ try {
576
+ const response = await this.client.post("/runes/etch/estimate", {
577
+ ...etchParams
578
+ });
579
+ return {
580
+ data: response.data
581
+ };
582
+ } catch (error) {
583
+ const err = error;
584
+ return {
585
+ error: this.parseError(err)
586
+ };
587
+ }
588
+ };
589
+ createMintOrder = async (mintOrderParams) => {
590
+ try {
591
+ const response = await this.client.post("/runes/mint/orders", {
592
+ ...mintOrderParams
593
+ });
594
+ return {
595
+ data: response.data
596
+ };
597
+ } catch (error) {
598
+ const err = error;
599
+ return {
600
+ error: this.parseError(err)
601
+ };
602
+ }
603
+ };
604
+ createEtchOrder = async (etchOrderParams) => {
605
+ try {
606
+ const response = await this.client.post("/runes/etch/orders", {
607
+ ...etchOrderParams
608
+ });
609
+ return {
610
+ data: response.data
611
+ };
612
+ } catch (error) {
613
+ const err = error;
614
+ return {
615
+ error: this.parseError(err)
616
+ };
617
+ }
618
+ };
619
+ executeMint = async (orderId, fundTransactionId) => {
620
+ try {
621
+ const response = await this.client.post(`/runes/mint/orders/${orderId}/execute`, {
622
+ fundTransactionId
623
+ });
624
+ return {
625
+ data: response.data
626
+ };
627
+ } catch (error) {
628
+ const err = error;
629
+ return {
630
+ error: this.parseError(err)
631
+ };
632
+ }
633
+ };
634
+ executeEtch = async (orderId, fundTransactionId) => {
635
+ try {
636
+ const response = await this.client.post(`/runes/etch/orders/${orderId}/execute`, {
637
+ fundTransactionId
638
+ });
639
+ return {
640
+ data: response.data
641
+ };
642
+ } catch (error) {
643
+ const err = error;
644
+ return {
645
+ error: this.parseError(err)
646
+ };
647
+ }
648
+ };
649
+ getOrder = async (orderId) => {
650
+ try {
651
+ const response = await this.client.get(`/orders/${orderId}`);
652
+ return {
653
+ data: response.data
654
+ };
655
+ } catch (error) {
656
+ const err = error;
657
+ return {
658
+ error: this.parseError(err)
659
+ };
660
+ }
661
+ };
662
+ rbfOrder = async (rbfRequest) => {
663
+ const { orderId, newFeeRate } = rbfRequest;
664
+ try {
665
+ const response = await this.client.post(`/orders/${orderId}/rbf-estimate`, {
666
+ newFeeRate
667
+ });
668
+ return {
669
+ data: response.data
670
+ };
671
+ } catch (error) {
672
+ const err = error;
673
+ return {
674
+ error: this.parseError(err)
675
+ };
676
+ }
677
+ };
678
+ };
679
+ var clients = {};
680
+ var getRunesApiClient = (network = "Mainnet" /* Mainnet */) => {
681
+ if (!clients[network]) {
682
+ clients[network] = new RunesApi(network);
683
+ }
684
+ return clients[network];
685
+ };
686
+
687
+ // src/adapters/satsConnectAdapter.ts
688
+ var SatsConnectAdapter = class {
689
+ async mintRunes(params) {
690
+ try {
691
+ const walletInfo = await this.requestInternal("getInfo", null).catch(() => null);
692
+ if (walletInfo && walletInfo.status === "success") {
693
+ const isMintSupported = walletInfo.result.methods?.includes("runes_mint");
694
+ if (isMintSupported) {
695
+ const response = await this.requestInternal("runes_mint", params);
696
+ if (response) {
697
+ if (response.status === "success") {
698
+ return response;
699
+ }
700
+ if (response.status === "error" && response.error.code !== -32601 /* METHOD_NOT_FOUND */) {
701
+ return response;
702
+ }
703
+ }
704
+ }
705
+ }
706
+ const mintRequest = {
707
+ destinationAddress: params.destinationAddress,
708
+ feeRate: params.feeRate,
709
+ refundAddress: params.refundAddress,
710
+ repeats: params.repeats,
711
+ runeName: params.runeName,
712
+ appServiceFee: params.appServiceFee,
713
+ appServiceFeeAddress: params.appServiceFeeAddress
714
+ };
715
+ const orderResponse = await new RunesApi(params.network).createMintOrder(mintRequest);
716
+ if (!orderResponse.data) {
717
+ return {
718
+ status: "error",
719
+ error: {
720
+ code: orderResponse.error.code === 400 ? -32600 /* INVALID_REQUEST */ : -32603 /* INTERNAL_ERROR */,
721
+ message: orderResponse.error.message
722
+ }
723
+ };
724
+ }
725
+ const paymentResponse = await this.requestInternal("sendTransfer", {
726
+ recipients: [
727
+ {
728
+ address: orderResponse.data.fundAddress,
729
+ amount: orderResponse.data.fundAmount
730
+ }
731
+ ]
732
+ });
733
+ if (paymentResponse.status !== "success") {
734
+ return paymentResponse;
735
+ }
736
+ await new RunesApi(params.network).executeMint(
737
+ orderResponse.data.orderId,
738
+ paymentResponse.result.txid
739
+ );
740
+ return {
741
+ status: "success",
742
+ result: {
743
+ orderId: orderResponse.data.orderId,
744
+ fundTransactionId: paymentResponse.result.txid,
745
+ fundingAddress: orderResponse.data.fundAddress
746
+ }
747
+ };
748
+ } catch (error) {
749
+ return {
750
+ status: "error",
751
+ error: {
752
+ code: -32603 /* INTERNAL_ERROR */,
753
+ message: error.message
754
+ }
755
+ };
756
+ }
757
+ }
758
+ async etchRunes(params) {
759
+ const etchRequest = {
760
+ destinationAddress: params.destinationAddress,
761
+ refundAddress: params.refundAddress,
762
+ feeRate: params.feeRate,
763
+ runeName: params.runeName,
764
+ divisibility: params.divisibility,
765
+ symbol: params.symbol,
766
+ premine: params.premine,
767
+ isMintable: params.isMintable,
768
+ terms: params.terms,
769
+ inscriptionDetails: params.inscriptionDetails,
770
+ delegateInscriptionId: params.delegateInscriptionId,
771
+ appServiceFee: params.appServiceFee,
772
+ appServiceFeeAddress: params.appServiceFeeAddress
773
+ };
774
+ try {
775
+ const walletInfo = await this.requestInternal("getInfo", null).catch(() => null);
776
+ if (walletInfo && walletInfo.status === "success") {
777
+ const isEtchSupported = walletInfo.result.methods?.includes("runes_etch");
778
+ if (isEtchSupported) {
779
+ const response = await this.requestInternal("runes_etch", params);
780
+ if (response) {
781
+ if (response.status === "success") {
782
+ return response;
783
+ }
784
+ if (response.status === "error" && response.error.code !== -32601 /* METHOD_NOT_FOUND */) {
785
+ return response;
786
+ }
787
+ }
788
+ }
789
+ }
790
+ const orderResponse = await new RunesApi(params.network).createEtchOrder(etchRequest);
791
+ if (!orderResponse.data) {
792
+ return {
793
+ status: "error",
794
+ error: {
795
+ code: orderResponse.error.code === 400 ? -32600 /* INVALID_REQUEST */ : -32603 /* INTERNAL_ERROR */,
796
+ message: orderResponse.error.message
797
+ }
798
+ };
799
+ }
800
+ const paymentResponse = await this.requestInternal("sendTransfer", {
801
+ recipients: [
802
+ {
803
+ address: orderResponse.data.fundAddress,
804
+ amount: orderResponse.data.fundAmount
805
+ }
806
+ ]
807
+ });
808
+ if (paymentResponse.status !== "success") {
809
+ return paymentResponse;
810
+ }
811
+ await new RunesApi(params.network).executeEtch(
812
+ orderResponse.data.orderId,
813
+ paymentResponse.result.txid
814
+ );
815
+ return {
816
+ status: "success",
817
+ result: {
818
+ orderId: orderResponse.data.orderId,
819
+ fundTransactionId: paymentResponse.result.txid,
820
+ fundingAddress: orderResponse.data.fundAddress
821
+ }
822
+ };
823
+ } catch (error) {
824
+ return {
825
+ status: "error",
826
+ error: {
827
+ code: -32603 /* INTERNAL_ERROR */,
828
+ message: error.message
829
+ }
830
+ };
831
+ }
947
832
  }
948
- if (!method) {
949
- throw new Error("A wallet method is required");
833
+ async estimateMint(params) {
834
+ const estimateMintRequest = {
835
+ destinationAddress: params.destinationAddress,
836
+ feeRate: params.feeRate,
837
+ repeats: params.repeats,
838
+ runeName: params.runeName,
839
+ appServiceFee: params.appServiceFee,
840
+ appServiceFeeAddress: params.appServiceFeeAddress
841
+ };
842
+ const response = await getRunesApiClient(
843
+ params.network
844
+ ).estimateMintCost(estimateMintRequest);
845
+ if (response.data) {
846
+ return {
847
+ status: "success",
848
+ result: response.data
849
+ };
850
+ }
851
+ return {
852
+ status: "error",
853
+ error: {
854
+ code: response.error.code === 400 ? -32600 /* INVALID_REQUEST */ : -32603 /* INTERNAL_ERROR */,
855
+ message: response.error.message
856
+ }
857
+ };
950
858
  }
951
- const response = await provider.request(method, params);
952
- if (v9.is(rpcErrorResponseMessageSchema, response)) {
859
+ async estimateEtch(params) {
860
+ const estimateEtchRequest = {
861
+ destinationAddress: params.destinationAddress,
862
+ feeRate: params.feeRate,
863
+ runeName: params.runeName,
864
+ divisibility: params.divisibility,
865
+ symbol: params.symbol,
866
+ premine: params.premine,
867
+ isMintable: params.isMintable,
868
+ terms: params.terms,
869
+ inscriptionDetails: params.inscriptionDetails,
870
+ delegateInscriptionId: params.delegateInscriptionId,
871
+ appServiceFee: params.appServiceFee,
872
+ appServiceFeeAddress: params.appServiceFeeAddress
873
+ };
874
+ const response = await getRunesApiClient(params.network).estimateEtchCost(estimateEtchRequest);
875
+ if (response.data) {
876
+ return {
877
+ status: "success",
878
+ result: response.data
879
+ };
880
+ }
953
881
  return {
954
882
  status: "error",
955
- error: response.error
883
+ error: {
884
+ code: response.error.code === 400 ? -32600 /* INVALID_REQUEST */ : -32603 /* INTERNAL_ERROR */,
885
+ message: response.error.message
886
+ }
956
887
  };
957
888
  }
958
- if (v9.is(rpcSuccessResponseMessageSchema, response)) {
889
+ async getOrder(params) {
890
+ const response = await getRunesApiClient(params.network).getOrder(params.id);
891
+ if (response.data) {
892
+ return {
893
+ status: "success",
894
+ result: response.data
895
+ };
896
+ }
959
897
  return {
960
- status: "success",
961
- result: response.result
898
+ status: "error",
899
+ error: {
900
+ code: response.error.code === 400 || response.error.code === 404 ? -32600 /* INVALID_REQUEST */ : -32603 /* INTERNAL_ERROR */,
901
+ message: response.error.message
902
+ }
962
903
  };
963
904
  }
964
- return {
965
- status: "error",
966
- error: {
967
- code: -32603 /* INTERNAL_ERROR */,
968
- message: "Received unknown response from provider.",
969
- data: response
905
+ async estimateRbfOrder(params) {
906
+ const rbfOrderRequest = {
907
+ newFeeRate: params.newFeeRate,
908
+ orderId: params.orderId
909
+ };
910
+ const response = await getRunesApiClient(params.network).rbfOrder(rbfOrderRequest);
911
+ if (response.data) {
912
+ return {
913
+ status: "success",
914
+ result: {
915
+ fundingAddress: response.data.fundingAddress,
916
+ rbfCost: response.data.rbfCost
917
+ }
918
+ };
970
919
  }
971
- };
920
+ return {
921
+ status: "error",
922
+ error: {
923
+ code: response.error.code === 400 || response.error.code === 404 ? -32600 /* INVALID_REQUEST */ : -32603 /* INTERNAL_ERROR */,
924
+ message: response.error.message
925
+ }
926
+ };
927
+ }
928
+ async rbfOrder(params) {
929
+ try {
930
+ const rbfOrderRequest = {
931
+ newFeeRate: params.newFeeRate,
932
+ orderId: params.orderId
933
+ };
934
+ const orderResponse = await getRunesApiClient(params.network).rbfOrder(rbfOrderRequest);
935
+ if (!orderResponse.data) {
936
+ return {
937
+ status: "error",
938
+ error: {
939
+ code: orderResponse.error.code === 400 || orderResponse.error.code === 404 ? -32600 /* INVALID_REQUEST */ : -32603 /* INTERNAL_ERROR */,
940
+ message: orderResponse.error.message
941
+ }
942
+ };
943
+ }
944
+ const paymentResponse = await this.requestInternal("sendTransfer", {
945
+ recipients: [
946
+ {
947
+ address: orderResponse.data.fundingAddress,
948
+ amount: orderResponse.data.rbfCost
949
+ }
950
+ ]
951
+ });
952
+ if (paymentResponse.status !== "success") {
953
+ return paymentResponse;
954
+ }
955
+ return {
956
+ status: "success",
957
+ result: {
958
+ fundingAddress: orderResponse.data.fundingAddress,
959
+ orderId: rbfOrderRequest.orderId,
960
+ fundRBFTransactionId: paymentResponse.result.txid
961
+ }
962
+ };
963
+ } catch (error) {
964
+ return {
965
+ status: "error",
966
+ error: {
967
+ code: -32603 /* INTERNAL_ERROR */,
968
+ message: error.message
969
+ }
970
+ };
971
+ }
972
+ }
973
+ async request(method, params) {
974
+ switch (method) {
975
+ case "runes_mint":
976
+ return this.mintRunes(params);
977
+ case "runes_etch":
978
+ return this.etchRunes(params);
979
+ case "runes_estimateMint":
980
+ return this.estimateMint(params);
981
+ case "runes_estimateEtch":
982
+ return this.estimateEtch(params);
983
+ case "runes_getOrder": {
984
+ return this.getOrder(params);
985
+ }
986
+ case "runes_estimateRbfOrder": {
987
+ return this.estimateRbfOrder(params);
988
+ }
989
+ case "runes_rbfOrder": {
990
+ return this.rbfOrder(params);
991
+ }
992
+ default:
993
+ return this.requestInternal(method, params);
994
+ }
995
+ }
972
996
  };
973
997
 
974
998
  // src/adapters/xverse.ts
@@ -977,6 +1001,15 @@ var XverseAdapter = class extends SatsConnectAdapter {
977
1001
  requestInternal = async (method, params) => {
978
1002
  return request(method, params, this.id);
979
1003
  };
1004
+ addListener = (event, cb) => {
1005
+ return addListener(
1006
+ event,
1007
+ // The types of the `addListener` function being called here are not
1008
+ // entirely accurate.
1009
+ cb,
1010
+ this.id
1011
+ );
1012
+ };
980
1013
  };
981
1014
 
982
1015
  // src/adapters/unisat.ts
@@ -1145,6 +1178,9 @@ var BaseAdapter = class extends SatsConnectAdapter {
1145
1178
  requestInternal = async (method, params) => {
1146
1179
  return request(method, params, this.id);
1147
1180
  };
1181
+ addListener = (..._args) => {
1182
+ throw new Error("Method not supported for `BaseAdapter`.");
1183
+ };
1148
1184
  };
1149
1185
 
1150
1186
  // src/adapters/index.ts
@@ -1190,7 +1226,8 @@ var extractOrValidateCapabilities = (provider, reportedCapabilities) => {
1190
1226
  sendBtcTransaction: validateCapability("sendBtcTransaction"),
1191
1227
  createInscription: validateCapability("createInscription"),
1192
1228
  createRepeatInscriptions: validateCapability("createRepeatInscriptions"),
1193
- signMultipleTransactions: validateCapability("signMultipleTransactions")
1229
+ signMultipleTransactions: validateCapability("signMultipleTransactions"),
1230
+ addListener: validateCapability("addListener")
1194
1231
  };
1195
1232
  return Object.entries(capabilityMap).reduce((acc, [capability, value]) => {
1196
1233
  if (value)
@@ -1388,6 +1425,9 @@ export {
1388
1425
  RpcErrorCode,
1389
1426
  RpcIdSchema,
1390
1427
  SatsConnectAdapter,
1428
+ accountChangeEventName,
1429
+ accountChangeSchema,
1430
+ addListener,
1391
1431
  addressSchema,
1392
1432
  createInscription,
1393
1433
  createRepeatInscriptions,
@@ -1428,6 +1468,8 @@ export {
1428
1468
  getWalletTypeRequestMessageSchema,
1429
1469
  getWalletTypeResultSchema,
1430
1470
  isProviderInstalled,
1471
+ networkChangeEventName,
1472
+ networkChangeSchema,
1431
1473
  removeDefaultProvider,
1432
1474
  renouncePermissionsMethodName,
1433
1475
  renouncePermissionsParamsSchema,
@@ -1463,6 +1505,7 @@ export {
1463
1505
  stxSignTransactionParamsSchema,
1464
1506
  stxSignTransactionRequestMessageSchema,
1465
1507
  stxSignTransactionResultSchema,
1508
+ walletEventSchema,
1466
1509
  walletTypeSchema,
1467
1510
  walletTypes
1468
1511
  };