@ckb-ccc/xverse 0.0.15-alpha.0

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@ckb-ccc/xverse",
+  "version": "0.0.15-alpha.0",
+  "description": "CCC - CKBer's Codebase. Common Chains Connector's support for Xverse",
+  "author": "Hanssen0 <hanssen0@hanssen0.com>",
+  "license": "MIT",
+  "private": false,
+  "homepage": "https://github.com/ckb-ecofund/ccc",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/ckb-ecofund/ccc.git"
+  },
+  "main": "dist.commonjs/index.js",
+  "module": "dist/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "default": "./dist.commonjs/index.js"
+    },
+    "./barrel": {
+      "import": "./dist/barrel.js",
+      "default": "./dist.commonjs/barrel.js"
+    },
+    "./advanced": {
+      "import": "./dist/advanced.js",
+      "default": "./dist.commonjs/advanced.js"
+    },
+    "./advancedBarrel": {
+      "import": "./dist/advancedBarrel.js",
+      "default": "./dist.commonjs/advancedBarrel.js"
+    }
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.1.1",
+    "copyfiles": "^2.4.1",
+    "eslint": "^9.1.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "prettier": "^3.2.5",
+    "prettier-plugin-organize-imports": "^3.2.4",
+    "rimraf": "^5.0.5",
+    "typescript": "^5.4.5",
+    "typescript-eslint": "^7.7.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "valibot": "^0.42.1",
+    "@ckb-ccc/core": "0.0.15"
+  },
+  "scripts": {
+    "build": "rimraf ./dist && rimraf ./dist.commonjs && tsc && tsc --project tsconfig.commonjs.json && copyfiles -u 2 misc/basedirs/**/* .",
+    "lint": "eslint",
+    "format": "prettier --write . && eslint --fix"
+  }
+}

package/src/advanced.ts

@@ -0,0 +1 @@
+export * as XverseA from "./advancedBarrel.js";

package/src/advancedBarrel.ts

@@ -0,0 +1 @@
+export * from "./sat-connect-core/advanced.js";

package/src/barrel.ts

@@ -0,0 +1,2 @@
+export * from "./signer.js";
+export * from "./signersFactory.js";

package/src/index.ts

@@ -0,0 +1 @@
+export * as Xverse from "./barrel.js";

package/src/sat-connect-core/advanced.ts

@@ -0,0 +1,4 @@
+export * from "./btcMethods.advanced";
+export * from "./provider.advanced";
+export * from "./requests.advanced";
+export * from "./types.advanced";

package/src/sat-connect-core/btcMethods.advanced.ts

