@sats-connect/core 0.8.1-db15ee7 → 0.8.1-e76eede

package/dist/index.mjs

@@ -1,3 +1,6 @@
+// src/request/index.ts
+import * as v25 from "valibot";
+
 // src/provider/types.ts
 import * as v4 from "valibot";
 
@@ -191,8 +194,22 @@ function getSupportedWallets() {
   return wallets;
 }
 
-// src/request/index.ts
-import * as v26 from "valibot";
+// src/request/sanitizeRequest.ts
+var sanitizeRequest = (method, params, providerVersion) => {
+  if (method === "wallet_connect" && providerVersion < 1) {
+    const typedParams = params;
+    if (!typedParams) {
+      return { method, params };
+    }
+    const { addresses, ...rest } = typedParams;
+    const sanitizedAddresses = addresses?.filter(
+      (addr) => addr !== "spark" /* Spark */ && addr !== "starknet" /* Starknet */
+    );
+    const overrideParams = { ...rest, addresses: sanitizedAddresses };
+    return { method, params: overrideParams };
+  }
+  return { method, params };
+};
 
 // src/request/types/btcMethods.ts
 import * as v6 from "valibot";
@@ -864,108 +881,87 @@ var sparkGetBalanceRequestMessageSchema = v13.object({
   }).entries
 });
 
-// src/request/types/sparkMethods/signMessage.ts
-import * as v14 from "valibot";
-var sparkSignMessageMethodName = "spark_signMessage";
-var sparkSignMessageParamsSchema = v14.object({
-  message: v14.string()
-});
-var sparkSignMessageResultSchema = v14.object({
-  /**
-   * The signature for the message in hex format
-   */
-  signature: v14.string()
-});
-var sparkSignMessageRequestMessageSchema = v14.object({
-  ...rpcRequestMessageSchema.entries,
-  ...v14.object({
-    method: v14.literal(sparkSignMessageMethodName),
-    params: sparkSignMessageParamsSchema,
-    id: v14.string()
-  }).entries
-});
-
 // src/request/types/sparkMethods/transfer.ts
-import * as v15 from "valibot";
+import * as v14 from "valibot";
 var sparkTransferMethodName = "spark_transfer";
