@sats-connect/core 0.4.0-069d601 → 0.4.0-20feed3

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,11 +47,9 @@ 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 ambientProviders = getProviders();
+  const { xverse, ...defaultProviders } = DefaultAdaptersInfo;
+  const allProviders = [...ambientProviders, ...Object.values(defaultProviders)];
   const wallets = allProviders.map((provider) => {
     {
       return {
@@ -118,13 +113,127 @@ var rpcResponseMessageSchema = v2.union([
 ]);
 
 // src/request/index.ts
-import * as v10 from "valibot";
+import * as v17 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 code of the Clarity contract.
+   */
+  codeBody: v4.string(),
+  /**
+   * The version of the Clarity contract.
+   */
+  version: 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 +249,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 +273,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,248 +544,364 @@ 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 permissionTemplate = v14.variant("type", [
+  v14.object({
+    ...v14.omit(permissions.resources.account.accountPermissionSchema, ["clientId", "actions"]).entries,
+    actions: v14.partial(permissions.resources.account.accountActionsSchema)
+  }),
+  v14.object({
+    ...v14.omit(permissions.resources.wallet.walletPermissionSchema, ["clientId"]).entries,
+    actions: v14.partial(permissions.resources.wallet.walletActionsSchema)
+  })
+]);
 var requestPermissionsMethodName = "wallet_requestPermissions";
-var requestPermissionsParamsSchema = v7.undefined();
-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.undefined();
-var renouncePermissionsResultSchema = v7.literal(true);
-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 = v14.nullish(v14.null());
+var disconnectResultSchema = v14.nullish(v14.null());
+var disconnectRequestMessageSchema = v14.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v14.object({
+    method: v14.literal(disconnectMethodName),
+    params: disconnectParamsSchema,
+    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),
-    id: v7.string()
+  ...v14.object({
+    method: v14.literal(getWalletTypeMethodName),
+    params: getWalletTypeParamsSchema,
+    id: v14.string()
   }).entries
 });
 var getCurrentPermissionsMethodName = "wallet_getCurrentPermissions";
-var getCurrentPermissionsParamsSchema = v7.nullish(v7.null());
-var getCurrentPermissionsResultSchema = v7.array(permissions.schemas.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),
-    id: v7.string()
+  ...v14.object({
+    method: v14.literal(getCurrentPermissionsMethodName),
+    params: getCurrentPermissionsParamsSchema,
+    id: v14.string()
+  }).entries
+});
+var getAccountMethodName = "wallet_getAccount";
+var getAccountParamsSchema = v14.nullish(v14.null());
+var getAccountResultSchema = v14.object({
+  id: permissions.utils.account.accountIdSchema,
+  addresses: v14.array(addressSchema),
+  walletType: walletTypeSchema
+});
+var getAccountRequestMessageSchema = v14.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v14.object({
+    method: v14.literal(getAccountMethodName),
+    params: getAccountParamsSchema,
+    id: v14.string()
+  }).entries
+});
+var connectMethodName = "wallet_connect";
+var connectParamsSchema = v14.nullish(
+  v14.object({
+    permissions: v14.optional(v14.array(permissionTemplate))
+  })
+);
+var connectResultSchema = getAccountResultSchema;
+var connectRequestMessageSchema = v14.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v14.object({
+    method: v14.literal(connectMethodName),
+    params: connectParamsSchema,
+    id: v14.string()
   }).entries
 });
 
 // src/request/types/runesMethods.ts
-import * as v8 from "valibot";
+import * as v15 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())
+var getRunesBalanceParamsSchema = v15.nullish(v15.null());
+var getRunesBalanceResultSchema = v15.object({
+  balances: v15.array(
+    v15.object({
+      runeName: v15.string(),
+      amount: v15.string(),
+      divisibility: v15.number(),
+      symbol: v15.string(),
+      inscriptionId: v15.nullish(v15.string())
     })
   )
 });