@@ -0,0 +1,304 @@
+// From https://github.com/secretkeylabs/sats-connect-core/
+
+/**
+ * Represents the types and interfaces related to BTC methods.
+ */
+
+import * as v from "valibot";
+import {
+  MethodParamsAndResult,
+  rpcRequestMessageSchema,
+} from "./types.advanced";
+import { walletTypeSchema } from "./walletMethods.advanced";
+
+export enum AddressPurpose {
+  Ordinals = "ordinals",
+  Payment = "payment",
+  Stacks = "stacks",
+}
+
+export enum AddressType {
+  p2pkh = "p2pkh",
+  p2sh = "p2sh",
+  p2wpkh = "p2wpkh",
+  p2wsh = "p2wsh",
+  p2tr = "p2tr",
+  stacks = "stacks",
+}
+
+export const addressSchema = v.object({
+  address: v.string(),
+  publicKey: v.string(),
+  purpose: v.enum(AddressPurpose),
+  addressType: v.enum(AddressType),
+});
+export type Address = v.InferOutput<typeof addressSchema>;
+
+export const getInfoMethodName = "getInfo";
+export const getInfoParamsSchema = v.nullish(v.null());
+export type GetInfoParams = v.InferOutput<typeof getInfoParamsSchema>;
+export const getInfoResultSchema = v.object({
+  /**
+   * Version of the wallet.
+   */
+  version: v.string(),
+
+  /**
+   * [WBIP](https://wbips.netlify.app/wbips/WBIP002) methods supported by the wallet.
+   */
+  methods: v.optional(v.array(v.string())),
+
+  /**
+   * List of WBIP standards supported by the wallet. Not currently used.
+   */
+  supports: v.array(v.string()),
+});
+export type GetInfoResult = v.InferOutput<typeof getInfoResultSchema>;
+export const getInfoRequestMessageSchema = v.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v.object({
+    method: v.literal(getInfoMethodName),
+    params: getInfoParamsSchema,
+    id: v.string(),
+  }).entries,
+});
+export type GetInfoRequestMessage = v.InferOutput<
+  typeof getInfoRequestMessageSchema
+>;
+export type GetInfo = MethodParamsAndResult<
+  v.InferOutput<typeof getInfoParamsSchema>,
+  v.InferOutput<typeof getInfoResultSchema>
+>;
+
+export const getAddressesMethodName = "getAddresses";
+export const getAddressesParamsSchema = v.object({
+  /**
+   * The purposes for which to generate addresses. See
+   * {@linkcode AddressPurpose} for available purposes.
+   */
+  purposes: v.array(v.enum(AddressPurpose)),
+  /**
+   * A message to be displayed to the user in the request prompt.
+   */
+  message: v.optional(v.string()),
+});
+export type GetAddressesParams = v.InferOutput<typeof getAddressesParamsSchema>;
+export const getAddressesResultSchema = v.object({
+  /**
+   * The addresses generated for the given purposes.
+   */
+  addresses: v.array(addressSchema),
+});
+export type GetAddressesResult = v.InferOutput<typeof getAddressesResultSchema>;
+export const getAddressesRequestMessageSchema = v.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v.object({
+    method: v.literal(getAddressesMethodName),
+    params: getAddressesParamsSchema,
+    id: v.string(),
+  }).entries,
+});
+export type GetAddressesRequestMessage = v.InferOutput<
+  typeof getAddressesRequestMessageSchema
+>;
+export type GetAddresses = MethodParamsAndResult<
+  v.InferOutput<typeof getAddressesParamsSchema>,
+  v.InferOutput<typeof getAddressesResultSchema>
+>;
+
+export const signMessageMethodName = "signMessage";
+
+export enum MessageSigningProtocols {
+  ECDSA = "ECDSA",
+  BIP322 = "BIP322",
+}
+
+export const signMessageParamsSchema = v.object({
+  /**
+   * The address used for signing.
+   **/
+  address: v.string(),
+  /**
+   * The message to sign.
+   **/
+  message: v.string(),
+  /**
+   * The protocol to use for signing the message.
+   */
+  protocol: v.optional(v.enum(MessageSigningProtocols)),
+});
+export type SignMessageParams = v.InferOutput<typeof signMessageParamsSchema>;
+export const signMessageResultSchema = v.object({
+  /**
+   * The signature of the message.
+   */
+  signature: v.string(),
+  /**
+   * hash of the message.
+   */
+  messageHash: v.string(),
+  /**
+   * The address used for signing.
+   */
+  address: v.string(),
+  /**
+   * The protocol to use for signing the message.
+   */
+  protocol: v.enum(MessageSigningProtocols),
+});
+export type SignMessageResult = v.InferOutput<typeof signMessageResultSchema>;
+export const signMessageRequestMessageSchema = v.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v.object({
+    method: v.literal(signMessageMethodName),
+    params: signMessageParamsSchema,
+    id: v.string(),
+  }).entries,
+});
+export type SignMessageRequestMessage = v.InferOutput<
+  typeof signMessageRequestMessageSchema
+>;
+export type SignMessage = MethodParamsAndResult<
+  v.InferOutput<typeof signMessageParamsSchema>,
+  v.InferOutput<typeof signMessageResultSchema>
+>;
+
+type Recipient = {
+  /**
+   * The recipient's address.
+   **/
+  address: string;
+  /**
+   * The amount to send to the recipient in satoshis.
+   */
+  amount: number;
+};
+
+export type SendTransferParams = {
+  /**
+   * Array of recipients to send to.
+   * The amount to send to each recipient is in satoshis.
+   */
+  recipients: Array<Recipient>;
+};
+type SendTransferResult = {
+  /**
+   * The transaction id as a hex-encoded string.
+   */
+  txid: string;
+};
+
+export type SendTransfer = MethodParamsAndResult<
+  SendTransferParams,
+  SendTransferResult
+>;
+
+export type SignPsbtParams = {
+  /**
+   * The base64 encoded PSBT to sign.
+   */
+  psbt: string;
+  /**
+   * The inputs to sign.
+   * The key is the address and the value is an array of indexes of the inputs to sign.
+   */
+  signInputs: Record<string, number[]>;
+  /**
+   * the sigHash type to use for signing.
+   * will default to the sighash type of the input if not provided.
+   **/
+  allowedSignHash?: number;
+  /**
+   * Whether to broadcast the transaction after signing.
+   **/
+  broadcast?: boolean;
+};
+
+export type SignPsbtResult = {
+  /**
+   * The base64 encoded PSBT after signing.
+   */
+  psbt: string;
+  /**
+   * The transaction id as a hex-encoded string.
+   * This is only returned if the transaction was broadcast.
+   **/
+  txid?: string;
+};
+
+export type SignPsbt = MethodParamsAndResult<SignPsbtParams, SignPsbtResult>;
+
+export const getAccountsMethodName = "getAccounts";
+export const getAccountsParamsSchema = v.object({
+  /**
+   * The purposes for which to generate addresses. See
+   * {@linkcode AddressPurpose} for available purposes.
+   */
+  purposes: v.array(v.enum(AddressPurpose)),
+  /**
+   * A message to be displayed to the user in the request prompt.
+   */
+  message: v.optional(v.string()),
+});
+export type GetAccountsParams = v.InferOutput<typeof getAccountsParamsSchema>;
+
+export const getAccountsResultSchema = v.array(
+  v.object({
+    ...addressSchema.entries,
+    ...v.object({
+      walletType: walletTypeSchema,
+    }).entries,
+  }),
+);
+export type GetAccountsResult = v.InferOutput<typeof getAccountsResultSchema>;
+export const getAccountsRequestMessageSchema = v.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v.object({
+    method: v.literal(getAccountsMethodName),
+    params: getAccountsParamsSchema,
+    id: v.string(),
+  }).entries,
+});
+export type GetAccountsRequestMessage = v.InferOutput<
+  typeof getAccountsRequestMessageSchema
+>;
+export type GetAccounts = MethodParamsAndResult<
+  v.InferOutput<typeof getAccountsParamsSchema>,
+  v.InferOutput<typeof getAccountsResultSchema>
+>;
+
+export const getBalanceMethodName = "getBalance";
+export const getBalanceParamsSchema = v.nullish(v.null());
+export const getBalanceResultSchema = v.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: v.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: v.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: v.string(),
+});
+export const getBalanceRequestMessageSchema = v.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v.object({
+    method: v.literal(getBalanceMethodName),
+    id: v.string(),
+  }).entries,
+});
+export type GetBalance = MethodParamsAndResult<
+  v.InferOutput<typeof getBalanceParamsSchema>,
+  v.InferOutput<typeof getBalanceResultSchema>
+>;

