@sats-connect/core 0.9.0 → 0.10.0-25de943

package/dist/index.mjs

@@ -1,5 +1,5 @@
 // src/request/index.ts
-import * as v36 from "valibot";
+import * as v37 from "valibot";
 
 // src/provider/types.ts
 import * as v4 from "valibot";
@@ -1113,87 +1113,115 @@ var sparkGetBalanceRequestMessageSchema = v24.object({
   }).entries
 });
 
-// src/request/types/sparkMethods/transfer.ts
+// src/request/types/sparkMethods/signMessage.ts
 import * as v25 from "valibot";
+var sparkSignMessageMethodName = "spark_signMessage";
+var sparkSignMessageParamsSchema = v25.object({
+  /**
+   * The message to sign. The message should only consist of valid UTF-8 characters.
+   */
+  message: v25.string()
+});
+var sparkSignMessageResultSchema = v25.object({
+  /**
+   * The signature, encoded in base64, of the message hash.
+   *
+   * Note: When signing, the message is decoded into a byte array,
+   * and the resulting byte array is hashed with SHA256 before signing
+   * with the private key.
+   */
+  signature: v25.string()
+});
+var sparkSignMessageRequestMessageSchema = v25.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v25.object({
+    method: v25.literal(sparkSignMessageMethodName),
+    params: sparkSignMessageParamsSchema,
+    id: v25.string()
+  }).entries
+});
+
+// src/request/types/sparkMethods/transfer.ts
+import * as v26 from "valibot";
 var sparkTransferMethodName = "spark_transfer";