-var getRunesBalanceRequestMessageSchema = v8.object({
+var getRunesBalanceRequestMessageSchema = v15.object({
   ...rpcRequestMessageSchema.entries,
-  ...v8.object({
-    method: v8.literal(getRunesBalanceMethodName),
+  ...v15.object({
+    method: v15.literal(getRunesBalanceMethodName),
     params: getRunesBalanceParamsSchema,
-    id: v8.string()
+    id: v15.string()
   }).entries
 });
 var transferRunesMethodName = "runes_transfer";
-var transferRunesParamsSchema = v8.object({
-  recipients: v8.array(
-    v8.object({
-      runeName: v8.string(),
-      amount: v8.string(),
-      address: v8.string()
+var transferRunesParamsSchema = v15.object({
+  recipients: v15.array(
+    v15.object({
+      runeName: v15.string(),
+      amount: v15.string(),
+      address: v15.string()
     })
   )
 });
-var transferRunesRequestSchema = v8.object({
+var transferRunesRequestSchema = v15.object({
   ...rpcRequestMessageSchema.entries,
-  ...v8.object({
-    method: v8.literal(transferRunesMethodName),
+  ...v15.object({
+    method: v15.literal(transferRunesMethodName),
     params: transferRunesParamsSchema,
-    id: v8.string()
+    id: v15.string()
   }).entries
 });
-var TransferRunesResultSchema = v8.object({
-  txid: v8.string()
+var TransferRunesResultSchema = v15.object({
+  txid: v15.string()
 });
 
 // src/request/types/ordinalsMethods.ts
-import * as v9 from "valibot";
+import * as v16 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 = v16.object({
+  offset: v16.number(),
+  limit: v16.number()
+});
+var getInscriptionsResultSchema = v16.object({
+  total: v16.number(),
+  limit: v16.number(),
+  offset: v16.number(),
+  inscriptions: v16.array(
+    v16.object({
+      inscriptionId: v16.string(),
+      inscriptionNumber: v16.string(),
+      address: v16.string(),
+      collectionName: v16.optional(v16.string()),
+      postage: v16.string(),
+      contentLength: v16.string(),
+      contentType: v16.string(),
+      timestamp: v16.number(),
+      offset: v16.number(),
+      genesisTransaction: v16.string(),
+      output: v16.string()
     })
   )
 });
-var getInscriptionsSchema = v9.object({
+var getInscriptionsSchema = v16.object({
   ...rpcRequestMessageSchema.entries,
-  ...v9.object({
-    method: v9.literal(getInscriptionsMethodName),
+  ...v16.object({
+    method: v16.literal(getInscriptionsMethodName),
     params: getInscriptionsParamsSchema,
-    id: v9.string()
+    id: v16.string()
   }).entries
 });
 var sendInscriptionsMethodName = "ord_sendInscriptions";
-var sendInscriptionsParamsSchema = v9.object({
-  transfers: v9.array(
-    v9.object({
-      address: v9.string(),
-      inscriptionId: v9.string()
+var sendInscriptionsParamsSchema = v16.object({
+  transfers: v16.array(
+    v16.object({
+      address: v16.string(),
+      inscriptionId: v16.string()
     })
   )
 });
-var sendInscriptionsResultSchema = v9.object({
-  txid: v9.string()
+var sendInscriptionsResultSchema = v16.object({
+  txid: v16.string()
 });
-var sendInscriptionsSchema = v9.object({
+var sendInscriptionsSchema = v16.object({
   ...rpcRequestMessageSchema.entries,
-  ...v9.object({
-    method: v9.literal(sendInscriptionsMethodName),
+  ...v16.object({
+    method: v16.literal(sendInscriptionsMethodName),
     params: sendInscriptionsParamsSchema,
-    id: v9.string()
+    id: v16.string()
   }).entries
 });
 
@@ -543,13 +918,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 (v17.is(rpcErrorResponseMessageSchema, response)) {
     return {
       status: "error",
       error: response.error
     };
   }
-  if (v10.is(rpcSuccessResponseMessageSchema, response)) {
+  if (v17.is(rpcSuccessResponseMessageSchema, response)) {
     return {
       status: "success",
       result: response.result
@@ -1060,17 +1435,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
       });
     }
   }
@@ -1102,10 +1476,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;
   }
@@ -1118,14 +1492,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) {
@@ -1139,11 +1515,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);
@@ -1213,6 +1589,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
@@ -1477,11 +1880,23 @@ export {
   accountChangeSchema,
   addListener,
   addressSchema,
+  connectMethodName,
+  connectParamsSchema,
+  connectRequestMessageSchema,
+  connectResultSchema,
   createInscription,
   createRepeatInscriptions,
   defaultAdapters,
   disconnectEventName,
+  disconnectMethodName,
+  disconnectParamsSchema,
+  disconnectRequestMessageSchema,
+  disconnectResultSchema,
   disconnectSchema,
+  getAccountMethodName,
+  getAccountParamsSchema,
+  getAccountRequestMessageSchema,
+  getAccountResultSchema,
   getAccountsMethodName,
   getAccountsParamsSchema,
   getAccountsRequestMessageSchema,
@@ -1524,6 +1939,7 @@ export {
   isProviderInstalled,
   networkChangeEventName,
   networkChangeSchema,
+  permissionTemplate,
   removeDefaultProvider,
   renouncePermissionsMethodName,
   renouncePermissionsParamsSchema,
@@ -1543,6 +1959,10 @@ export {
   sendInscriptionsParamsSchema,
   sendInscriptionsResultSchema,
   sendInscriptionsSchema,
+  sendTransferMethodName,
+  sendTransferParamsSchema,
+  sendTransferRequestMessageSchema,
+  sendTransferResultSchema,
   setDefaultProvider,
   signMessage,
   signMessageMethodName,
@@ -1550,15 +1970,41 @@ export {
   signMessageRequestMessageSchema,
   signMessageResultSchema,
   signMultipleTransactions,
+  signPsbtMethodName,
+  signPsbtParamsSchema,
+  signPsbtRequestMessageSchema,
+  signPsbtResultSchema,
   signTransaction,
+  stxCallContractMethodName,
+  stxCallContractParamsSchema,
+  stxCallContractRequestMessageSchema,
+  stxCallContractResultSchema,
+  stxDeployContractRequestMessageSchema,
+  stxDeployContractResultSchema,
+  stxGetAccountsMethodName,
+  stxGetAccountsParamsSchema,
+  stxGetAccountsRequestMessageSchema,
+  stxGetAccountsResultSchema,
   stxGetAddressesMethodName,
   stxGetAddressesParamsSchema,
   stxGetAddressesRequestMessageSchema,
   stxGetAddressesResultSchema,
+  stxSignMessageMethodName,
+  stxSignMessageParamsSchema,
+  stxSignMessageRequestMessageSchema,
+  stxSignMessageResultSchema,
+  stxSignStructuredMessageMethodName,
+  stxSignStructuredMessageParamsSchema,
+  stxSignStructuredMessageRequestMessageSchema,
+  stxSignStructuredMessageResultSchema,
   stxSignTransactionMethodName,
   stxSignTransactionParamsSchema,
   stxSignTransactionRequestMessageSchema,
   stxSignTransactionResultSchema,
+  stxTransferStxMethodName,
+  stxTransferStxParamsSchema,
+  stxTransferStxRequestMessageSchema,
+  stxTransferStxResultSchema,
   transferRunesMethodName,
   transferRunesParamsSchema,
   transferRunesRequestSchema,