@sats-connect/core 0.4.0-7721c7c → 0.4.0-7a3cb13

package/dist/index.mjs

@@ -1,6 +1,3 @@
-// src/provider/index.ts
-import omit from "lodash.omit";
-
 // src/provider/types.ts
 import * as v from "valibot";
 var accountChangeEventName = "accountChange";
@@ -50,12 +47,7 @@ function removeDefaultProvider() {
   localStorage.removeItem("sats-connect_defaultProvider");
 }
 function getSupportedWallets() {
-  const btc_providers = getProviders();
-  const allProviders = [...btc_providers];
-  for (const key in omit(DefaultAdaptersInfo, ["xverse"])) {
-    allProviders.push(DefaultAdaptersInfo[key]);
-  }
-  const wallets = allProviders.map((provider) => {
+  const wallets = Object.values(DefaultAdaptersInfo).map((provider) => {
     {
       return {
         ...provider,
@@ -68,11 +60,11 @@ function getSupportedWallets() {
 
 // src/types.ts
 import * as v2 from "valibot";
-var BitcoinNetworkType = /* @__PURE__ */ ((BitcoinNetworkType3) => {
-  BitcoinNetworkType3["Mainnet"] = "Mainnet";
-  BitcoinNetworkType3["Testnet"] = "Testnet";
-  BitcoinNetworkType3["Signet"] = "Signet";
-  return BitcoinNetworkType3;
+var BitcoinNetworkType = /* @__PURE__ */ ((BitcoinNetworkType2) => {
+  BitcoinNetworkType2["Mainnet"] = "Mainnet";
+  BitcoinNetworkType2["Testnet"] = "Testnet";
+  BitcoinNetworkType2["Signet"] = "Signet";
+  return BitcoinNetworkType2;
 })(BitcoinNetworkType || {});
 var RpcIdSchema = v2.optional(v2.union([v2.string(), v2.number(), v2.null()]));
 var rpcRequestMessageSchema = v2.object({
@@ -89,7 +81,7 @@ var rpcRequestMessageSchema = v2.object({
       v2.null()
     ])
   ),
-  id: RpcIdSchema
+  id: v2.unwrap(RpcIdSchema)
 });
 var RpcErrorCode = /* @__PURE__ */ ((RpcErrorCode2) => {
   RpcErrorCode2[RpcErrorCode2["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
@@ -118,13 +110,127 @@ var rpcResponseMessageSchema = v2.union([
 ]);
 
 // src/request/index.ts
-import * as v10 from "valibot";
+import * as v20 from "valibot";
+
+// src/request/types/stxMethods/callContract.ts
+import * as v3 from "valibot";
+var stxCallContractMethodName = "stx_callContract";
+var stxCallContractParamsSchema = v3.object({
+  /**
+   * The contract principal.
+   *
+   * E.g. `"SPKE...GD5C.my-contract"`
+   */
+  contract: v3.string(),
+  /**
+   * The name of the function to call.
+   *
+   * Note: spec changes ongoing,
+   * https://github.com/stacksgov/sips/pull/166#pullrequestreview-1914236999
+   */
+  functionName: v3.string(),
+  /**
+   * The function's arguments. The arguments are expected to be hex-encoded
+   * strings of Clarity values.
+   *
+   * To convert Clarity values to their hex representation, the `cvToString`
+   * helper from the `@stacks/transactions` package may be helpful.
+   *
+   * ```js
+   * import { cvToString } from '@stacks/transactions';
+   *
+   * const functionArgs = [someClarityValue1, someClarityValue2];
+   * const hexArgs = functionArgs.map(cvToString);
+   * ```
+   */
+  arguments: v3.optional(v3.array(v3.string()))
+});
+var stxCallContractResultSchema = v3.object({
+  /**
+   * The ID of the transaction.
+   */
+  txid: v3.string(),
+  /**
+   * A Stacks transaction as a hex-encoded string.
+   */
+  transaction: v3.string()
+});
+var stxCallContractRequestMessageSchema = v3.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v3.object({
+    method: v3.literal(stxCallContractMethodName),
+    params: stxCallContractParamsSchema,
+    id: v3.string()
+  }).entries
+});
+
+// src/request/types/stxMethods/deployContract.ts
+import * as v4 from "valibot";
+var stxDeployContractMethodName = "stx_deployContract";
+var stxDeployContractParamsSchema = v4.object({
+  /**
+   * Name of the contract.
+   */
+  name: v4.string(),
+  /**
+   * The source code of the Clarity contract.
+   */
+  clarityCode: v4.string(),
+  /**
+   * The version of the Clarity contract.
+   */
+  clarityVersion: v4.optional(v4.string())
+});
+var stxDeployContractResultSchema = v4.object({
+  /**
+   * The ID of the transaction.
+   */
+  txid: v4.string(),
+  /**
+   * A Stacks transaction as a hex-encoded string.
+   */
+  transaction: v4.string()
+});
+var stxDeployContractRequestMessageSchema = v4.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v4.object({
+    method: v4.literal(stxDeployContractMethodName),
+    params: stxDeployContractParamsSchema,
+    id: v4.string()
+  }).entries
+});
+
+// src/request/types/stxMethods/getAccounts.ts
+import * as v5 from "valibot";
+var stxGetAccountsMethodName = "stx_getAccounts";
+var stxGetAccountsParamsSchema = v5.nullish(v5.null());
+var stxGetAccountsResultSchema = v5.object({
+  /**
+   * The addresses generated for the given purposes.
+   */
+  addresses: v5.array(
+    v5.object({
+      address: v5.string(),
+      publicKey: v5.string(),
+      gaiaHubUrl: v5.string(),
+      gaiaAppKey: v5.string()
+    })
+  )
+});
+var stxGetAccountsRequestMessageSchema = v5.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v5.object({
+    method: v5.literal(stxGetAccountsMethodName),
+    params: stxGetAccountsParamsSchema,
+    id: v5.string()
+  }).entries
+});
 
 // src/addresses/index.ts
 import { createUnsecuredToken } from "jsontokens";
 
 // src/addresses/types.ts
-import * as v3 from "valibot";
+import * as v6 from "valibot";
 var AddressPurpose = /* @__PURE__ */ ((AddressPurpose2) => {
   AddressPurpose2["Ordinals"] = "ordinals";
   AddressPurpose2["Payment"] = "payment";
@@ -140,11 +246,11 @@ var AddressType = /* @__PURE__ */ ((AddressType3) => {
   AddressType3["stacks"] = "stacks";
   return AddressType3;
 })(AddressType || {});
-var addressSchema = v3.object({
-  address: v3.string(),
-  publicKey: v3.string(),
-  purpose: v3.enum(AddressPurpose),
-  addressType: v3.enum(AddressType)
+var addressSchema = v6.object({
+  address: v6.string(),
+  publicKey: v6.string(),
+  purpose: v6.enum(AddressPurpose),
+  addressType: v6.enum(AddressType)
 });
 
 // src/addresses/index.ts
@@ -164,119 +270,269 @@ var getAddress = async (options) => {
   }
 };
 
-// src/request/types/stxMethods.ts
-import * as v4 from "valibot";
+// src/request/types/stxMethods/getAddresses.ts
+import * as v7 from "valibot";
 var stxGetAddressesMethodName = "stx_getAddresses";
-var stxGetAddressesParamsSchema = v4.nullish(
-  v4.object({
+var stxGetAddressesParamsSchema = v7.nullish(
+  v7.object({
     /**
      * A message to be displayed to the user in the request prompt.
      */
-    message: v4.optional(v4.string())
+    message: v7.optional(v7.string())
   })
 );
-var stxGetAddressesResultSchema = v4.object({
+var stxGetAddressesResultSchema = v7.object({
   /**
    * The addresses generated for the given purposes.
    */
-  addresses: v4.array(addressSchema)
+  addresses: v7.array(addressSchema)
 });
-var stxGetAddressesRequestMessageSchema = v4.object({
+var stxGetAddressesRequestMessageSchema = v7.object({
   ...rpcRequestMessageSchema.entries,
-  ...v4.object({
-    method: v4.literal(stxGetAddressesMethodName),
+  ...v7.object({
+    method: v7.literal(stxGetAddressesMethodName),
     params: stxGetAddressesParamsSchema,
-    id: v4.string()
+    id: v7.string()
+  }).entries
+});
+
+// src/request/types/stxMethods/signMessage.ts
+import * as v8 from "valibot";
+var stxSignMessageMethodName = "stx_signMessage";
+var stxSignMessageParamsSchema = v8.object({
+  /**
+   * The message to sign.
+   */
+  message: v8.string(),
+  /**
+   * The public key to sign the message with.
+   */
+  publicKey: v8.string(),
+  /**
+   * The format version of the parameter.
+   */
+  parameterFormatVersion: v8.optional(v8.number())
+});
+var stxSignMessageResultSchema = v8.object({
+  /**
+   * The signature of the message.
+   */
+  signature: v8.string(),
+  /**
+   * The public key used to sign the message.
+   */
+  publicKey: v8.string()
+});
+var stxSignMessageRequestMessageSchema = v8.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v8.object({
+    method: v8.literal(stxSignMessageMethodName),
+    params: stxSignMessageParamsSchema,
+    id: v8.string()
+  }).entries
+});
+
+// src/request/types/stxMethods/signStructuredMessage.ts
+import * as v9 from "valibot";
+var stxSignStructuredMessageMethodName = "stx_signStructuredMessage";
+var stxSignStructuredMessageParamsSchema = v9.object({
+  /**
+   * The domain to be signed.
+   */
+  domain: v9.string(),
+  /**
+   * Message payload to be signed.
+   */
+  message: v9.string(),
+  /**
+   * The format version of the parameter.
+   */
+  parameterFormatVersion: v9.optional(v9.number()),
+  /**
+   * The public key to sign the message with.
+   */
+  publicKey: v9.optional(v9.string())
+});
+var stxSignStructuredMessageResultSchema = v9.object({
+  /**
+   * Signature of the message.
+   */
+  signature: v9.string(),
+  /**
+   * Public key as hex-encoded string.
+   */
+  publicKey: v9.string()
+});
+var stxSignStructuredMessageRequestMessageSchema = v9.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v9.object({
+    method: v9.literal(stxSignStructuredMessageMethodName),
+    params: stxSignStructuredMessageParamsSchema,
+    id: v9.string()
   }).entries
 });
+
+// src/request/types/stxMethods/signTransaction.ts
+import * as v10 from "valibot";
 var stxSignTransactionMethodName = "stx_signTransaction";
-var stxSignTransactionParamsSchema = v4.object({
+var stxSignTransactionParamsSchema = v10.object({
   /**
    * The transaction to sign as a hex-encoded string.
    */
-  transaction: v4.string(),
+  transaction: v10.string(),
   /**
    * The public key to sign the transaction with. The wallet may use any key
    * when not provided.
    */
-  pubkey: v4.optional(v4.string()),
+  pubkey: v10.optional(v10.string()),
   /**
    * Whether to broadcast the transaction after signing. Defaults to `true`.
    */
-  broadcast: v4.optional(v4.boolean())
+  broadcast: v10.optional(v10.boolean())
 });
-var stxSignTransactionResultSchema = v4.object({
+var stxSignTransactionResultSchema = v10.object({
   /**
    * The signed transaction as a hex-encoded string.
    */
-  transaction: v4.string()
+  transaction: v10.string()
 });
-var stxSignTransactionRequestMessageSchema = v4.object({
+var stxSignTransactionRequestMessageSchema = v10.object({
   ...rpcRequestMessageSchema.entries,
-  ...v4.object({
-    method: v4.literal(stxSignTransactionMethodName),
+  ...v10.object({
+    method: v10.literal(stxSignTransactionMethodName),
     params: stxSignTransactionParamsSchema,
-    id: v4.string()
+    id: v10.string()
+  }).entries
+});
+
+// src/request/types/stxMethods/transferStx.ts
+import * as v11 from "valibot";
+var stxTransferStxMethodName = "stx_transferStx";
+var stxTransferStxParamsSchema = v11.object({
+  /**
+   * Amount of STX tokens to transfer in microstacks as a string. Anything
+   * parseable by `BigInt` is acceptable.
+   *
+   * Example,
+   *
+   * ```js
+   * const amount1 = 1234;
+   * const amount2 = 1234n;
+   * const amount3 = '1234';
+   * ```
+   */
+  amount: v11.union([v11.number(), v11.string()]),
+  /**
+   * The recipeint's principal.
+   */
+  recipient: v11.string(),
+  /**
+   * A string representing the memo.
+   */
+  memo: v11.optional(v11.string()),
+  /**
+   * Version of parameter format.
+   */
+  version: v11.optional(v11.string()),
+  /**
+   * The mode of the post conditions.
+   */
+  postConditionMode: v11.optional(v11.number()),
+  /**
+   * A hex-encoded string representing the post conditions.
+   *
+   * A post condition may be converted to it's hex representation using the `serializePostCondition` helper from the `@stacks/transactions` package,
+   *
+   * ```js
+   * import { serializePostCondition } from '@stacks/transactions';
+   *
+   * const postCondition = somePostCondition;
+   * const hexPostCondition = serializePostCondition(postCondition).toString('hex');
+   * ```
+   */
+  postConditions: v11.optional(v11.array(v11.string())),
+  /**
+   * The public key to sign the transaction with. The wallet may use any key
+   * when not provided.
+   */
+  pubkey: v11.optional(v11.string())
+});
+var stxTransferStxResultSchema = v11.object({
+  /**
+   * The ID of the transaction.
+   */
+  txid: v11.string(),
+  /**
+   * A Stacks transaction as a hex-encoded string.
+   */
+  transaction: v11.string()
+});
+var stxTransferStxRequestMessageSchema = v11.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v11.object({
+    method: v11.literal(stxTransferStxMethodName),
+    params: stxTransferStxParamsSchema,
+    id: v11.string()
   }).entries
 });
 
 // src/request/types/btcMethods.ts
-import * as v6 from "valibot";
+import * as v13 from "valibot";
 
 // src/request/types/common.ts
-import * as v5 from "valibot";
+import * as v12 from "valibot";
 var walletTypes = ["software", "ledger"];
-var walletTypeSchema = v5.picklist(walletTypes);
+var walletTypeSchema = v12.picklist(walletTypes);
 
 // src/request/types/btcMethods.ts
 var getInfoMethodName = "getInfo";
-var getInfoParamsSchema = v6.nullish(v6.null());
-var getInfoResultSchema = v6.object({
+var getInfoParamsSchema = v13.nullish(v13.null());
+var getInfoResultSchema = v13.object({
   /**
    * Version of the wallet.
    */
-  version: v6.string(),
+  version: v13.string(),
   /**
    * [WBIP](https://wbips.netlify.app/wbips/WBIP002) methods supported by the wallet.
    */
-  methods: v6.optional(v6.array(v6.string())),
+  methods: v13.optional(v13.array(v13.string())),
   /**
    * List of WBIP standards supported by the wallet. Not currently used.
    */
-  supports: v6.array(v6.string())
+  supports: v13.array(v13.string())
 });
-var getInfoRequestMessageSchema = v6.object({
+var getInfoRequestMessageSchema = v13.object({
   ...rpcRequestMessageSchema.entries,
-  ...v6.object({
-    method: v6.literal(getInfoMethodName),
+  ...v13.object({
+    method: v13.literal(getInfoMethodName),
     params: getInfoParamsSchema,
-    id: v6.string()
+    id: v13.string()
   }).entries
 });
 var getAddressesMethodName = "getAddresses";
-var getAddressesParamsSchema = v6.object({
+var getAddressesParamsSchema = v13.object({
   /**
    * The purposes for which to generate addresses. See
    * {@linkcode AddressPurpose} for available purposes.
    */
-  purposes: v6.array(v6.enum(AddressPurpose)),
+  purposes: v13.array(v13.enum(AddressPurpose)),
   /**
    * A message to be displayed to the user in the request prompt.
    */
-  message: v6.optional(v6.string())
+  message: v13.optional(v13.string())
 });
-var getAddressesResultSchema = v6.object({
+var getAddressesResultSchema = v13.object({
   /**
    * The addresses generated for the given purposes.
    */
-  addresses: v6.array(addressSchema)
+  addresses: v13.array(addressSchema)
 });
-var getAddressesRequestMessageSchema = v6.object({
+var getAddressesRequestMessageSchema = v13.object({
   ...rpcRequestMessageSchema.entries,
-  ...v6.object({
-    method: v6.literal(getAddressesMethodName),
+  ...v13.object({
+    method: v13.literal(getAddressesMethodName),
     params: getAddressesParamsSchema,
-    id: v6.string()
+    id: v13.string()
   }).entries
 });
 var signMessageMethodName = "signMessage";
@@ -285,312 +541,437 @@ var MessageSigningProtocols = /* @__PURE__ */ ((MessageSigningProtocols2) => {
   MessageSigningProtocols2["BIP322"] = "BIP322";
   return MessageSigningProtocols2;
 })(MessageSigningProtocols || {});
-var signMessageParamsSchema = v6.object({
+var signMessageParamsSchema = v13.object({
   /**
    * The address used for signing.
    **/
-  address: v6.string(),
+  address: v13.string(),
   /**
    * The message to sign.
    **/
-  message: v6.string(),
+  message: v13.string(),
   /**
    * The protocol to use for signing the message.
    */
-  protocol: v6.optional(v6.enum(MessageSigningProtocols))
+  protocol: v13.optional(v13.enum(MessageSigningProtocols))
 });
-var signMessageResultSchema = v6.object({
+var signMessageResultSchema = v13.object({
   /**
    * The signature of the message.
    */
-  signature: v6.string(),
+  signature: v13.string(),
   /**
    * hash of the message.
    */
-  messageHash: v6.string(),
+  messageHash: v13.string(),
   /**
    * The address used for signing.
    */
-  address: v6.string(),
+  address: v13.string(),
   /**
    * The protocol to use for signing the message.
    */
-  protocol: v6.enum(MessageSigningProtocols)
+  protocol: v13.enum(MessageSigningProtocols)
 });
-var signMessageRequestMessageSchema = v6.object({
+var signMessageRequestMessageSchema = v13.object({
   ...rpcRequestMessageSchema.entries,
-  ...v6.object({
-    method: v6.literal(signMessageMethodName),
+  ...v13.object({
+    method: v13.literal(signMessageMethodName),
     params: signMessageParamsSchema,
-    id: v6.string()
+    id: v13.string()
+  }).entries
+});
+var sendTransferMethodName = "sendTransfer";
+var sendTransferParamsSchema = v13.object({
+  /**
+   * Array of recipients to send to.
+   * The amount to send to each recipient is in satoshis.
+   */
+  recipients: v13.array(
+    v13.object({
+      address: v13.string(),
+      amount: v13.number()
+    })
+  )
+});
+var sendTransferResultSchema = v13.object({
+  /**
+   * The transaction id as a hex-encoded string.
+   */
+  txid: v13.string()
+});
+var sendTransferRequestMessageSchema = v13.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v13.object({
+    method: v13.literal(sendTransferMethodName),
+    params: sendTransferParamsSchema,
+    id: v13.string()
+  }).entries
+});
+var signPsbtMethodName = "signPsbt";
+var signPsbtParamsSchema = v13.object({
+  /**
+   * The base64 encoded PSBT to sign.
+   */
+  psbt: v13.string(),
+  /**
+   * The inputs to sign.
+   * The key is the address and the value is an array of indexes of the inputs to sign.
+   */
+  signInputs: v13.record(v13.string(), v13.array(v13.number())),
+  allowedSignHash: v13.optional(v13.number()),
+  /**
+   * Whether to broadcast the transaction after signing.
+   **/
+  broadcast: v13.optional(v13.boolean())
+});
+var signPsbtResultSchema = v13.object({
+  /**
+   * The base64 encoded PSBT after signing.
+   */
+  psbt: v13.string(),
+  /**
+   * The transaction id as a hex-encoded string.
+   * This is only returned if the transaction was broadcast.
+   **/
+  txid: v13.optional(v13.string())
+});
+var signPsbtRequestMessageSchema = v13.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v13.object({
+    method: v13.literal(signPsbtMethodName),
+    params: signPsbtParamsSchema,
+    id: v13.string()
   }).entries
 });
 var getAccountsMethodName = "getAccounts";
-var getAccountsParamsSchema = v6.object({
+var getAccountsParamsSchema = v13.object({
   /**
    * The purposes for which to generate addresses. See
    * {@linkcode AddressPurpose} for available purposes.
    */
-  purposes: v6.array(v6.enum(AddressPurpose)),
+  purposes: v13.array(v13.enum(AddressPurpose)),
   /**
    * A message to be displayed to the user in the request prompt.
    */
-  message: v6.optional(v6.string())
+  message: v13.optional(v13.string())
 });
-var getAccountsResultSchema = v6.array(
-  v6.object({
+var getAccountsResultSchema = v13.array(
+  v13.object({
     ...addressSchema.entries,
-    ...v6.object({
+    ...v13.object({
       walletType: walletTypeSchema
     }).entries
   })
 );
-var getAccountsRequestMessageSchema = v6.object({
+var getAccountsRequestMessageSchema = v13.object({
   ...rpcRequestMessageSchema.entries,
-  ...v6.object({
-    method: v6.literal(getAccountsMethodName),
+  ...v13.object({
+    method: v13.literal(getAccountsMethodName),
     params: getAccountsParamsSchema,
-    id: v6.string()
+    id: v13.string()
   }).entries
 });
 var getBalanceMethodName = "getBalance";
-var getBalanceParamsSchema = v6.nullish(v6.null());
-var getBalanceResultSchema = v6.object({
+var getBalanceParamsSchema = v13.nullish(v13.null());
+var getBalanceResultSchema = v13.object({
   /**
    * The confirmed balance of the wallet in sats. Using a string due to chrome
    * messages not supporting bigint
    * (https://issues.chromium.org/issues/40116184).
    */
-  confirmed: v6.string(),
+  confirmed: v13.string(),
   /**
    * The unconfirmed balance of the wallet in sats. Using a string due to chrome
    * messages not supporting bigint
    * (https://issues.chromium.org/issues/40116184).
    */
-  unconfirmed: v6.string(),
+  unconfirmed: v13.string(),
   /**
    * The total balance (both confirmed and unconfrimed UTXOs) of the wallet in
    * sats. Using a string due to chrome messages not supporting bigint
    * (https://issues.chromium.org/issues/40116184).
    */
-  total: v6.string()
+  total: v13.string()
 });
-var getBalanceRequestMessageSchema = v6.object({
+var getBalanceRequestMessageSchema = v13.object({
   ...rpcRequestMessageSchema.entries,
-  ...v6.object({
-    method: v6.literal(getBalanceMethodName),
-    id: v6.string()
+  ...v13.object({
+    method: v13.literal(getBalanceMethodName),
+    id: v13.string()
   }).entries
 });
 
 // src/request/types/walletMethods.ts
-import * as v7 from "valibot";
+import * as v14 from "valibot";
 import { permissions } from "@secretkeylabs/xverse-core";
-var permissionWithoutClientId = v7.variant("type", [
-  v7.omit(permissions.resources.account.accountPermissionSchema, ["clientId"]),
-  v7.omit(permissions.resources.wallet.walletPermissionSchema, ["clientId"])
+var permissionTemplate = v14.variant("type", [
+  v14.object({
+    ...v14.omit(permissions.resources.account.accountPermissionSchema, ["clientId"]).entries
+  }),
+  v14.object({
+    ...v14.omit(permissions.resources.wallet.walletPermissionSchema, ["clientId"]).entries
+  })
 ]);
 var requestPermissionsMethodName = "wallet_requestPermissions";
-var requestPermissionsParamsSchema = v7.nullish(v7.array(permissionWithoutClientId));
-var requestPermissionsResultSchema = v7.literal(true);
-var requestPermissionsRequestMessageSchema = v7.object({
+var requestPermissionsParamsSchema = v14.nullish(v14.array(permissionTemplate));
+var requestPermissionsResultSchema = v14.literal(true);
+var requestPermissionsRequestMessageSchema = v14.object({
   ...rpcRequestMessageSchema.entries,
-  ...v7.object({
-    method: v7.literal(requestPermissionsMethodName),
+  ...v14.object({
+    method: v14.literal(requestPermissionsMethodName),
     params: requestPermissionsParamsSchema,
-    id: v7.string()
+    id: v14.string()
   }).entries
 });
 var renouncePermissionsMethodName = "wallet_renouncePermissions";
-var renouncePermissionsParamsSchema = v7.nullish(v7.null());
-var renouncePermissionsResultSchema = v7.nullish(v7.null());
-var renouncePermissionsRequestMessageSchema = v7.object({
+var renouncePermissionsParamsSchema = v14.nullish(v14.null());
+var renouncePermissionsResultSchema = v14.nullish(v14.null());
+var renouncePermissionsRequestMessageSchema = v14.object({
   ...rpcRequestMessageSchema.entries,
-  ...v7.object({
-    method: v7.literal(renouncePermissionsMethodName),
+  ...v14.object({
+    method: v14.literal(renouncePermissionsMethodName),
     params: renouncePermissionsParamsSchema,
-    id: v7.string()
+    id: v14.string()
   }).entries
 });
 var disconnectMethodName = "wallet_disconnect";
-var disconnectParamsSchema = v7.nullish(v7.null());
-var disconnectResultSchema = v7.nullish(v7.null());
-var disconnectRequestMessageSchema = v7.object({
+var disconnectParamsSchema = v14.nullish(v14.null());
+var disconnectResultSchema = v14.nullish(v14.null());
+var disconnectRequestMessageSchema = v14.object({
   ...rpcRequestMessageSchema.entries,
-  ...v7.object({
-    method: v7.literal(disconnectMethodName),
+  ...v14.object({
+    method: v14.literal(disconnectMethodName),
     params: disconnectParamsSchema,
-    id: v7.string()
+    id: v14.string()
   }).entries
 });
 var getWalletTypeMethodName = "wallet_getWalletType";
-var getWalletTypeParamsSchema = v7.nullish(v7.null());
+var getWalletTypeParamsSchema = v14.nullish(v14.null());
 var getWalletTypeResultSchema = walletTypeSchema;
-var getWalletTypeRequestMessageSchema = v7.object({
+var getWalletTypeRequestMessageSchema = v14.object({
   ...rpcRequestMessageSchema.entries,
-  ...v7.object({
-    method: v7.literal(getWalletTypeMethodName),
+  ...v14.object({
+    method: v14.literal(getWalletTypeMethodName),
     params: getWalletTypeParamsSchema,
-    id: v7.string()
+    id: v14.string()
   }).entries
 });
 var getCurrentPermissionsMethodName = "wallet_getCurrentPermissions";
-var getCurrentPermissionsParamsSchema = v7.nullish(v7.null());
-var getCurrentPermissionsResultSchema = v7.array(permissions.store.permission);
-var getCurrentPermissionsRequestMessageSchema = v7.object({
+var getCurrentPermissionsParamsSchema = v14.nullish(v14.null());
+var getCurrentPermissionsResultSchema = v14.array(permissions.store.permission);
+var getCurrentPermissionsRequestMessageSchema = v14.object({
   ...rpcRequestMessageSchema.entries,
-  ...v7.object({
-    method: v7.literal(getCurrentPermissionsMethodName),
+  ...v14.object({
+    method: v14.literal(getCurrentPermissionsMethodName),
     params: getCurrentPermissionsParamsSchema,
-    id: v7.string()
+    id: v14.string()
   }).entries
 });
 var getAccountMethodName = "wallet_getAccount";
-var getAccountParamsSchema = v7.nullish(v7.null());
-var getAccountResultSchema = v7.object({
+var getAccountParamsSchema = v14.nullish(v14.null());
+var getAccountResultSchema = v14.object({
   id: permissions.utils.account.accountIdSchema,
-  addresses: v7.array(addressSchema),
+  addresses: v14.array(addressSchema),
   walletType: walletTypeSchema
 });
-var getAccountRequestMessageSchema = v7.object({
+var getAccountRequestMessageSchema = v14.object({
   ...rpcRequestMessageSchema.entries,
-  ...v7.object({
-    method: v7.literal(getAccountMethodName),
+  ...v14.object({
+    method: v14.literal(getAccountMethodName),
     params: getAccountParamsSchema,
-    id: v7.string()
-  }).entries
-});
-var registerClientMethodName = "wallet_registerClient";
-var registerClientParamsSchema = v7.object({
-  name: v7.optional(v7.string()),
-  description: v7.optional(v7.string())
-});
-var registerClientResultSchema = v7.object({
-  id: v7.string()
-});
-var registerClientRequestMessageSchema = v7.object({
-  ...rpcRequestMessageSchema.entries,
-  ...v7.object({
-    method: v7.literal(registerClientMethodName),
-    params: registerClientParamsSchema,
-    id: v7.string()
+    id: v14.string()
   }).entries
 });
 var connectMethodName = "wallet_connect";
-var connectParamsSchema = v7.nullish(
-  v7.object({
-    permissions: v7.optional(v7.array(permissionWithoutClientId)),
-    clientInfo: registerClientParamsSchema
+var connectParamsSchema = v14.nullish(
+  v14.object({
+    permissions: v14.optional(v14.array(permissionTemplate))
   })
 );
 var connectResultSchema = getAccountResultSchema;
-var connectRequestMessageSchema = v7.object({
+var connectRequestMessageSchema = v14.object({
   ...rpcRequestMessageSchema.entries,
-  ...v7.object({
-    method: v7.literal(connectMethodName),
+  ...v14.object({
+    method: v14.literal(connectMethodName),
     params: connectParamsSchema,
-    id: v7.string()
+    id: v14.string()
   }).entries
 });
 
-// src/request/types/runesMethods.ts
-import * as v8 from "valibot";
-var getRunesBalanceMethodName = "runes_getBalance";
-var getRunesBalanceParamsSchema = v8.nullish(v8.null());
-var getRunesBalanceResultSchema = v8.object({
-  balances: v8.array(
-    v8.object({
-      runeName: v8.string(),
-      amount: v8.string(),
-      divisibility: v8.number(),
-      symbol: v8.string(),
-      inscriptionId: v8.nullish(v8.string())
+// src/request/types/runesMethods/etch.ts
+import * as v15 from "valibot";
+var runesEtchMethodName = "runes_etch";
+var etchTermsSchema = v15.object({
+  amount: v15.string(),
+  cap: v15.string(),
+  heightStart: v15.optional(v15.string()),
+  heightEnd: v15.optional(v15.string()),
+  offsetStart: v15.optional(v15.string()),
+  offsetEnd: v15.optional(v15.string())
+});
+var inscriptionDetailsSchema = v15.object({
+  contentType: v15.string(),
+  contentBase64: v15.string()
+});
+var runesEtchParamsSchema = v15.object({
+  runeName: v15.string(),
+  divisibility: v15.optional(v15.number()),
+  symbol: v15.optional(v15.string()),
+  premine: v15.optional(v15.string()),
+  isMintable: v15.boolean(),
+  delegateInscriptionId: v15.optional(v15.string()),
+  destinationAddress: v15.string(),
+  refundAddress: v15.string(),
+  feeRate: v15.number(),
+  appServiceFee: v15.optional(v15.number()),
+  appServiceFeeAddress: v15.optional(v15.string()),
+  terms: v15.optional(etchTermsSchema),
+  inscriptionDetails: v15.optional(inscriptionDetailsSchema),
+  network: v15.optional(v15.enum(BitcoinNetworkType))
+});
+var runesEtchResultSchema = v15.object({
+  orderId: v15.string(),
+  fundTransactionId: v15.string(),
+  fundingAddress: v15.string()
+});
+var runesEtchRequestMessageSchema = v15.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v15.object({
+    method: v15.literal(runesEtchMethodName),
+    params: runesEtchParamsSchema,
+    id: v15.string()
+  }).entries
+});
+
+// src/request/types/runesMethods/getBalance.ts
+import * as v16 from "valibot";
+var runesGetBalanceMethodName = "runes_getBalance";
+var runesGetBalanceParamsSchema = v16.nullish(v16.null());
+var runesGetBalanceResultSchema = v16.object({
+  balances: v16.array(
+    v16.object({
+      runeName: v16.string(),
+      amount: v16.string(),
+      divisibility: v16.number(),
+      symbol: v16.string(),
+      inscriptionId: v16.nullish(v16.string())
     })
   )
 });
-var getRunesBalanceRequestMessageSchema = v8.object({
+var runesGetBalanceRequestMessageSchema = v16.object({
   ...rpcRequestMessageSchema.entries,
-  ...v8.object({
-    method: v8.literal(getRunesBalanceMethodName),
-    params: getRunesBalanceParamsSchema,
-    id: v8.string()
+  ...v16.object({
+    method: v16.literal(runesGetBalanceMethodName),
+    params: runesGetBalanceParamsSchema,
+    id: v16.string()
   }).entries
 });
-var transferRunesMethodName = "runes_transfer";
-var transferRunesParamsSchema = v8.object({
-  recipients: v8.array(
-    v8.object({
-      runeName: v8.string(),
-      amount: v8.string(),
-      address: v8.string()
+
+// src/request/types/runesMethods/mint.ts
+import * as v17 from "valibot";
+var runesMintMethodName = "runes_mint";
+var runesMintParamsSchema = v17.object({
+  appServiceFee: v17.optional(v17.number()),
+  appServiceFeeAddress: v17.optional(v17.string()),
+  destinationAddress: v17.string(),
+  feeRate: v17.number(),
+  refundAddress: v17.string(),
+  repeats: v17.number(),
+  runeName: v17.string(),
+  network: v17.optional(v17.enum(BitcoinNetworkType))
+});
+var runesMintResultSchema = v17.object({
+  orderId: v17.string(),
+  fundTransactionId: v17.string(),
+  fundingAddress: v17.string()
+});
+var runesMintRequestMessageSchema = v17.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v17.object({
+    method: v17.literal(runesMintMethodName),
+    params: runesMintParamsSchema,
+    id: v17.string()
+  }).entries
+});
+
+// src/request/types/runesMethods/transfer.ts
+import * as v18 from "valibot";
+var runesTransferMethodName = "runes_transfer";
+var runesTransferParamsSchema = v18.object({
+  recipients: v18.array(
+    v18.object({
+      runeName: v18.string(),
+      amount: v18.string(),
+      address: v18.string()
     })
   )
 });
-var transferRunesRequestSchema = v8.object({
+var runesTransferResultSchema = v18.object({
+  txid: v18.string()
+});
+var runesTransferRequestMessageSchema = v18.object({
   ...rpcRequestMessageSchema.entries,
-  ...v8.object({
-    method: v8.literal(transferRunesMethodName),
-    params: transferRunesParamsSchema,
-    id: v8.string()
+  ...v18.object({
+    method: v18.literal(runesTransferMethodName),
+    params: runesTransferParamsSchema,
+    id: v18.string()
   }).entries
 });
-var TransferRunesResultSchema = v8.object({
-  txid: v8.string()
-});
 
 // src/request/types/ordinalsMethods.ts
-import * as v9 from "valibot";
+import * as v19 from "valibot";
 var getInscriptionsMethodName = "ord_getInscriptions";
-var getInscriptionsParamsSchema = v9.object({
-  offset: v9.number(),
-  limit: v9.number()
-});
-var getInscriptionsResultSchema = v9.object({
-  total: v9.number(),
-  limit: v9.number(),
-  offset: v9.number(),
-  inscriptions: v9.array(
-    v9.object({
-      inscriptionId: v9.string(),
-      inscriptionNumber: v9.string(),
-      address: v9.string(),
-      collectionName: v9.optional(v9.string()),
-      postage: v9.string(),
-      contentLength: v9.string(),
-      contentType: v9.string(),
-      timestamp: v9.number(),
-      offset: v9.number(),
-      genesisTransaction: v9.string(),
-      output: v9.string()
+var getInscriptionsParamsSchema = v19.object({
+  offset: v19.number(),
+  limit: v19.number()
+});
+var getInscriptionsResultSchema = v19.object({
+  total: v19.number(),
+  limit: v19.number(),
+  offset: v19.number(),
+  inscriptions: v19.array(
+    v19.object({
+      inscriptionId: v19.string(),
+      inscriptionNumber: v19.string(),
+      address: v19.string(),
+      collectionName: v19.optional(v19.string()),
+      postage: v19.string(),
+      contentLength: v19.string(),
+      contentType: v19.string(),
+      timestamp: v19.number(),
+      offset: v19.number(),
+      genesisTransaction: v19.string(),
+      output: v19.string()
     })
   )
 });
-var getInscriptionsSchema = v9.object({
+var getInscriptionsRequestMessageSchema = v19.object({
   ...rpcRequestMessageSchema.entries,
-  ...v9.object({
-    method: v9.literal(getInscriptionsMethodName),
+  ...v19.object({
+    method: v19.literal(getInscriptionsMethodName),
     params: getInscriptionsParamsSchema,
-    id: v9.string()
+    id: v19.string()
   }).entries
 });
 var sendInscriptionsMethodName = "ord_sendInscriptions";
-var sendInscriptionsParamsSchema = v9.object({
-  transfers: v9.array(
-    v9.object({
-      address: v9.string(),
-      inscriptionId: v9.string()
+var sendInscriptionsParamsSchema = v19.object({
+  transfers: v19.array(
+    v19.object({
+      address: v19.string(),
+      inscriptionId: v19.string()
     })
   )
 });
-var sendInscriptionsResultSchema = v9.object({
-  txid: v9.string()
+var sendInscriptionsResultSchema = v19.object({
+  txid: v19.string()
 });
-var sendInscriptionsSchema = v9.object({
+var sendInscriptionsRequestMessageSchema = v19.object({
   ...rpcRequestMessageSchema.entries,
-  ...v9.object({
-    method: v9.literal(sendInscriptionsMethodName),
+  ...v19.object({
+    method: v19.literal(sendInscriptionsMethodName),
     params: sendInscriptionsParamsSchema,
-    id: v9.string()
+    id: v19.string()
   }).entries
 });
 
@@ -607,13 +988,13 @@ var request = async (method, params, providerId) => {
     throw new Error("A wallet method is required");
   }
   const response = await provider.request(method, params);
-  if (v10.is(rpcErrorResponseMessageSchema, response)) {
+  if (v20.is(rpcErrorResponseMessageSchema, response)) {
     return {
       status: "error",
       error: response.error
     };
   }
-  if (v10.is(rpcSuccessResponseMessageSchema, response)) {
+  if (v20.is(rpcSuccessResponseMessageSchema, response)) {
     return {
       status: "success",
       result: response.result
@@ -1124,17 +1505,16 @@ var XverseAdapter = class extends SatsConnectAdapter {
 };
 
 // src/adapters/unisat.ts
-import { Buffer } from "buffer";
 import { AddressType as AddressType2, getAddressInfo } from "bitcoin-address-validation";
-function convertSignInputsToInputType(signInputs, allowedSignHash) {
+import { Buffer } from "buffer";
+function convertSignInputsToInputType(signInputs) {
   let result = [];
   for (let address in signInputs) {
     let indexes = signInputs[address];
     for (let index of indexes) {
       result.push({
         index,
-        address,
-        sighashTypes: allowedSignHash ? [allowedSignHash] : void 0
+        address
       });
     }
   }
@@ -1166,10 +1546,10 @@ var UnisatAdapter = class extends SatsConnectAdapter {
     };
     const response = [];
     if (purposes.includes("payment" /* Payment */)) {
-      response.push(paymentAddress);
+      response.push({ ...paymentAddress, walletType: "software" });
     }
     if (purposes.includes("ordinals" /* Ordinals */)) {
-      response.push(ordinalsAddress);
+      response.push({ ...ordinalsAddress, walletType: "software" });
     }
     return response;
   }
@@ -1182,14 +1562,16 @@ var UnisatAdapter = class extends SatsConnectAdapter {
       return {
         address,
         messageHash: "",
-        signature: response2
+        signature: response2,
+        protocol: "BIP322" /* BIP322 */
       };
     }
     const response = await window.unisat.signMessage(message, "ecdsa");
     return {
       address,
       messageHash: "",
-      signature: response
+      signature: response,
+      protocol: "ECDSA" /* ECDSA */
     };
   }
   async sendTransfer(params) {
@@ -1203,11 +1585,11 @@ var UnisatAdapter = class extends SatsConnectAdapter {
     };
   }
   async signPsbt(params) {
-    const { psbt, signInputs, allowedSignHash, broadcast } = params;
+    const { psbt, signInputs, broadcast } = params;
     const psbtHex = Buffer.from(psbt, "base64").toString("hex");
     const signedPsbt = await window.unisat.signPsbt(psbtHex, {
       autoFinalized: broadcast,
-      toSignInputs: convertSignInputsToInputType(signInputs, allowedSignHash)
+      toSignInputs: convertSignInputsToInputType(signInputs)
     });
     if (broadcast) {
       const txid = await window.unisat.pushPsbt(psbtHex);
@@ -1277,6 +1659,33 @@ var UnisatAdapter = class extends SatsConnectAdapter {
       };
     }
   };
+  addListener = (eventName, cb) => {
+    switch (eventName) {
+      case "accountChange": {
+        const handler = () => {
+          cb({ type: "accountChange" });
+        };
+        window.unisat.on("accountsChanged", handler);
+        return () => {
+          window.unisat.removeListener("accountsChanged", handler);
+        };
+      }
+      case "networkChange": {
+        const handler = () => {
+          cb({ type: "networkChange" });
+        };
+        window.unisat.on("networkChanged", handler);
+        return () => {
+          window.unisat.removeListener("networkChanged", handler);
+        };
+      }
+      default: {
+        console.error("Event not supported by the selected wallet");
+        return () => {
+        };
+      }
+    }
+  };
 };
 
 // src/adapters/BaseAdapter.ts
@@ -1536,7 +1945,6 @@ export {
   RpcErrorCode,
   RpcIdSchema,
   SatsConnectAdapter,
-  TransferRunesResultSchema,
   accountChangeEventName,
   accountChangeSchema,
   addListener,
@@ -1583,15 +1991,11 @@ export {
   getInfoResultSchema,
   getInscriptionsMethodName,
   getInscriptionsParamsSchema,
+  getInscriptionsRequestMessageSchema,
   getInscriptionsResultSchema,
-  getInscriptionsSchema,
   getProviderById,
   getProviderOrThrow,
   getProviders,
-  getRunesBalanceMethodName,
-  getRunesBalanceParamsSchema,
-  getRunesBalanceRequestMessageSchema,
-  getRunesBalanceResultSchema,
   getSupportedWallets,
   getWalletTypeMethodName,
   getWalletTypeParamsSchema,
@@ -1600,11 +2004,7 @@ export {
   isProviderInstalled,
   networkChangeEventName,
   networkChangeSchema,
-  permissionWithoutClientId,
-  registerClientMethodName,
-  registerClientParamsSchema,
-  registerClientRequestMessageSchema,
-  registerClientResultSchema,
+  permissionTemplate,
   removeDefaultProvider,
   renouncePermissionsMethodName,
   renouncePermissionsParamsSchema,
@@ -1619,11 +2019,31 @@ export {
   rpcRequestMessageSchema,
   rpcResponseMessageSchema,
   rpcSuccessResponseMessageSchema,
+  runesEtchMethodName,
+  runesEtchParamsSchema,
+  runesEtchRequestMessageSchema,
+  runesEtchResultSchema,
+  runesGetBalanceMethodName,
+  runesGetBalanceParamsSchema,
+  runesGetBalanceRequestMessageSchema,
+  runesGetBalanceResultSchema,
+  runesMintMethodName,
+  runesMintParamsSchema,
+  runesMintRequestMessageSchema,
+  runesMintResultSchema,
+  runesTransferMethodName,
+  runesTransferParamsSchema,
+  runesTransferRequestMessageSchema,
+  runesTransferResultSchema,
   sendBtcTransaction,
   sendInscriptionsMethodName,
   sendInscriptionsParamsSchema,
+  sendInscriptionsRequestMessageSchema,
   sendInscriptionsResultSchema,
-  sendInscriptionsSchema,
+  sendTransferMethodName,
+  sendTransferParamsSchema,
+  sendTransferRequestMessageSchema,
+  sendTransferResultSchema,
   setDefaultProvider,
   signMessage,
   signMessageMethodName,
@@ -1631,18 +2051,43 @@ export {
   signMessageRequestMessageSchema,
   signMessageResultSchema,
   signMultipleTransactions,
+  signPsbtMethodName,
+  signPsbtParamsSchema,
+  signPsbtRequestMessageSchema,
+  signPsbtResultSchema,
   signTransaction,
+  stxCallContractMethodName,
+  stxCallContractParamsSchema,
+  stxCallContractRequestMessageSchema,
+  stxCallContractResultSchema,
+  stxDeployContractMethodName,
+  stxDeployContractParamsSchema,
+  stxDeployContractRequestMessageSchema,
+  stxDeployContractResultSchema,
+  stxGetAccountsMethodName,
+  stxGetAccountsParamsSchema,
+  stxGetAccountsRequestMessageSchema,
+  stxGetAccountsResultSchema,
   stxGetAddressesMethodName,
   stxGetAddressesParamsSchema,
   stxGetAddressesRequestMessageSchema,
   stxGetAddressesResultSchema,
+  stxSignMessageMethodName,
+  stxSignMessageParamsSchema,
+  stxSignMessageRequestMessageSchema,
+  stxSignMessageResultSchema,
+  stxSignStructuredMessageMethodName,
+  stxSignStructuredMessageParamsSchema,
+  stxSignStructuredMessageRequestMessageSchema,
+  stxSignStructuredMessageResultSchema,
   stxSignTransactionMethodName,
   stxSignTransactionParamsSchema,
   stxSignTransactionRequestMessageSchema,
   stxSignTransactionResultSchema,
-  transferRunesMethodName,
-  transferRunesParamsSchema,
-  transferRunesRequestSchema,
+  stxTransferStxMethodName,
+  stxTransferStxParamsSchema,
+  stxTransferStxRequestMessageSchema,
+  stxTransferStxResultSchema,
   walletEventSchema,
   walletTypeSchema,
   walletTypes