@sats-connect/core 0.0.4-caef0cb → 0.0.5-4f78052

package/dist/index.d.mts

@@ -427,6 +427,16 @@ type CreateEtchOrderRequest = {
     appServiceFeeAddress?: string;
 };
 type EstimateEtchOrderRequest = Omit<CreateEtchOrderRequest, 'refundAddress'>;
+type GetOrderRequest = {
+    id: string;
+};
+type GetOrderResponse = {
+    id: string;
+    orderType: 'rune_mint' | 'rune_etch';
+    state: 'new' | 'pending' | 'executing' | 'complete' | 'failed' | 'refunded' | 'stale';
+    reason?: string;
+    createdAt: string;
+};
 
 interface EstimateRunesMintParams extends EstimateMintOrderRequest {
     network?: BitcoinNetworkType;
@@ -454,6 +464,10 @@ type EtchRunesResult = {
     fundTransactionId: string;
 };
 type EtchRunes = MethodParamsAndResult<EtchRunesParams, EtchRunesResult>;
+interface GetOrderParams extends GetOrderRequest {
+    network?: BitcoinNetworkType;
+}
+type GetOrder = MethodParamsAndResult<GetOrderParams, GetOrderResponse>;
 
 interface Pubkey {
     /**
@@ -660,6 +674,7 @@ interface RunesRequests {
     runes_mint: MintRunes;
     runes_estimateEtch: EstimateRunesEtch;
     runes_etch: EtchRunes;
+    runes_getOrder: GetOrder;
 }
 type RunesRequestMethod = keyof RunesRequests;
 type Requests = BtcRequests & StxRequests & RunesRequests;
@@ -674,6 +689,7 @@ declare abstract class SatsConnectAdapter {
     private etchRunes;
     private estimateMint;
     private estimateEtch;
+    private getOrder;
     request<Method extends keyof Requests>(method: Method, params: Params<Method>): Promise<RpcResult<Method> | undefined>;
     protected abstract requestInternal<Method extends keyof Requests>(method: Method, params: Params<Method>): Promise<RpcResult<Method> | undefined>;
 }

package/dist/index.mjs

@@ -4,25 +4,25 @@ var BitcoinNetworkType = /* @__PURE__ */ ((BitcoinNetworkType2) => {
   BitcoinNetworkType2["Testnet"] = "Testnet";
   return BitcoinNetworkType2;
 })(BitcoinNetworkType || {});
-var RpcErrorCode = /* @__PURE__ */ ((RpcErrorCode3) => {
-  RpcErrorCode3[RpcErrorCode3["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
-  RpcErrorCode3[RpcErrorCode3["INVALID_REQUEST"] = -32600] = "INVALID_REQUEST";
-  RpcErrorCode3[RpcErrorCode3["METHOD_NOT_FOUND"] = -32601] = "METHOD_NOT_FOUND";
-  RpcErrorCode3[RpcErrorCode3["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
-  RpcErrorCode3[RpcErrorCode3["INTERNAL_ERROR"] = -32603] = "INTERNAL_ERROR";
-  RpcErrorCode3[RpcErrorCode3["USER_REJECTION"] = -32e3] = "USER_REJECTION";
-  RpcErrorCode3[RpcErrorCode3["METHOD_NOT_SUPPORTED"] = -32001] = "METHOD_NOT_SUPPORTED";
-  return RpcErrorCode3;
+var RpcErrorCode = /* @__PURE__ */ ((RpcErrorCode2) => {
+  RpcErrorCode2[RpcErrorCode2["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
+  RpcErrorCode2[RpcErrorCode2["INVALID_REQUEST"] = -32600] = "INVALID_REQUEST";
+  RpcErrorCode2[RpcErrorCode2["METHOD_NOT_FOUND"] = -32601] = "METHOD_NOT_FOUND";
+  RpcErrorCode2[RpcErrorCode2["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
+  RpcErrorCode2[RpcErrorCode2["INTERNAL_ERROR"] = -32603] = "INTERNAL_ERROR";
+  RpcErrorCode2[RpcErrorCode2["USER_REJECTION"] = -32e3] = "USER_REJECTION";
+  RpcErrorCode2[RpcErrorCode2["METHOD_NOT_SUPPORTED"] = -32001] = "METHOD_NOT_SUPPORTED";
+  return RpcErrorCode2;
 })(RpcErrorCode || {});
 
 // src/runes/index.ts
 import axios from "axios";
-var RUNES_API_BASE_URL = (network = "Mainnet" /* Mainnet */) => `https://ordinals${network === "Testnet" /* Testnet */ ? "-testnet" : ""}.xverse.app/v1/runes`;
+var ORDINALS_API_BASE_URL = (network = "Mainnet" /* Mainnet */) => `https://ordinals${network === "Testnet" /* Testnet */ ? "-testnet" : ""}.xverse.app/v1`;
 var RunesApi = class {
   client;
   constructor(network) {
     this.client = axios.create({
-      baseURL: `${RUNES_API_BASE_URL(network)}`
+      baseURL: ORDINALS_API_BASE_URL(network)
     });
   }
   parseError = (error) => {
@@ -33,7 +33,7 @@ var RunesApi = class {
   };
   estimateMintCost = async (mintParams) => {
     try {
-      const response = await this.client.post("/mint/estimate", {
+      const response = await this.client.post("/runes/mint/estimate", {
         ...mintParams
       });
       return {
@@ -48,7 +48,7 @@ var RunesApi = class {
   };
   estimateEtchCost = async (etchParams) => {
     try {
-      const response = await this.client.post("/etch/estimate", {
+      const response = await this.client.post("/runes/etch/estimate", {
         ...etchParams
       });
       return {
@@ -63,7 +63,7 @@ var RunesApi = class {
   };
   createMintOrder = async (mintOrderParams) => {
     try {
-      const response = await this.client.post("/mint/orders", {
+      const response = await this.client.post("/runes/mint/orders", {
         ...mintOrderParams
       });
       return {
@@ -78,7 +78,7 @@ var RunesApi = class {
   };
   createEtchOrder = async (etchOrderParams) => {
     try {
-      const response = await this.client.post("/etch/orders", {
+      const response = await this.client.post("/runes/etch/orders", {
         ...etchOrderParams
       });
       return {
@@ -93,7 +93,7 @@ var RunesApi = class {
   };
   executeMint = async (orderId, fundTransactionId) => {
     try {
-      const response = await this.client.post(`/mint/orders/${orderId}/execute`, {
+      const response = await this.client.post(`/runes/mint/orders/${orderId}/execute`, {
         fundTransactionId
       });
       return {
@@ -108,7 +108,7 @@ var RunesApi = class {
   };
   executeEtch = async (orderId, fundTransactionId) => {
     try {
-      const response = await this.client.post(`/etch/orders/${orderId}/execute`, {
+      const response = await this.client.post(`/runes/etch/orders/${orderId}/execute`, {
         fundTransactionId
       });
       return {
@@ -121,6 +121,19 @@ var RunesApi = class {
       };
     }
   };
+  getOrder = async (orderId) => {
+    try {
+      const response = await this.client.get(`/orders/${orderId}`);
+      return {
+        data: response.data
+      };
+    } catch (error) {
+      const err = error;
+      return {
+        error: this.parseError(err)
+      };
+    }
+  };
 };
 var testnetClient = new RunesApi("Testnet" /* Testnet */);
 var mainnetClient = new RunesApi("Mainnet" /* Mainnet */);
@@ -308,6 +321,22 @@ var SatsConnectAdapter = class {
       }
     };
   }
+  async getOrder(params) {
+    const response = await getRunesApiClient(params.network).getOrder(params.id);
+    if (response.data) {
+      return {
+        status: "success",
+        result: response.data
+      };
+    }
+    return {
+      status: "error",
+      error: {
+        code: response.error.code === 400 ? -32600 /* INVALID_REQUEST */ : -32603 /* INTERNAL_ERROR */,
+        message: response.error.message
+      }
+    };
+  }
   async request(method, params) {
     switch (method) {
       case "runes_mint":
@@ -318,6 +347,9 @@ var SatsConnectAdapter = class {
         return this.estimateMint(params);
       case "runes_estimateEtch":
         return this.estimateEtch(params);
+      case "runes_getOrder": {
+        return this.getOrder(params);
+      }
       default:
         return this.requestInternal(method, params);
     }
@@ -468,10 +500,8 @@ var UnisatAdapter = class extends SatsConnectAdapter {
     if (!purposes.includes("stacks" /* Stacks */)) {
       throw new Error("Only bitcoin addresses are supported");
     }
-    const [accounts, publicKey] = await Promise.all([
-      window.unisat.requestAccounts(),
-      window.unisat.getPublicKey()
-    ]);
+    const accounts = await window.unisat.requestAccounts();
+    const publicKey = await window.unisat.getPublicKey();
     const address = accounts[0];
     const addressType = getAddressInfo(accounts[0]).type;
     const pk = addressType === AddressType2.p2tr ? publicKey.slice(2) : publicKey;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sats-connect/core",
-  "version": "0.0.4-caef0cb",
+  "version": "0.0.5-4f78052",
   "main": "dist/index.mjs",
   "module": "dist/index.mjs",
   "types": "dist/index.d.mts",