package/src/sat-connect-core/provider.advanced.ts

@@ -0,0 +1,61 @@
+import * as v from "valibot";
+import { Requests, Params } from "./requests.advanced";
+import { RpcResponse } from "./types.advanced";
+
+// accountChange
+export const accountChangeEventName = "accountChange";
+export const accountChangeSchema = v.object({
+  type: v.literal(accountChangeEventName),
+});
+export type AccountChangeEvent = v.InferOutput<typeof accountChangeSchema>;
+
+// networkChange
+export const networkChangeEventName = "networkChange";
+export const networkChangeSchema = v.object({
+  type: v.literal(networkChangeEventName),
+});
+export type NetworkChangeEvent = v.InferOutput<typeof networkChangeSchema>;
+
+// disconnect
+export const disconnectEventName = "disconnect";
+export const disconnectSchema = v.object({
+  type: v.literal(disconnectEventName),
+});
+export type DisconnectEvent = v.InferOutput<typeof disconnectSchema>;
+
+export const walletEventSchema = v.variant("type", [
+  accountChangeSchema,
+  networkChangeSchema,
+  disconnectSchema,
+]);
+
+export type WalletEvent = v.InferOutput<typeof walletEventSchema>;
+export type AddListener = <const WalletEventName extends WalletEvent["type"]>(
+  eventName: WalletEventName,
+  cb: (event: Extract<WalletEvent, { type: WalletEventName }>) => void,
+) => () => void;
+
+/**
+ * Interface representing a provider for interacting with accounts and signing messages.
+ */
+export interface BtcProvider {
+  request: <Method extends keyof Requests>(
+    method: Method,
+    options: Params<Method>,
+    providerId?: string,
+  ) => Promise<RpcResponse<Method>>;
+
+  addListener: AddListener;
+}
+
+export interface Provider {
+  id: string;
+  name: string;
+  icon: string;
+  webUrl?: string;
+  chromeWebStoreUrl?: string;
+  mozillaAddOnsUrl?: string;
+  googlePlayStoreUrl?: string;
+  iOSAppStoreUrl?: string;
+  methods?: string[];
+}

