@sats-connect/core 0.0.3-8ca018a → 0.0.3-aae39fb

package/dist/index.d.mts

@@ -381,6 +381,80 @@ type GetAccountsParams = {
 type GetAccountResult = Address$1[];
 type GetAccounts = MethodParamsAndResult<GetAccountsParams, GetAccountResult>;
 
+type CreateMintOrderRequest = {
+    runeName: string;
+    repeats: number;
+    refundAddress: string;
+    destinationAddress: string;
+    feeRate: number;
+    appServiceFee?: number;
+    appServiceFeeAddress?: string;
+};
+type EstimateMintOrderRequest = Omit<CreateMintOrderRequest, 'refundAddress'>;
+type EstimateOrderResponse = {
+    totalSize: number;
+    totalCost: number;
+    costBreakdown: {
+        postage: number;
+        networkFee: number;
+        serviceFee: number;
+        appServiceFee: number;
+    };
+};
+type CreateEtchOrderRequest = {
+    runeName: string;
+    divisibility?: number;
+    symbol?: string;
+    premine?: string;
+    isMintable: boolean;
+    terms?: {
+        amount?: string;
+        cap?: string;
+        heightStart?: string;
+        heightEnd?: string;
+        offsetStart?: string;
+        offsetEnd?: string;
+    };
+    inscriptionDetails?: {
+        contentType: string;
+        contentBase64: string;
+    };
+    delegateInscriptionId?: string;
+    destinationAddress: string;
+    refundAddress: string;
+    feeRate: number;
+    appServiceFee?: number;
+    appServiceFeeAddress?: string;
+};
+type EstimateEtchOrderRequest = Omit<CreateEtchOrderRequest, 'refundAddress'>;
+
+interface EstimateRunesMintParams extends EstimateMintOrderRequest {
+    network?: BitcoinNetworkType;
+}
+type EstimateRunesMintResult = EstimateOrderResponse;
+type EstimateRunesMint = MethodParamsAndResult<EstimateRunesMintParams, EstimateRunesMintResult>;
+interface MintRunesParams extends CreateMintOrderRequest {
+    network?: BitcoinNetworkType;
+}
+type MintRunesResult = {
+    orderId: string;
+    fundTransactionId: string;
+};
+type MintRunes = MethodParamsAndResult<MintRunesParams, MintRunesResult>;
+interface EstimateRunesEtchParams extends EstimateEtchOrderRequest {
+    network?: BitcoinNetworkType;
+}
+type EstimateRunesEtchResult = EstimateOrderResponse;
+type EstimateRunesEtch = MethodParamsAndResult<EstimateRunesEtchParams, EstimateRunesEtchResult>;
+interface EtchRunesParams extends CreateEtchOrderRequest {
+    network?: BitcoinNetworkType;
+}
+type EtchRunesResult = {
+    orderId: string;
+    fundTransactionId: string;
+};
+type EtchRunes = MethodParamsAndResult<EtchRunesParams, EtchRunesResult>;
+
 interface Pubkey {
     /**
      * When sending a transfer STX request to a wallet, users can generally
@@ -581,21 +655,33 @@ interface BtcRequests {
     signPsbt: SignPsbt;
 }
 type BtcRequestMethod = keyof BtcRequests;
-type Requests = BtcRequests & StxRequests;
+interface RunesRequests {
+    runes_estimateMint: EstimateRunesMint;
+    runes_mint: MintRunes;
+    runes_estimateEtch: EstimateRunesEtch;
+    runes_etch: EtchRunes;
+}
+type RunesRequestMethod = keyof RunesRequests;
+type Requests = BtcRequests & StxRequests & RunesRequests;
 type Return<Method> = Method extends keyof Requests ? Requests[Method]['result'] : never;
 type Params<Method> = Method extends keyof Requests ? Requests[Method]['params'] : never;
 
-declare const request: <Method extends keyof BtcRequests | keyof StxRequests>(method: Method, params: Params<Method>, providerId?: string) => Promise<RpcResult<Method>>;
+declare const request: <Method extends keyof BtcRequests | keyof StxRequests | keyof RunesRequests>(method: Method, params: Params<Method>, providerId?: string) => Promise<RpcResult<Method>>;
 
 declare abstract class SatsConnectAdapter {
     abstract readonly id: string;
-    abstract request<Method extends keyof Requests>(method: Method, params: Params<Method>): Promise<RpcResult<Method> | undefined>;
+    private mintRunes;
+    private etchRunes;
+    private estimateMint;
+    private estimateEtch;
+    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>;
 }
 
 declare class BaseAdapter extends SatsConnectAdapter {
     id: string;
     constructor(providerId: string);
-    request: <Method extends keyof BtcRequests | keyof StxRequests>(method: Method, params: Params<Method>) => Promise<RpcResult<Method> | undefined>;
+    requestInternal: <Method extends keyof BtcRequests | keyof StxRequests | keyof RunesRequests>(method: Method, params: Params<Method>) => Promise<RpcResult<Method> | undefined>;
 }
 
 declare const DefaultAdaptersInfo: Record<string, Provider>;
@@ -606,4 +692,4 @@ interface Config {
 }
 declare function createDefaultConfig(providers: SupportedWallet[]): Config;
 
-export { type Address$1 as Address, AddressPurpose, AddressType, BaseAdapter, type BitcoinNetwork, BitcoinNetworkType, type BitcoinProvider, type BtcRequestMethod, type BtcRequests, type CallContractParams, type CallContractResult, type Capability, type Config, type CreateInscriptionOptions, type CreateInscriptionPayload, type CreateInscriptionResponse, type CreateRepeatInscriptionsOptions, type CreateRepeatInscriptionsPayload, type CreateRepeatInscriptionsResponse, DefaultAdaptersInfo, type DeployContractParams, type DeployContractResult, type GetAccountResult, type GetAccounts, type GetAccountsParams, type GetAccountsResult, type GetAddressOptions, type GetAddressPayload, type GetAddressResponse, type GetAddresses, type GetAddressesParams, type GetAddressesResult, type GetCapabilitiesOptions, type GetCapabilitiesPayload, type GetCapabilitiesResponse, type GetInfo, type InputToSign, type MethodParamsAndResult, type Params, type Provider, type PsbtPayload, type Recipient$2 as Recipient, type RequestOptions, type RequestPayload, type Requests, type Return, type RpcBase, type RpcError, RpcErrorCode, type RpcErrorResponse, type RpcId, type RpcRequest, type RpcResponse, type RpcResult, type RpcSuccessResponse, SatsConnectAdapter, type SendBtcTransactionOptions, type SendBtcTransactionPayload, type SendBtcTransactionResponse, type SendTransfer, type SendTransferParams, type SerializedRecipient, type SerializedSendBtcTransactionPayload, type SignMessage, type SignMessageOptions, type SignMessageParams, type SignMessagePayload, type SignMessageResponse, type SignMultiplePsbtPayload, type SignMultipleTransactionOptions, type SignMultipleTransactionsPayload, type SignMultipleTransactionsResponse, type SignPsbt, type SignPsbtParams, type SignPsbtResult, type SignStructuredMessageResult, type SignStxMessageParams, type SignStxMessageResult, type SignTransactionOptions, type SignTransactionParams, type SignTransactionPayload, type SignTransactionResponse, type SignTransactionResult, type StxCallContract, type StxDeployContract, type StxGetAccounts, type StxGetAddresses, type StxRequestMethod, type StxRequests, type StxSignStructuredMessage, type StxSignStxMessage, type StxSignTransaction, type StxTransferStx, type SupportedWallet, type TransferStxParams, type TransferStxResult, createDefaultConfig, createInscription, createRepeatInscriptions, defaultAdapters, getAddress, getCapabilities, getDefaultProvider, getProviderById, getProviderOrThrow, getProviders, getSupportedWallets, isProviderInstalled, removeDefaultProvider, request, sendBtcTransaction, setDefaultProvider, signMessage, signMultipleTransactions, signTransaction };
+export { type Address$1 as Address, AddressPurpose, AddressType, BaseAdapter, type BitcoinNetwork, BitcoinNetworkType, type BitcoinProvider, type BtcRequestMethod, type BtcRequests, type CallContractParams, type CallContractResult, type Capability, type Config, type CreateInscriptionOptions, type CreateInscriptionPayload, type CreateInscriptionResponse, type CreateRepeatInscriptionsOptions, type CreateRepeatInscriptionsPayload, type CreateRepeatInscriptionsResponse, DefaultAdaptersInfo, type DeployContractParams, type DeployContractResult, type GetAccountResult, type GetAccounts, type GetAccountsParams, type GetAccountsResult, type GetAddressOptions, type GetAddressPayload, type GetAddressResponse, type GetAddresses, type GetAddressesParams, type GetAddressesResult, type GetCapabilitiesOptions, type GetCapabilitiesPayload, type GetCapabilitiesResponse, type GetInfo, type InputToSign, type MethodParamsAndResult, type Params, type Provider, type PsbtPayload, type Recipient$2 as Recipient, type RequestOptions, type RequestPayload, type Requests, type Return, type RpcBase, type RpcError, RpcErrorCode, type RpcErrorResponse, type RpcId, type RpcRequest, type RpcResponse, type RpcResult, type RpcSuccessResponse, type RunesRequestMethod, type RunesRequests, SatsConnectAdapter, type SendBtcTransactionOptions, type SendBtcTransactionPayload, type SendBtcTransactionResponse, type SendTransfer, type SendTransferParams, type SerializedRecipient, type SerializedSendBtcTransactionPayload, type SignMessage, type SignMessageOptions, type SignMessageParams, type SignMessagePayload, type SignMessageResponse, type SignMultiplePsbtPayload, type SignMultipleTransactionOptions, type SignMultipleTransactionsPayload, type SignMultipleTransactionsResponse, type SignPsbt, type SignPsbtParams, type SignPsbtResult, type SignStructuredMessageResult, type SignStxMessageParams, type SignStxMessageResult, type SignTransactionOptions, type SignTransactionParams, type SignTransactionPayload, type SignTransactionResponse, type SignTransactionResult, type StxCallContract, type StxDeployContract, type StxGetAccounts, type StxGetAddresses, type StxRequestMethod, type StxRequests, type StxSignStructuredMessage, type StxSignStxMessage, type StxSignTransaction, type StxTransferStx, type SupportedWallet, type TransferStxParams, type TransferStxResult, createDefaultConfig, createInscription, createRepeatInscriptions, defaultAdapters, getAddress, getCapabilities, getDefaultProvider, getProviderById, getProviderOrThrow, getProviders, getSupportedWallets, isProviderInstalled, removeDefaultProvider, request, sendBtcTransaction, setDefaultProvider, signMessage, signMultipleTransactions, signTransaction };

package/dist/index.mjs

@@ -1,5 +1,295 @@
+// src/types.ts
+var BitcoinNetworkType = /* @__PURE__ */ ((BitcoinNetworkType2) => {
+  BitcoinNetworkType2["Mainnet"] = "Mainnet";
+  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;
+})(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 RunesApi = class {
+  client;
+  constructor(network) {
+    this.client = axios.create({
+      baseURL: `${RUNES_API_BASE_URL(network)}`
+    });
+  }
+  estimateMintCost = async (mintParams) => {
+    try {
+      const response = await this.client.post("/mint/estimate", {
+        ...mintParams
+      });
+      return {
+        data: response.data
+      };
+    } catch (error) {
+      const err = error;
+      return {
+        error: {
+          code: err.response?.status,
+          message: err.response?.data
+        }
+      };
+    }
+  };
+  estimateEtchCost = async (etchParams) => {
+    try {
+      const response = await this.client.post("/etch/estimate", {
+        ...etchParams
+      });
+      return {
+        data: response.data
+      };
+    } catch (error) {
+      const err = error;
+      return {
+        error: {
+          code: err.response?.status,
+          message: err.response?.data
+        }
+      };
+    }
+  };
+  createMintOrder = async (mintOrderParams) => {
+    try {
+      const response = await this.client.post("/mint/orders", {
+        ...mintOrderParams
+      });
+      return {
+        data: response.data
+      };
+    } catch (error) {
+      const err = error;
+      return {
+        error: {
+          code: err.response?.status,
+          message: err.response?.data
+        }
+      };
+    }
+  };
+  createEtchOrder = async (etchOrderParams) => {
+    try {
+      const response = await this.client.post("/etch/orders", {
+        ...etchOrderParams
+      });
+      return {
+        data: response.data
+      };
+    } catch (error) {
+      const err = error;
+      return {
+        error: {
+          code: err.response?.status,
+          message: err.response?.data
+        }
+      };
+    }
+  };
+  executeMint = async (orderId, fundTransactionId) => {
+    try {
+      const response = await this.client.post(`/mint/orders/${orderId}/execute`, {
+        fundTransactionId
+      });
+      return {
+        data: response.data
+      };
+    } catch (error) {
+      const err = error;
+      return {
+        error: {
+          code: err.response?.status,
+          message: err.response?.data
+        }
+      };
+    }
+  };
+  executeEtch = async (orderId, fundTransactionId) => {
+    try {
+      const response = await this.client.post(`/etch/orders/${orderId}/execute`, {
+        fundTransactionId
+      });
+      return {
+        data: response.data
+      };
+    } catch (error) {
+      const err = error;
+      return {
+        error: {
+          code: err.response?.status,
+          message: err.response?.data
+        }
+      };
+    }
+  };
+};
+var testnetClient = new RunesApi("Testnet" /* Testnet */);
+var mainnetClient = new RunesApi("Mainnet" /* Mainnet */);
+var getRunesApiClient = (network = "Mainnet" /* Mainnet */) => network === "Mainnet" /* Mainnet */ ? mainnetClient : testnetClient;
+
 // src/adapters/satsConnectAdapter.ts
 var SatsConnectAdapter = class {
+  async mintRunes(params) {
+    try {
+      const orderResponse = await new RunesApi(params.network).createMintOrder(params);
+      if (!orderResponse.data) {
+        return {
+          status: "error",
+          error: {
+            code: orderResponse.error.code === 400 ? -32600 /* INVALID_REQUEST */ : -32603 /* INTERNAL_ERROR */,
+            message: orderResponse.error.message
+          }
+        };
+      }
+      const paymentResponse = await this.requestInternal("sendTransfer", {
+        recipients: [
+          {
+            address: orderResponse.data.fundAddress,
+            amount: orderResponse.data.fundAmount
+          }
+        ]
+      });
+      if (paymentResponse?.status !== "success") {
+        return {
+          status: "error",
+          error: {
+            code: -32e3 /* USER_REJECTION */,
+            message: "User rejected the payment request"
+          }
+        };
+      }
+      await new RunesApi(params.network).executeMint(
+        orderResponse.data.orderId,
+        paymentResponse.result.txid
+      );
+      return {
+        status: "success",
+        result: {
+          orderId: orderResponse.data.orderId,
+          fundTransactionId: paymentResponse.result.txid
+        }
+      };
+    } catch (error) {
+      return {
+        status: "error",
+        error: {
+          code: -32603 /* INTERNAL_ERROR */,
+          message: error.message
+        }
+      };
+    }
+  }
+  async etchRunes(params) {
+    try {
+      const orderResponse = await new RunesApi(params.network).createEtchOrder(params);
+      if (!orderResponse.data) {
+        return {
+          status: "error",
+          error: {
+            code: orderResponse.error.code === 400 ? -32600 /* INVALID_REQUEST */ : -32603 /* INTERNAL_ERROR */,
+            message: orderResponse.error.message
+          }
+        };
+      }
+      const paymentResponse = await this.requestInternal("sendTransfer", {
+        recipients: [
+          {
+            address: orderResponse.data.fundAddress,
+            amount: orderResponse.data.fundAmount
+          }
+        ]
+      });
+      if (paymentResponse?.status !== "success") {
+        return {
+          status: "error",
+          error: {
+            code: -32e3 /* USER_REJECTION */,
+            message: "User rejected the payment request"
+          }
+        };
+      }
+      await new RunesApi(params.network).executeEtch(
+        orderResponse.data.orderId,
+        paymentResponse.result.txid
+      );
+      return {
+        status: "success",
+        result: {
+          orderId: orderResponse.data.orderId,
+          fundTransactionId: paymentResponse.result.txid
+        }
+      };
+    } catch (error) {
+      return {
+        status: "error",
+        error: {
+          code: -32603 /* INTERNAL_ERROR */,
+          message: error.message
+        }
+      };
+    }
+  }
+  async estimateMint(params) {
+    const response = await getRunesApiClient(
+      params.network
+    ).estimateMintCost(params);
+    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 estimateEtch(params) {
+    const response = await getRunesApiClient(
+      params.network
+    ).estimateEtchCost(params);
+    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":
+        return this.mintRunes(params);
+      case "runes_etch":
+        return this.etchRunes(params);
+      case "runes_estimateMint":
+        return this.estimateMint(params);
+      case "runes_estimateEtch":
+        return this.estimateEtch(params);
+      default:
+        return this.requestInternal(method, params);
+    }
+  }
 };
 
 // src/provider/index.ts
@@ -78,32 +368,13 @@ var isRpcSuccessResponse = (response) => {
 // src/adapters/xverse.ts
 var XverseAdapter = class extends SatsConnectAdapter {
   id = DefaultAdaptersInfo.xverse.id;
-  request = async (method, params) => {
+  requestInternal = async (method, params) => {
     return request(method, params, this.id);
   };
 };
 
 // src/adapters/unisat.ts
 import { Buffer } from "buffer";
-
-// src/types.ts
-var BitcoinNetworkType = /* @__PURE__ */ ((BitcoinNetworkType2) => {
-  BitcoinNetworkType2["Mainnet"] = "Mainnet";
-  BitcoinNetworkType2["Testnet"] = "Testnet";
-  return BitcoinNetworkType2;
-})(BitcoinNetworkType || {});
-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/adapters/unisat.ts
 import { AddressType as AddressType2, getAddressInfo } from "bitcoin-address-validation";
 
 // src/addresses/index.ts
@@ -240,7 +511,7 @@ var UnisatAdapter = class extends SatsConnectAdapter {
       psbt: psbtHex
     };
   }
-  request = async (method, params) => {
+  requestInternal = async (method, params) => {
     try {
       switch (method) {
         case "getAccounts": {
@@ -306,7 +577,7 @@ var BaseAdapter = class extends SatsConnectAdapter {
     super();
     this.id = providerId;
   }
-  request = async (method, params) => {
+  requestInternal = async (method, params) => {
     return request(method, params, this.id);
   };
 };
@@ -459,15 +730,6 @@ var signMessage = async (options) => {
   }
 };
 
-// src/runes/index.ts
-import axios from "axios";
-var runesAPI = axios.create({
-  baseURL: "https://api.xverse.app/v1/runes",
-  headers: {
-    "Content-Type": "application/json"
-  }
-});
-
 // src/transactions/sendBtcTransaction.ts
 import { createUnsecuredToken as createUnsecuredToken6 } from "jsontokens";
 var serializer = (recipient) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sats-connect/core",
-  "version": "0.0.3-8ca018a",
+  "version": "0.0.3-aae39fb",
   "main": "dist/index.mjs",
   "module": "dist/index.mjs",
   "types": "dist/index.d.mts",
@@ -24,7 +24,7 @@
     ]
   },
   "dependencies": {
-    "axios": "^1.6.8",
+    "axios": "1.6.8",
     "bitcoin-address-validation": "2.2.3",
     "buffer": "6.0.3",
     "jsontokens": "4.0.1",