@sats-connect/core 0.1.2-aa7093b → 0.1.2-b66f8be

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 -29
  2. package/dist/index.mjs +771 -753
  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,237 +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())
871
- })
872
- )
873
- });
874
- var getRunesBalanceRequestMessageSchema = v7.object({
875
- ...rpcRequestMessageSchema.entries,
876
- ...v7.object({
877
- method: v7.literal(getRunesBalanceMethodName),
878
- params: getRunesBalanceParamsSchema,
879
- id: v7.string()
880
- }).entries
881
- });
882
- var transferRunesMethodName = "runes_transfer";
883
- var transferRunesParamsSchema = v7.object({
884
- recipients: v7.array(
885
- v7.object({
886
- runeName: v7.string(),
887
- amount: v7.string(),
888
- address: 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())
889
425
  })
890
426
  )
891
427
  });
892
- var transferRunesRequestSchema = v7.object({
893
- ...rpcRequestMessageSchema.entries,
894
- ...v7.object({
895
- method: v7.literal(transferRunesMethodName),
896
- params: transferRunesParamsSchema,
897
- id: v7.string()
898
- }).entries
899
- });
900
- var TransferRunesResultSchema = v7.object({
901
- txid: v7.string()
428
+ var getRunesBalanceRequestMessageSchema = v8.object({
429
+ ...rpcRequestMessageSchema.entries,
430
+ ...v8.object({
431
+ method: v8.literal(getRunesBalanceMethodName),
432
+ params: getRunesBalanceParamsSchema,
433
+ id: v8.string()
434
+ }).entries
902
435
  });
903
436
 
904
437
  // src/request/types/ordinalsMethods.ts
905
- import * as v8 from "valibot";
438
+ import * as v9 from "valibot";
906
439
  var getInscriptionsMethodName = "ord_getInscriptions";
907
- var getInscriptionsParamsSchema = v8.object({
908
- offset: v8.number(),
909
- limit: v8.number()
440
+ var getInscriptionsParamsSchema = v9.object({
441
+ offset: v9.number(),
442
+ limit: v9.number()
910
443
  });
911
- var getInscriptionsResultSchema = v8.object({
912
- total: v8.number(),
913
- limit: v8.number(),
914
- offset: v8.number(),
915
- inscriptions: v8.array(
916
- v8.object({
917
- inscriptionId: v8.string(),
918
- inscriptionNumber: v8.string(),
919
- address: v8.string(),
920
- collectionName: v8.optional(v8.string()),
921
- postage: v8.string(),
922
- contentLength: v8.string(),
923
- contentType: v8.string(),
924
- timestamp: v8.number(),
925
- offset: v8.number(),
926
- genesisTransaction: v8.string(),
927
- 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()
928
461
  })
929
462
  )
930
463
  });
931
- var getInscriptionsSchema = v8.object({
464
+ var getInscriptionsSchema = v9.object({
932
465
  ...rpcRequestMessageSchema.entries,
933
- ...v8.object({
934
- method: v8.literal(getInscriptionsMethodName),
466
+ ...v9.object({
467
+ method: v9.literal(getInscriptionsMethodName),
935
468
  params: getInscriptionsParamsSchema,
936
- id: v8.string()
469
+ id: v9.string()
937
470
  }).entries
938
471
  });
939
472
  var sendInscriptionsMethodName = "ord_sendInscriptions";
940
- var sendInscriptionsParamsSchema = v8.object({
941
- transfers: v8.array(
942
- v8.object({
943
- address: v8.string(),
944
- inscriptionId: v8.string()
473
+ var sendInscriptionsParamsSchema = v9.object({
474
+ transfers: v9.array(
475
+ v9.object({
476
+ address: v9.string(),
477
+ inscriptionId: v9.string()
945
478
  })
946
479
  )
947
480
  });
948
- var sendInscriptionsResultSchema = v8.object({
949
- txid: v8.string()
481
+ var sendInscriptionsResultSchema = v9.object({
482
+ txid: v9.string()
950
483
  });
951
- var sendInscriptionsSchema = v8.object({
484
+ var sendInscriptionsSchema = v9.object({
952
485
  ...rpcRequestMessageSchema.entries,
953
- ...v8.object({
954
- method: v8.literal(sendInscriptionsMethodName),
486
+ ...v9.object({
487
+ method: v9.literal(sendInscriptionsMethodName),
955
488
  params: sendInscriptionsParamsSchema,
956
- id: v8.string()
489
+ id: v9.string()
957
490
  }).entries
958
491
  });
959
492
 
@@ -963,33 +496,503 @@ var request = async (method, params, providerId) => {
963
496
  if (providerId) {
964
497
  provider = await getProviderById(providerId);
965
498
  }
966
- if (!provider) {
967
- 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
+ }
968
832
  }
969
- if (!method) {
970
- 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
+ };
971
858
  }
972
- const response = await provider.request(method, params);
973
- 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
+ }
974
881
  return {
975
882
  status: "error",
976
- error: response.error
883
+ error: {
884
+ code: response.error.code === 400 ? -32600 /* INVALID_REQUEST */ : -32603 /* INTERNAL_ERROR */,
885
+ message: response.error.message
886
+ }
977
887
  };
978
888
  }
979
- 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
+ }
980
897
  return {
981
- status: "success",
982
- 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
+ }
983
903
  };
984
904
  }
985
- return {
986
- status: "error",
987
- error: {
988
- code: -32603 /* INTERNAL_ERROR */,
989
- message: "Received unknown response from provider.",
990
- 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
+ };
991
919
  }
992
- };
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
+ }
993
996
  };
994
997
 
995
998
  // src/adapters/xverse.ts
@@ -998,6 +1001,15 @@ var XverseAdapter = class extends SatsConnectAdapter {
998
1001
  requestInternal = async (method, params) => {
999
1002
  return request(method, params, this.id);
1000
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
+ };
1001
1013
  };
1002
1014
 
1003
1015
  // src/adapters/unisat.ts
@@ -1166,6 +1178,9 @@ var BaseAdapter = class extends SatsConnectAdapter {
1166
1178
  requestInternal = async (method, params) => {
1167
1179
  return request(method, params, this.id);
1168
1180
  };
1181
+ addListener = (..._args) => {
1182
+ throw new Error("Method not supported for `BaseAdapter`.");
1183
+ };
1169
1184
  };
1170
1185
 
1171
1186
  // src/adapters/index.ts
@@ -1211,7 +1226,8 @@ var extractOrValidateCapabilities = (provider, reportedCapabilities) => {
1211
1226
  sendBtcTransaction: validateCapability("sendBtcTransaction"),
1212
1227
  createInscription: validateCapability("createInscription"),
1213
1228
  createRepeatInscriptions: validateCapability("createRepeatInscriptions"),
1214
- signMultipleTransactions: validateCapability("signMultipleTransactions")
1229
+ signMultipleTransactions: validateCapability("signMultipleTransactions"),
1230
+ addListener: validateCapability("addListener")
1215
1231
  };
1216
1232
  return Object.entries(capabilityMap).reduce((acc, [capability, value]) => {
1217
1233
  if (value)
@@ -1409,7 +1425,9 @@ export {
1409
1425
  RpcErrorCode,
1410
1426
  RpcIdSchema,
1411
1427
  SatsConnectAdapter,
1412
- TransferRunesResultSchema,
1428
+ accountChangeEventName,
1429
+ accountChangeSchema,
1430
+ addListener,
1413
1431
  addressSchema,
1414
1432
  createInscription,
1415
1433
  createRepeatInscriptions,
@@ -1450,6 +1468,8 @@ export {
1450
1468
  getWalletTypeRequestMessageSchema,
1451
1469
  getWalletTypeResultSchema,
1452
1470
  isProviderInstalled,
1471
+ networkChangeEventName,
1472
+ networkChangeSchema,
1453
1473
  removeDefaultProvider,
1454
1474
  renouncePermissionsMethodName,
1455
1475
  renouncePermissionsParamsSchema,
@@ -1485,9 +1505,7 @@ export {
1485
1505
  stxSignTransactionParamsSchema,
1486
1506
  stxSignTransactionRequestMessageSchema,
1487
1507
  stxSignTransactionResultSchema,
1488
- transferRunesMethodName,
1489
- transferRunesParamsSchema,
1490
- transferRunesRequestSchema,
1508
+ walletEventSchema,
1491
1509
  walletTypeSchema,
1492
1510
  walletTypes
1493
1511
  };