package/src/sat-connect-core/requests.advanced.ts

@@ -0,0 +1,41 @@
+import {
+  GetAccounts,
+  GetAddresses,
+  GetBalance,
+  GetInfo,
+  SendTransfer,
+  SignMessage,
+  SignPsbt,
+} from "./btcMethods.advanced";
+import {
+  GetWalletType,
+  RenouncePermissions,
+  RequestPermissions,
+} from "./walletMethods.advanced";
+
+export interface BtcRequests {
+  getInfo: GetInfo;
+  getAddresses: GetAddresses;
+  getAccounts: GetAccounts;
+  getBalance: GetBalance;
+  signMessage: SignMessage;
+  sendTransfer: SendTransfer;
+  signPsbt: SignPsbt;
+}
+
+export type BtcRequestMethod = keyof BtcRequests;
+
+export interface WalletRequests {
+  wallet_requestPermissions: RequestPermissions;
+  wallet_renouncePermissions: RenouncePermissions;
+  wallet_getWalletType: GetWalletType;
+}
+
+export type Requests = BtcRequests & WalletRequests;
+
+export type Return<Method> = Method extends keyof Requests
+  ? Requests[Method]["result"]
+  : never;
+export type Params<Method> = Method extends keyof Requests
+  ? Requests[Method]["params"]
+  : never;

package/src/sat-connect-core/types.advanced.ts

@@ -0,0 +1,159 @@
+// From https://github.com/secretkeylabs/sats-connect-core/
+
+import * as v from "valibot";
+import type { BtcProvider } from "./provider.advanced";
+import type { Requests, Return } from "./requests.advanced";
+
+export enum BitcoinNetworkType {
+  Mainnet = "Mainnet",
+  Testnet = "Testnet",
+  Signet = "Signet",
+}
+
+export interface BitcoinNetwork {
+  type: BitcoinNetworkType;
+  address?: string;
+}
+
+export interface RequestPayload {
+  network: BitcoinNetwork;
+}
+
+export interface RequestOptions<Payload extends RequestPayload, Response> {
+  onFinish: (response: Response) => void;
+  onCancel: () => void;
+  payload: Payload;
+  getProvider?: () => Promise<BtcProvider | undefined>;
+}
+
+// RPC Request and Response types
+
+export const RpcIdSchema = v.optional(
+  v.union([v.string(), v.number(), v.null()]),
+);
+export type RpcId = v.InferOutput<typeof RpcIdSchema>;
+export const rpcRequestMessageSchema = v.object({
+  jsonrpc: v.literal("2.0"),
+  method: v.string(),
+  params: v.optional(
+    v.union([
+      v.array(v.unknown()),
+      v.looseObject({}),
+      // Note: This is to support current incorrect usage of RPC 2.0. Params need
+      // to be either an array or an object when provided. Changing this now would
+      // be a breaking change, so accepting null values for now. Tracking in
+      // https://linear.app/xverseapp/issue/ENG-4538.
+      v.null(),
+    ]),
+  ),
+  id: RpcIdSchema,
+});
+export type RpcRequestMessage = v.InferOutput<typeof rpcRequestMessageSchema>;
+
+export interface RpcBase {
+  jsonrpc: "2.0";
+  id: RpcId;
+}
+export interface RpcRequest<T extends string, U> extends RpcBase {
+  method: T;
+  params: U;
+}
+
+export interface MethodParamsAndResult<TParams, TResult> {
+  params: TParams;
+  result: TResult;
+}
+
+/**
+ * @enum {number} RpcErrorCode
+ * @description JSON-RPC error codes
+ * @see https://www.jsonrpc.org/specification#error_object
+ */
+export enum RpcErrorCode {
+  /**
+   * Parse error Invalid JSON
+   **/
+  PARSE_ERROR = -32700,
+  /**
+   * The JSON sent is not a valid Request object.
+   **/
+  INVALID_REQUEST = -32600,
+  /**
+   * The method does not exist/is not available.
+   **/
+  METHOD_NOT_FOUND = -32601,
+  /**
+   * Invalid method parameter(s).
+   */
+  INVALID_PARAMS = -32602,
+  /**
+   * Internal JSON-RPC error.
+   * This is a generic error, used when the server encounters an error in performing the request.
+   **/
+  INTERNAL_ERROR = -32603,
+  /**
+   * user rejected/canceled the request
+   */
+  USER_REJECTION = -32000,
+  /**
+   * method is not supported for the address provided
+   */
+  METHOD_NOT_SUPPORTED = -32001,
+  /**
+   * The client does not have permission to access the requested resource.
+   */
+  ACCESS_DENIED = -32002,
+}
+
+export const rpcSuccessResponseMessageSchema = v.object({
+  jsonrpc: v.literal("2.0"),
+  result: v.nonOptional(v.unknown()),
+  id: RpcIdSchema,
+});
+export type RpcSuccessResponseMessage = v.InferOutput<
+  typeof rpcSuccessResponseMessageSchema
+>;
+
+export const rpcErrorResponseMessageSchema = v.object({
+  jsonrpc: v.literal("2.0"),
+  error: v.nonOptional(v.unknown()),
+  id: RpcIdSchema,
+});
+export type RpcErrorResponseMessage = v.InferOutput<
+  typeof rpcErrorResponseMessageSchema
+>;
+export const rpcResponseMessageSchema = v.union([
+  rpcSuccessResponseMessageSchema,
+  rpcErrorResponseMessageSchema,
+]);
+export type RpcResponseMessage = v.InferOutput<typeof rpcResponseMessageSchema>;
+
+export interface RpcError {
+  code: number | RpcErrorCode;
+  message: string;
+  data?: any;
+}
+
+export interface RpcErrorResponse<TError extends RpcError = RpcError>
+  extends RpcBase {
+  error: TError;
+}
+
+export interface RpcSuccessResponse<Method extends keyof Requests>
+  extends RpcBase {
+  result: Return<Method>;
+}
+
+export type RpcResponse<Method extends keyof Requests> =
+  | RpcSuccessResponse<Method>
+  | RpcErrorResponse;
+
+export type RpcResult<Method extends keyof Requests> =
+  | {
+      result: RpcSuccessResponse<Method>["result"];
+      status: "success";
+    }
+  | {
+      error: RpcErrorResponse["error"];
+      status: "error";
+    };