-var sparkTransferParamsSchema = v15.object({
+var sparkTransferParamsSchema = v14.object({
   /**
    * Amount of SATS to transfer as a string or number.
    */
-  amountSats: v15.union([v15.number(), v15.string()]),
+  amountSats: v14.union([v14.number(), v14.string()]),
   /**
    * The recipient's spark address.
    */
-  receiverSparkAddress: v15.string()
+  receiverSparkAddress: v14.string()
 });
-var sparkTransferResultSchema = v15.object({
+var sparkTransferResultSchema = v14.object({
   /**
    * The ID of the transaction.
    */
-  id: v15.string()
+  id: v14.string()
 });
-var sparkTransferRequestMessageSchema = v15.object({
+var sparkTransferRequestMessageSchema = v14.object({
   ...rpcRequestMessageSchema.entries,
-  ...v15.object({
-    method: v15.literal(sparkTransferMethodName),
+  ...v14.object({
+    method: v14.literal(sparkTransferMethodName),
     params: sparkTransferParamsSchema,
-    id: v15.string()
+    id: v14.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/transferToken.ts
-import * as v16 from "valibot";
+import * as v15 from "valibot";
 var sparkTransferTokenMethodName = "spark_transferToken";
-var sparkTransferTokenParamsSchema = v16.object({
+var sparkTransferTokenParamsSchema = v15.object({
   /**
    * Amount of units of the token to transfer as a string or number.
    */
-  tokenAmount: v16.union([v16.number(), v16.string()]),
+  tokenAmount: v15.union([v15.number(), v15.string()]),
   /**
    * The Bech32m token identifier.
    */
-  tokenIdentifier: v16.string(),
+  tokenIdentifier: v15.string(),
   /**
    * The recipient's spark address.
    */
-  receiverSparkAddress: v16.string()
+  receiverSparkAddress: v15.string()
 });
-var sparkTransferTokenResultSchema = v16.object({
+var sparkTransferTokenResultSchema = v15.object({
   /**
    * The ID of the transaction.
    */
-  id: v16.string()
+  id: v15.string()
 });
-var sparkTransferTokenRequestMessageSchema = v16.object({
+var sparkTransferTokenRequestMessageSchema = v15.object({
   ...rpcRequestMessageSchema.entries,
-  ...v16.object({
-    method: v16.literal(sparkTransferTokenMethodName),
+  ...v15.object({
+    method: v15.literal(sparkTransferTokenMethodName),
     params: sparkTransferTokenParamsSchema,
-    id: v16.string()
+    id: v15.string()
   }).entries
 });
 
 // src/request/types/stxMethods/callContract.ts
-import * as v17 from "valibot";
+import * as v16 from "valibot";
 var stxCallContractMethodName = "stx_callContract";
-var stxCallContractParamsSchema = v17.object({
+var stxCallContractParamsSchema = v16.object({
   /**
    * The contract principal.
    *
    * E.g. `"SPKE...GD5C.my-contract"`
    */
-  contract: v17.string(),
+  contract: v16.string(),
   /**
    * The name of the function to call.
    *
    * Note: spec changes ongoing,
    * https://github.com/stacksgov/sips/pull/166#pullrequestreview-1914236999
    */
-  functionName: v17.string(),
+  functionName: v16.string(),
   /**
    * @deprecated in favor of `functionArgs` for @stacks/connect compatibility
    */
-  arguments: v17.optional(v17.array(v17.string())),
+  arguments: v16.optional(v16.array(v16.string())),
   /**
    * The function's arguments. The arguments are expected to be hex-encoded
    * strings of Clarity values.
@@ -980,274 +976,274 @@ var stxCallContractParamsSchema = v17.object({
    * const hexArgs = functionArgs.map(cvToHex);
    * ```
    */
-  functionArgs: v17.optional(v17.array(v17.string())),
+  functionArgs: v16.optional(v16.array(v16.string())),
   /**
    * The post conditions to apply to the contract call.
    */
-  postConditions: v17.optional(v17.array(v17.string())),
+  postConditions: v16.optional(v16.array(v16.string())),
   /**
    * The mode to apply to the post conditions.
    */
-  postConditionMode: v17.optional(v17.union([v17.literal("allow"), v17.literal("deny")]))
+  postConditionMode: v16.optional(v16.union([v16.literal("allow"), v16.literal("deny")]))
 });
-var stxCallContractResultSchema = v17.object({
+var stxCallContractResultSchema = v16.object({
   /**
    * The ID of the transaction.
    */
-  txid: v17.string(),
+  txid: v16.string(),
   /**
    * A Stacks transaction as a hex-encoded string.
    */
-  transaction: v17.string()
+  transaction: v16.string()
 });
-var stxCallContractRequestMessageSchema = v17.object({
+var stxCallContractRequestMessageSchema = v16.object({
   ...rpcRequestMessageSchema.entries,
-  ...v17.object({
-    method: v17.literal(stxCallContractMethodName),
+  ...v16.object({
+    method: v16.literal(stxCallContractMethodName),
     params: stxCallContractParamsSchema,
-    id: v17.string()
+    id: v16.string()
   }).entries
 });
 
 // src/request/types/stxMethods/deployContract.ts
-import * as v18 from "valibot";
+import * as v17 from "valibot";
 var stxDeployContractMethodName = "stx_deployContract";
-var stxDeployContractParamsSchema = v18.object({
+var stxDeployContractParamsSchema = v17.object({
   /**
    * Name of the contract.
    */
-  name: v18.string(),
+  name: v17.string(),
   /**
    * The source code of the Clarity contract.
    */
-  clarityCode: v18.string(),
+  clarityCode: v17.string(),
   /**
    * The version of the Clarity contract.
    */
-  clarityVersion: v18.optional(v18.number()),
+  clarityVersion: v17.optional(v17.number()),
   /**
    * The post conditions to apply to the contract call.
    */
-  postConditions: v18.optional(v18.array(v18.string())),
+  postConditions: v17.optional(v17.array(v17.string())),
   /**
    * The mode to apply to the post conditions.
    */
-  postConditionMode: v18.optional(v18.union([v18.literal("allow"), v18.literal("deny")]))
+  postConditionMode: v17.optional(v17.union([v17.literal("allow"), v17.literal("deny")]))
 });
-var stxDeployContractResultSchema = v18.object({
+var stxDeployContractResultSchema = v17.object({
   /**
    * The ID of the transaction.
    */
-  txid: v18.string(),
+  txid: v17.string(),
   /**
    * A Stacks transaction as a hex-encoded string.
    */
-  transaction: v18.string()
+  transaction: v17.string()
 });
-var stxDeployContractRequestMessageSchema = v18.object({
+var stxDeployContractRequestMessageSchema = v17.object({
   ...rpcRequestMessageSchema.entries,
-  ...v18.object({
-    method: v18.literal(stxDeployContractMethodName),
+  ...v17.object({
+    method: v17.literal(stxDeployContractMethodName),
     params: stxDeployContractParamsSchema,
-    id: v18.string()
+    id: v17.string()
   }).entries
 });
 
 // src/request/types/stxMethods/getAccounts.ts
-import * as v19 from "valibot";
+import * as v18 from "valibot";
 var stxGetAccountsMethodName = "stx_getAccounts";
-var stxGetAccountsParamsSchema = v19.nullish(v19.null());
-var stxGetAccountsResultSchema = v19.object({
+var stxGetAccountsParamsSchema = v18.nullish(v18.null());
+var stxGetAccountsResultSchema = v18.object({
   /**
    * The addresses generated for the given purposes.
    */
-  addresses: v19.array(
-    v19.object({
-      address: v19.string(),
-      publicKey: v19.string(),
-      gaiaHubUrl: v19.string(),
-      gaiaAppKey: v19.string()
+  addresses: v18.array(
+    v18.object({
+      address: v18.string(),
+      publicKey: v18.string(),
+      gaiaHubUrl: v18.string(),
+      gaiaAppKey: v18.string()
     })
   ),
   network: getNetworkResultSchema
 });
-var stxGetAccountsRequestMessageSchema = v19.object({
+var stxGetAccountsRequestMessageSchema = v18.object({
   ...rpcRequestMessageSchema.entries,
-  ...v19.object({
-    method: v19.literal(stxGetAccountsMethodName),
+  ...v18.object({
+    method: v18.literal(stxGetAccountsMethodName),
     params: stxGetAccountsParamsSchema,
-    id: v19.string()
+    id: v18.string()
   }).entries
 });
 
 // src/request/types/stxMethods/getAddresses.ts
-import * as v20 from "valibot";
+import * as v19 from "valibot";
 var stxGetAddressesMethodName = "stx_getAddresses";
-var stxGetAddressesParamsSchema = v20.nullish(
-  v20.object({
+var stxGetAddressesParamsSchema = v19.nullish(
+  v19.object({
     /**
      * A message to be displayed to the user in the request prompt.
      */
-    message: v20.optional(v20.string())
+    message: v19.optional(v19.string())
   })
 );
-var stxGetAddressesResultSchema = v20.object({
+var stxGetAddressesResultSchema = v19.object({
   /**
    * The addresses generated for the given purposes.
    */
-  addresses: v20.array(addressSchema),
+  addresses: v19.array(addressSchema),
   network: getNetworkResultSchema
 });
-var stxGetAddressesRequestMessageSchema = v20.object({
+var stxGetAddressesRequestMessageSchema = v19.object({
   ...rpcRequestMessageSchema.entries,
-  ...v20.object({
-    method: v20.literal(stxGetAddressesMethodName),
+  ...v19.object({
+    method: v19.literal(stxGetAddressesMethodName),
     params: stxGetAddressesParamsSchema,
-    id: v20.string()
+    id: v19.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signMessage.ts
-import * as v21 from "valibot";
+import * as v20 from "valibot";
 var stxSignMessageMethodName = "stx_signMessage";
-var stxSignMessageParamsSchema = v21.object({
+var stxSignMessageParamsSchema = v20.object({
   /**
    * The message to sign.
    */
-  message: v21.string()
+  message: v20.string()
 });
-var stxSignMessageResultSchema = v21.object({
+var stxSignMessageResultSchema = v20.object({
   /**
    * The signature of the message.
    */
-  signature: v21.string(),
+  signature: v20.string(),
   /**
    * The public key used to sign the message.
    */
-  publicKey: v21.string()
+  publicKey: v20.string()
 });
-var stxSignMessageRequestMessageSchema = v21.object({
+var stxSignMessageRequestMessageSchema = v20.object({
   ...rpcRequestMessageSchema.entries,
-  ...v21.object({
-    method: v21.literal(stxSignMessageMethodName),
+  ...v20.object({
+    method: v20.literal(stxSignMessageMethodName),
     params: stxSignMessageParamsSchema,
-    id: v21.string()
+    id: v20.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signStructuredMessage.ts
-import * as v22 from "valibot";
+import * as v21 from "valibot";
 var stxSignStructuredMessageMethodName = "stx_signStructuredMessage";
-var stxSignStructuredMessageParamsSchema = v22.object({
+var stxSignStructuredMessageParamsSchema = v21.object({
   /**
    * The domain to be signed.
    */
-  domain: v22.string(),
+  domain: v21.string(),
   /**
    * Message payload to be signed.
    */
-  message: v22.string(),
+  message: v21.string(),
   /**
    * The public key to sign the message with.
    */
-  publicKey: v22.optional(v22.string())
+  publicKey: v21.optional(v21.string())
 });
-var stxSignStructuredMessageResultSchema = v22.object({
+var stxSignStructuredMessageResultSchema = v21.object({
   /**
    * Signature of the message.
    */
-  signature: v22.string(),
+  signature: v21.string(),
   /**
    * Public key as hex-encoded string.
    */
-  publicKey: v22.string()
+  publicKey: v21.string()
 });
-var stxSignStructuredMessageRequestMessageSchema = v22.object({
+var stxSignStructuredMessageRequestMessageSchema = v21.object({
   ...rpcRequestMessageSchema.entries,
-  ...v22.object({
-    method: v22.literal(stxSignStructuredMessageMethodName),
+  ...v21.object({
+    method: v21.literal(stxSignStructuredMessageMethodName),
     params: stxSignStructuredMessageParamsSchema,
-    id: v22.string()
+    id: v21.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signTransaction.ts
-import * as v23 from "valibot";
+import * as v22 from "valibot";
 var stxSignTransactionMethodName = "stx_signTransaction";
-var stxSignTransactionParamsSchema = v23.object({
+var stxSignTransactionParamsSchema = v22.object({
   /**
    * The transaction to sign as a hex-encoded string.
    */
-  transaction: v23.string(),
+  transaction: v22.string(),
   /**
    * The public key to sign the transaction with. The wallet may use any key
    * when not provided.
    */
-  pubkey: v23.optional(v23.string()),
+  pubkey: v22.optional(v22.string()),
   /**
    * Whether to broadcast the transaction after signing. Defaults to `true`.
    */
-  broadcast: v23.optional(v23.boolean())
+  broadcast: v22.optional(v22.boolean())
 });
-var stxSignTransactionResultSchema = v23.object({
+var stxSignTransactionResultSchema = v22.object({
   /**
    * The signed transaction as a hex-encoded string.
    */
-  transaction: v23.string()
+  transaction: v22.string()
 });
-var stxSignTransactionRequestMessageSchema = v23.object({
+var stxSignTransactionRequestMessageSchema = v22.object({
   ...rpcRequestMessageSchema.entries,
-  ...v23.object({
-    method: v23.literal(stxSignTransactionMethodName),
+  ...v22.object({
+    method: v22.literal(stxSignTransactionMethodName),
     params: stxSignTransactionParamsSchema,
-    id: v23.string()
+    id: v22.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signTransactions.ts
-import * as v24 from "valibot";
+import * as v23 from "valibot";
 var stxSignTransactionsMethodName = "stx_signTransactions";
-var stxSignTransactionsParamsSchema = v24.object({
+var stxSignTransactionsParamsSchema = v23.object({
   /**
    * The transactions to sign as hex-encoded strings.
    */
-  transactions: v24.pipe(
-    v24.array(
-      v24.pipe(
-        v24.string(),
-        v24.check((hex) => {
+  transactions: v23.pipe(
+    v23.array(
+      v23.pipe(
+        v23.string(),
+        v23.check((hex) => {
           return true;
         }, "Invalid hex-encoded Stacks transaction.")
       )
     ),
-    v24.minLength(1)
+    v23.minLength(1)
   ),
   /**
    * Whether the signed transactions should be broadcast after signing. Defaults
    * to `true`.
    */
-  broadcast: v24.optional(v24.boolean())
+  broadcast: v23.optional(v23.boolean())
 });
-var stxSignTransactionsResultSchema = v24.object({
+var stxSignTransactionsResultSchema = v23.object({
   /**
    * The signed transactions as hex-encoded strings, in the same order as in the
    * sign request.
    */
-  transactions: v24.array(v24.string())
+  transactions: v23.array(v23.string())
 });
-var stxSignTransactionsRequestMessageSchema = v24.object({
+var stxSignTransactionsRequestMessageSchema = v23.object({
   ...rpcRequestMessageSchema.entries,
-  ...v24.object({
-    method: v24.literal(stxSignTransactionsMethodName),
+  ...v23.object({
+    method: v23.literal(stxSignTransactionsMethodName),
     params: stxSignTransactionsParamsSchema,
-    id: v24.string()
+    id: v23.string()
   }).entries
 });
 
 // src/request/types/stxMethods/transferStx.ts
-import * as v25 from "valibot";
+import * as v24 from "valibot";
 var stxTransferStxMethodName = "stx_transferStx";
-var stxTransferStxParamsSchema = v25.object({
+var stxTransferStxParamsSchema = v24.object({
   /**
    * Amount of STX tokens to transfer in microstacks as a string. Anything
    * parseable by `BigInt` is acceptable.
@@ -1260,23 +1256,23 @@ var stxTransferStxParamsSchema = v25.object({
    * const amount3 = '1234';
    * ```
    */
-  amount: v25.union([v25.number(), v25.string()]),
+  amount: v24.union([v24.number(), v24.string()]),
   /**
    * The recipient's principal.
    */
-  recipient: v25.string(),
+  recipient: v24.string(),
   /**
    * A string representing the memo.
    */
-  memo: v25.optional(v25.string()),
+  memo: v24.optional(v24.string()),
   /**
    * Version of parameter format.
    */
-  version: v25.optional(v25.string()),
+  version: v24.optional(v24.string()),
   /**
    * The mode of the post conditions.
    */
-  postConditionMode: v25.optional(v25.number()),
+  postConditionMode: v24.optional(v24.number()),
   /**
    * A hex-encoded string representing the post conditions.
    *
@@ -1289,29 +1285,29 @@ var stxTransferStxParamsSchema = v25.object({
    * const hexPostCondition = serializePostCondition(postCondition).toString('hex');
    * ```
    */
-  postConditions: v25.optional(v25.array(v25.string())),
+  postConditions: v24.optional(v24.array(v24.string())),
   /**
    * The public key to sign the transaction with. The wallet may use any key
    * when not provided.
    */
-  pubkey: v25.optional(v25.string())
+  pubkey: v24.optional(v24.string())
 });
-var stxTransferStxResultSchema = v25.object({
+var stxTransferStxResultSchema = v24.object({
   /**
    * The ID of the transaction.
    */
-  txid: v25.string(),
+  txid: v24.string(),
   /**
    * A Stacks transaction as a hex-encoded string.
    */
-  transaction: v25.string()
+  transaction: v24.string()
 });
-var stxTransferStxRequestMessageSchema = v25.object({
+var stxTransferStxRequestMessageSchema = v24.object({
   ...rpcRequestMessageSchema.entries,
-  ...v25.object({
-    method: v25.literal(stxTransferStxMethodName),
+  ...v24.object({
+    method: v24.literal(stxTransferStxMethodName),
     params: stxTransferStxParamsSchema,
-    id: v25.string()
+    id: v24.string()
   }).entries
 });
 
@@ -1327,14 +1323,23 @@ var request = async (method, params, providerId) => {
   if (!method) {
     throw new Error("A wallet method is required");
   }
-  const response = await provider.request(method, params);
-  if (v26.is(rpcErrorResponseMessageSchema, response)) {
+  const providerVersion = provider.version ?? 0;
+  const {
+    method: sanitizedMethod,
+    params: sanitizedParams,
+    overrideResponse
+  } = sanitizeRequest(method, params, providerVersion);
+  if (overrideResponse) {
+    return overrideResponse;
+  }
+  const response = await provider.request(sanitizedMethod, sanitizedParams);
+  if (v25.is(rpcErrorResponseMessageSchema, response)) {
     return {
       status: "error",
       error: response.error
     };
   }
-  if (v26.is(rpcSuccessResponseMessageSchema, response)) {
+  if (v25.is(rpcSuccessResponseMessageSchema, response)) {
     return {
       status: "success",
       result: response.result
@@ -2496,10 +2501,6 @@ export {
   sparkGetBalanceParamsSchema,
   sparkGetBalanceRequestMessageSchema,
   sparkGetBalanceResultSchema,
-  sparkSignMessageMethodName,
-  sparkSignMessageParamsSchema,
-  sparkSignMessageRequestMessageSchema,
-  sparkSignMessageResultSchema,
   sparkTransferMethodName,
   sparkTransferParamsSchema,
   sparkTransferRequestMessageSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sats-connect/core",
-  "version": "0.8.1-db15ee7",
+  "version": "0.8.1-e76eede",
   "main": "dist/index.mjs",
   "module": "dist/index.mjs",
   "types": "dist/index.d.mts",