-var sparkTransferParamsSchema = v25.object({
+var sparkTransferParamsSchema = v26.object({
   /**
    * Amount of SATS to transfer as a string or number.
    */
-  amountSats: v25.union([v25.number(), v25.string()]),
+  amountSats: v26.union([v26.number(), v26.string()]),
   /**
    * The recipient's spark address.
    */
-  receiverSparkAddress: v25.string()
+  receiverSparkAddress: v26.string()
 });
-var sparkTransferResultSchema = v25.object({
+var sparkTransferResultSchema = v26.object({
   /**
    * The ID of the transaction.
    */
-  id: v25.string()
+  id: v26.string()
 });
-var sparkTransferRequestMessageSchema = v25.object({
+var sparkTransferRequestMessageSchema = v26.object({
   ...rpcRequestMessageSchema.entries,
-  ...v25.object({
-    method: v25.literal(sparkTransferMethodName),
+  ...v26.object({
+    method: v26.literal(sparkTransferMethodName),
     params: sparkTransferParamsSchema,
-    id: v25.string()
+    id: v26.string()
   }).entries
 });
 
 // src/request/types/sparkMethods/transferToken.ts
-import * as v26 from "valibot";
+import * as v27 from "valibot";
 var sparkTransferTokenMethodName = "spark_transferToken";
-var sparkTransferTokenParamsSchema = v26.object({
+var sparkTransferTokenParamsSchema = v27.object({
   /**
    * Amount of units of the token to transfer as a string or number.
    */
-  tokenAmount: v26.union([v26.number(), v26.string()]),
+  tokenAmount: v27.union([v27.number(), v27.string()]),
   /**
    * The Bech32m token identifier.
    */
-  tokenIdentifier: v26.string(),
+  tokenIdentifier: v27.string(),
   /**
    * The recipient's spark address.
    */
-  receiverSparkAddress: v26.string()
+  receiverSparkAddress: v27.string()
 });
-var sparkTransferTokenResultSchema = v26.object({
+var sparkTransferTokenResultSchema = v27.object({
   /**
    * The ID of the transaction.
    */
-  id: v26.string()
+  id: v27.string()
 });
-var sparkTransferTokenRequestMessageSchema = v26.object({
+var sparkTransferTokenRequestMessageSchema = v27.object({
   ...rpcRequestMessageSchema.entries,
-  ...v26.object({
-    method: v26.literal(sparkTransferTokenMethodName),
+  ...v27.object({
+    method: v27.literal(sparkTransferTokenMethodName),
     params: sparkTransferTokenParamsSchema,
-    id: v26.string()
+    id: v27.string()
   }).entries
 });
 
 // src/request/types/stxMethods/callContract.ts
-import * as v27 from "valibot";
+import * as v28 from "valibot";
 var stxCallContractMethodName = "stx_callContract";
-var stxCallContractParamsSchema = v27.object({
+var stxCallContractParamsSchema = v28.object({
   /**
    * The contract principal.
    *
    * E.g. `"SPKE...GD5C.my-contract"`
    */
-  contract: v27.string(),
+  contract: v28.string(),
   /**
    * The name of the function to call.
    *
    * Note: spec changes ongoing,
    * https://github.com/stacksgov/sips/pull/166#pullrequestreview-1914236999
    */
-  functionName: v27.string(),
+  functionName: v28.string(),
   /**
    * @deprecated in favor of `functionArgs` for @stacks/connect compatibility
    */
-  arguments: v27.optional(v27.array(v27.string())),
+  arguments: v28.optional(v28.array(v28.string())),
   /**
    * The function's arguments. The arguments are expected to be hex-encoded
    * strings of Clarity values.
@@ -1208,274 +1236,274 @@ var stxCallContractParamsSchema = v27.object({
    * const hexArgs = functionArgs.map(cvToHex);
    * ```
    */
-  functionArgs: v27.optional(v27.array(v27.string())),
+  functionArgs: v28.optional(v28.array(v28.string())),
   /**
    * The post conditions to apply to the contract call.
    */
-  postConditions: v27.optional(v27.array(v27.string())),
+  postConditions: v28.optional(v28.array(v28.string())),
   /**
    * The mode to apply to the post conditions.
    */
-  postConditionMode: v27.optional(v27.union([v27.literal("allow"), v27.literal("deny")]))
+  postConditionMode: v28.optional(v28.union([v28.literal("allow"), v28.literal("deny")]))
 });
-var stxCallContractResultSchema = v27.object({
+var stxCallContractResultSchema = v28.object({
   /**
    * The ID of the transaction.
    */
-  txid: v27.string(),
+  txid: v28.string(),
   /**
    * A Stacks transaction as a hex-encoded string.
    */
-  transaction: v27.string()
+  transaction: v28.string()
 });
-var stxCallContractRequestMessageSchema = v27.object({
+var stxCallContractRequestMessageSchema = v28.object({
   ...rpcRequestMessageSchema.entries,
-  ...v27.object({
-    method: v27.literal(stxCallContractMethodName),
+  ...v28.object({
+    method: v28.literal(stxCallContractMethodName),
     params: stxCallContractParamsSchema,
-    id: v27.string()
+    id: v28.string()
   }).entries
 });
 
 // src/request/types/stxMethods/deployContract.ts
-import * as v28 from "valibot";
+import * as v29 from "valibot";
 var stxDeployContractMethodName = "stx_deployContract";
-var stxDeployContractParamsSchema = v28.object({
+var stxDeployContractParamsSchema = v29.object({
   /**
    * Name of the contract.
    */
-  name: v28.string(),
+  name: v29.string(),
   /**
    * The source code of the Clarity contract.
    */
-  clarityCode: v28.string(),
+  clarityCode: v29.string(),
   /**
    * The version of the Clarity contract.
    */
-  clarityVersion: v28.optional(v28.number()),
+  clarityVersion: v29.optional(v29.number()),
   /**
    * The post conditions to apply to the contract call.
    */
-  postConditions: v28.optional(v28.array(v28.string())),
+  postConditions: v29.optional(v29.array(v29.string())),
   /**
    * The mode to apply to the post conditions.
    */
-  postConditionMode: v28.optional(v28.union([v28.literal("allow"), v28.literal("deny")]))
+  postConditionMode: v29.optional(v29.union([v29.literal("allow"), v29.literal("deny")]))
 });
-var stxDeployContractResultSchema = v28.object({
+var stxDeployContractResultSchema = v29.object({
   /**
    * The ID of the transaction.
    */
-  txid: v28.string(),
+  txid: v29.string(),
   /**
    * A Stacks transaction as a hex-encoded string.
    */
-  transaction: v28.string()
+  transaction: v29.string()
 });
-var stxDeployContractRequestMessageSchema = v28.object({
+var stxDeployContractRequestMessageSchema = v29.object({
   ...rpcRequestMessageSchema.entries,
-  ...v28.object({
-    method: v28.literal(stxDeployContractMethodName),
+  ...v29.object({
+    method: v29.literal(stxDeployContractMethodName),
     params: stxDeployContractParamsSchema,
-    id: v28.string()
+    id: v29.string()
   }).entries
 });
 
 // src/request/types/stxMethods/getAccounts.ts
-import * as v29 from "valibot";
+import * as v30 from "valibot";
 var stxGetAccountsMethodName = "stx_getAccounts";
-var stxGetAccountsParamsSchema = v29.nullish(v29.null());
-var stxGetAccountsResultSchema = v29.object({
+var stxGetAccountsParamsSchema = v30.nullish(v30.null());
+var stxGetAccountsResultSchema = v30.object({
   /**
    * The addresses generated for the given purposes.
    */
-  addresses: v29.array(
-    v29.object({
-      address: v29.string(),
-      publicKey: v29.string(),
-      gaiaHubUrl: v29.string(),
-      gaiaAppKey: v29.string()
+  addresses: v30.array(
+    v30.object({
+      address: v30.string(),
+      publicKey: v30.string(),
+      gaiaHubUrl: v30.string(),
+      gaiaAppKey: v30.string()
     })
   ),
   network: getNetworkResultSchema
 });
-var stxGetAccountsRequestMessageSchema = v29.object({
+var stxGetAccountsRequestMessageSchema = v30.object({
   ...rpcRequestMessageSchema.entries,
-  ...v29.object({
-    method: v29.literal(stxGetAccountsMethodName),
+  ...v30.object({
+    method: v30.literal(stxGetAccountsMethodName),
     params: stxGetAccountsParamsSchema,
-    id: v29.string()
+    id: v30.string()
   }).entries
 });
 
 // src/request/types/stxMethods/getAddresses.ts
-import * as v30 from "valibot";
+import * as v31 from "valibot";
 var stxGetAddressesMethodName = "stx_getAddresses";
-var stxGetAddressesParamsSchema = v30.nullish(
-  v30.object({
+var stxGetAddressesParamsSchema = v31.nullish(
+  v31.object({
     /**
      * A message to be displayed to the user in the request prompt.
      */
-    message: v30.optional(v30.string())
+    message: v31.optional(v31.string())
   })
 );
-var stxGetAddressesResultSchema = v30.object({
+var stxGetAddressesResultSchema = v31.object({
   /**
    * The addresses generated for the given purposes.
    */
-  addresses: v30.array(addressSchema),
+  addresses: v31.array(addressSchema),
   network: getNetworkResultSchema
 });
-var stxGetAddressesRequestMessageSchema = v30.object({
+var stxGetAddressesRequestMessageSchema = v31.object({
   ...rpcRequestMessageSchema.entries,
-  ...v30.object({
-    method: v30.literal(stxGetAddressesMethodName),
+  ...v31.object({
+    method: v31.literal(stxGetAddressesMethodName),
     params: stxGetAddressesParamsSchema,
-    id: v30.string()
+    id: v31.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signMessage.ts
-import * as v31 from "valibot";
+import * as v32 from "valibot";
 var stxSignMessageMethodName = "stx_signMessage";
-var stxSignMessageParamsSchema = v31.object({
+var stxSignMessageParamsSchema = v32.object({
   /**
    * The message to sign.
    */
-  message: v31.string()
+  message: v32.string()
 });
-var stxSignMessageResultSchema = v31.object({
+var stxSignMessageResultSchema = v32.object({
   /**
    * The signature of the message.
    */
-  signature: v31.string(),
+  signature: v32.string(),
   /**
    * The public key used to sign the message.
    */
-  publicKey: v31.string()
+  publicKey: v32.string()
 });
-var stxSignMessageRequestMessageSchema = v31.object({
+var stxSignMessageRequestMessageSchema = v32.object({
   ...rpcRequestMessageSchema.entries,
-  ...v31.object({
-    method: v31.literal(stxSignMessageMethodName),
+  ...v32.object({
+    method: v32.literal(stxSignMessageMethodName),
     params: stxSignMessageParamsSchema,
-    id: v31.string()
+    id: v32.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signStructuredMessage.ts
-import * as v32 from "valibot";
+import * as v33 from "valibot";
 var stxSignStructuredMessageMethodName = "stx_signStructuredMessage";
-var stxSignStructuredMessageParamsSchema = v32.object({
+var stxSignStructuredMessageParamsSchema = v33.object({
   /**
    * The domain to be signed.
    */
-  domain: v32.string(),
+  domain: v33.string(),
   /**
    * Message payload to be signed.
    */
-  message: v32.string(),
+  message: v33.string(),
   /**
    * The public key to sign the message with.
    */
-  publicKey: v32.optional(v32.string())
+  publicKey: v33.optional(v33.string())
 });
-var stxSignStructuredMessageResultSchema = v32.object({
+var stxSignStructuredMessageResultSchema = v33.object({
   /**
    * Signature of the message.
    */
-  signature: v32.string(),
+  signature: v33.string(),
   /**
    * Public key as hex-encoded string.
    */
-  publicKey: v32.string()
+  publicKey: v33.string()
 });
-var stxSignStructuredMessageRequestMessageSchema = v32.object({
+var stxSignStructuredMessageRequestMessageSchema = v33.object({
   ...rpcRequestMessageSchema.entries,
-  ...v32.object({
-    method: v32.literal(stxSignStructuredMessageMethodName),
+  ...v33.object({
+    method: v33.literal(stxSignStructuredMessageMethodName),
     params: stxSignStructuredMessageParamsSchema,
-    id: v32.string()
+    id: v33.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signTransaction.ts
-import * as v33 from "valibot";
+import * as v34 from "valibot";
 var stxSignTransactionMethodName = "stx_signTransaction";
-var stxSignTransactionParamsSchema = v33.object({
+var stxSignTransactionParamsSchema = v34.object({
   /**
    * The transaction to sign as a hex-encoded string.
    */
-  transaction: v33.string(),
+  transaction: v34.string(),
   /**
    * The public key to sign the transaction with. The wallet may use any key
    * when not provided.
    */
-  pubkey: v33.optional(v33.string()),
+  pubkey: v34.optional(v34.string()),
   /**
    * Whether to broadcast the transaction after signing. Defaults to `true`.
    */
-  broadcast: v33.optional(v33.boolean())
+  broadcast: v34.optional(v34.boolean())
 });
-var stxSignTransactionResultSchema = v33.object({
+var stxSignTransactionResultSchema = v34.object({
   /**
    * The signed transaction as a hex-encoded string.
    */
-  transaction: v33.string()
+  transaction: v34.string()
 });
-var stxSignTransactionRequestMessageSchema = v33.object({
+var stxSignTransactionRequestMessageSchema = v34.object({
   ...rpcRequestMessageSchema.entries,
-  ...v33.object({
-    method: v33.literal(stxSignTransactionMethodName),
+  ...v34.object({
+    method: v34.literal(stxSignTransactionMethodName),
     params: stxSignTransactionParamsSchema,
-    id: v33.string()
+    id: v34.string()
   }).entries
 });
 
 // src/request/types/stxMethods/signTransactions.ts
-import * as v34 from "valibot";
+import * as v35 from "valibot";
 var stxSignTransactionsMethodName = "stx_signTransactions";
-var stxSignTransactionsParamsSchema = v34.object({
+var stxSignTransactionsParamsSchema = v35.object({
   /**
    * The transactions to sign as hex-encoded strings.
    */
-  transactions: v34.pipe(
-    v34.array(
-      v34.pipe(
-        v34.string(),
-        v34.check((hex) => {
+  transactions: v35.pipe(
+    v35.array(
+      v35.pipe(
+        v35.string(),
+        v35.check((hex) => {
           return true;
         }, "Invalid hex-encoded Stacks transaction.")
       )
     ),
-    v34.minLength(1)
+    v35.minLength(1)
   ),
   /**
    * Whether the signed transactions should be broadcast after signing. Defaults
    * to `true`.
    */
-  broadcast: v34.optional(v34.boolean())
+  broadcast: v35.optional(v35.boolean())
 });
-var stxSignTransactionsResultSchema = v34.object({
+var stxSignTransactionsResultSchema = v35.object({
   /**
    * The signed transactions as hex-encoded strings, in the same order as in the
    * sign request.
    */
-  transactions: v34.array(v34.string())
+  transactions: v35.array(v35.string())
 });
-var stxSignTransactionsRequestMessageSchema = v34.object({
+var stxSignTransactionsRequestMessageSchema = v35.object({
   ...rpcRequestMessageSchema.entries,
-  ...v34.object({
-    method: v34.literal(stxSignTransactionsMethodName),
+  ...v35.object({
+    method: v35.literal(stxSignTransactionsMethodName),
     params: stxSignTransactionsParamsSchema,
-    id: v34.string()
+    id: v35.string()
   }).entries
 });
 
 // src/request/types/stxMethods/transferStx.ts
-import * as v35 from "valibot";
+import * as v36 from "valibot";
 var stxTransferStxMethodName = "stx_transferStx";
-var stxTransferStxParamsSchema = v35.object({
+var stxTransferStxParamsSchema = v36.object({
   /**
    * Amount of STX tokens to transfer in microstacks as a string. Anything
    * parseable by `BigInt` is acceptable.
@@ -1488,23 +1516,23 @@ var stxTransferStxParamsSchema = v35.object({
    * const amount3 = '1234';
    * ```
    */
-  amount: v35.union([v35.number(), v35.string()]),
+  amount: v36.union([v36.number(), v36.string()]),
   /**
    * The recipient's principal.
    */
-  recipient: v35.string(),
+  recipient: v36.string(),
   /**
    * A string representing the memo.
    */
-  memo: v35.optional(v35.string()),
+  memo: v36.optional(v36.string()),
   /**
    * Version of parameter format.
    */
-  version: v35.optional(v35.string()),
+  version: v36.optional(v36.string()),
   /**
    * The mode of the post conditions.
    */
-  postConditionMode: v35.optional(v35.number()),
+  postConditionMode: v36.optional(v36.number()),
   /**
    * A hex-encoded string representing the post conditions.
    *
@@ -1517,29 +1545,29 @@ var stxTransferStxParamsSchema = v35.object({
    * const hexPostCondition = serializePostCondition(postCondition).toString('hex');
    * ```
    */
-  postConditions: v35.optional(v35.array(v35.string())),
+  postConditions: v36.optional(v36.array(v36.string())),
   /**
    * The public key to sign the transaction with. The wallet may use any key
    * when not provided.
    */
-  pubkey: v35.optional(v35.string())
+  pubkey: v36.optional(v36.string())
 });
-var stxTransferStxResultSchema = v35.object({
+var stxTransferStxResultSchema = v36.object({
   /**
    * The ID of the transaction.
    */
-  txid: v35.string(),
+  txid: v36.string(),
   /**
    * A Stacks transaction as a hex-encoded string.
    */
-  transaction: v35.string()
+  transaction: v36.string()
 });
-var stxTransferStxRequestMessageSchema = v35.object({
+var stxTransferStxRequestMessageSchema = v36.object({
   ...rpcRequestMessageSchema.entries,
-  ...v35.object({
-    method: v35.literal(stxTransferStxMethodName),
+  ...v36.object({
+    method: v36.literal(stxTransferStxMethodName),
     params: stxTransferStxParamsSchema,
-    id: v35.string()
+    id: v36.string()
   }).entries
 });
 
@@ -1547,13 +1575,13 @@ var stxTransferStxRequestMessageSchema = v35.object({
 var cache = {};
 var requestInternal = async (provider, method, params) => {
   const response = await provider.request(method, params);
-  if (v36.is(rpcErrorResponseMessageSchema, response)) {
+  if (v37.is(rpcErrorResponseMessageSchema, response)) {
     return {
       status: "error",
       error: response.error
     };
   }
-  if (v36.is(rpcSuccessResponseMessageSchema, response)) {
+  if (v37.is(rpcSuccessResponseMessageSchema, response)) {
     return {
       status: "success",
       result: response.result
@@ -2769,6 +2797,10 @@ export {
   sparkGetBalanceParamsSchema,
   sparkGetBalanceRequestMessageSchema,
   sparkGetBalanceResultSchema,
+  sparkSignMessageMethodName,
+  sparkSignMessageParamsSchema,
+  sparkSignMessageRequestMessageSchema,
+  sparkSignMessageResultSchema,
   sparkTransferMethodName,
   sparkTransferParamsSchema,
   sparkTransferRequestMessageSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sats-connect/core",
-  "version": "0.9.0",
+  "version": "0.10.0-25de943",
   "main": "dist/index.mjs",
   "module": "dist/index.mjs",
   "types": "dist/index.d.mts",