package/src/sat-connect-core/walletMethods.advanced.ts

@@ -0,0 +1,58 @@
+// From https://github.com/secretkeylabs/sats-connect-core/
+
+import * as v from "valibot";
+import {
+  MethodParamsAndResult,
+  rpcRequestMessageSchema,
+} from "./types.advanced.js";
+
+export const walletTypes = ["software", "ledger"] as const;
+export const walletTypeSchema = v.picklist(walletTypes);
+export type WalletType = v.InferOutput<typeof walletTypeSchema>;
+
+export const requestPermissionsMethodName = "wallet_requestPermissions";
+export const requestPermissionsParamsSchema = v.undefined();
+export const requestPermissionsResultSchema = v.literal(true);
+export const requestPermissionsRequestMessageSchema = v.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v.object({
+    method: v.literal(requestPermissionsMethodName),
+    params: requestPermissionsParamsSchema,
+    id: v.string(),
+  }).entries,
+});
+export type RequestPermissions = MethodParamsAndResult<
+  v.InferOutput<typeof requestPermissionsParamsSchema>,
+  v.InferOutput<typeof requestPermissionsResultSchema>
+>;
+
+export const renouncePermissionsMethodName = "wallet_renouncePermissions";
+export const renouncePermissionsParamsSchema = v.undefined();
+export const renouncePermissionsResultSchema = v.literal(true);
+export const renouncePermissionsRequestMessageSchema = v.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v.object({
+    method: v.literal(renouncePermissionsMethodName),
+    params: renouncePermissionsParamsSchema,
+    id: v.string(),
+  }).entries,
+});
+export type RenouncePermissions = MethodParamsAndResult<
+  v.InferOutput<typeof renouncePermissionsParamsSchema>,
+  v.InferOutput<typeof renouncePermissionsResultSchema>
+>;
+
+export const getWalletTypeMethodName = "wallet_getWalletType";
+export const getWalletTypeParamsSchema = v.nullish(v.null());
+export const getWalletTypeResultSchema = walletTypeSchema;
+export const getWalletTypeRequestMessageSchema = v.object({
+  ...rpcRequestMessageSchema.entries,
+  ...v.object({
+    method: v.literal(getWalletTypeMethodName),
+    id: v.string(),
+  }).entries,
+});
+export type GetWalletType = MethodParamsAndResult<
+  v.InferOutput<typeof getWalletTypeParamsSchema>,
+  v.InferOutput<typeof getWalletTypeResultSchema>
+>;