mahmoud/eng-3688-detecting-the-wallet-api-bitcoin-provider

src/capabilities/index.ts

@@ -28,7 +28,8 @@ const extractOrValidateCapabilities = (
   };
 
   const capabilityMap: CapabilityMap = {
-    call: validateCapability('call'),
+    request: validateCapability('request'),
+    listen: validateCapability('listen'),
     connect: validateCapability('connect'),
     signMessage: validateCapability('signMessage'),
     signTransaction: validateCapability('signTransaction'),

src/index.ts

@@ -1,8 +1,9 @@
 export * from './addresses';
-export * from './call';
+export * from './request';
 export * from './capabilities';
 export * from './inscriptions';
 export * from './messages';
 export * from './provider';
 export * from './transactions';
 export * from './types';
+export * from './listen';

src/listen/index.ts

@@ -0,0 +1,15 @@
+import { getProviderOrThrow } from '../provider';
+
+export const listen = async (method: string, options: Record<string, any>) => {
+  const provider = await getProviderOrThrow(options.getProvider);
+
+  if (!method) {
+    throw new Error('A wallet method is required');
+  }
+
+  try {
+    return provider.listen(method, options.callback);
+  } catch (error) {
+    console.error('[Connect] Error during listen request', error);
+  }
+};

src/provider/index.ts

@@ -1,9 +1,10 @@
-import type { BitcoinProvider } from './types';
+import { type BitcoinProvider, type WebbtcProvider } from './types';
 
 export async function getProviderOrThrow(
   getProvider?: () => Promise<BitcoinProvider | undefined>
 ): Promise<BitcoinProvider> {
-  const provider = (await getProvider?.()) || window.XverseProviders?.BitcoinProvider || window.BitcoinProvider;
+  const provider =
+    (await getProvider?.()) || window.XverseProviders?.BitcoinProvider || window.BitcoinProvider;
 
   if (!provider) {
     throw new Error('No Bitcoin wallet installed');
@@ -12,4 +13,19 @@ export async function getProviderOrThrow(
   return provider;
 }
 
+export function getProviders(): WebbtcProvider[] {
+  if (!window.webbtc_providers) window.webbtc_providers = [];
+  return window.webbtc_providers;
+}
+
+export function getProviderById(providerId: string) {
+  if (Array.isArray(window.webbtc_providers)) {
+    const provider = window.webbtc_providers.find((provider) => provider.id === providerId);
+    return provider?.id?.split('.').reduce((acc: any, part) => acc?.[part], window);
+  } else {
+    console.error('window.webbtc_providers is not defined or not an array');
+    return null;
+  }
+}
+
 export * from './types';

src/provider/types.ts

@@ -1,5 +1,5 @@
+import { Params, Requests } from '../request';
 import type { GetAddressResponse } from '../addresses';
-import type { CallWalletResponse } from '../call';
 import type { GetCapabilitiesResponse } from '../capabilities';
 import type { CreateInscriptionResponse, CreateRepeatInscriptionsResponse } from '../inscriptions';
 import type { SignMessageResponse } from '../messages';
@@ -8,9 +8,15 @@ import type {
   SignMultipleTransactionsResponse,
   SignTransactionResponse,
 } from '../transactions';
+import { RpcResponse } from '../types';
 
 interface BaseBitcoinProvider {
-  call: (request: string) => Promise<CallWalletResponse>;
+  request: <Method extends keyof Requests>(
+    method: Method,
+    options: Params<Method>,
+    providerId?: string
+  ) => Promise<RpcResponse<Method>>;
+  listen: (method: string, callback: () => void) => void;
   connect: (request: string) => Promise<GetAddressResponse>;
   signMessage: (request: string) => Promise<SignMessageResponse>;
   signTransaction: (request: string) => Promise<SignTransactionResponse>;
@@ -26,13 +32,25 @@ export interface BitcoinProvider extends BaseBitcoinProvider {
   getCapabilities?: (request: string) => Promise<GetCapabilitiesResponse>;
 }
 
+export interface WebbtcProvider {
+  id: string;
+  name: string;
+  icon: string;
+  webUrl?: string;
+  chromeWebStoreUrl?: string;
+  mozillaAddOnsUrl?: string;
+  googlePlayStoreUrl?: string;
+  iOSAppStoreUrl?: string;
+  methods?: string[];
+}
+
 declare global {
   interface XverseProviders {
     BitcoinProvider?: BitcoinProvider;
   }
-
   interface Window {
     BitcoinProvider?: BitcoinProvider;
-    XverseProviders?: XverseProviders
+    XverseProviders?: XverseProviders;
+    webbtc_providers: WebbtcProvider[];
   }
 }

src/request/index.ts

@@ -0,0 +1,24 @@
+import { RpcResponse } from '../types';
+import { getProviderById } from '../provider';
+import { Params, Requests } from './types';
+
+export const request = async <Method extends keyof Requests>(
+  method: Method,
+  params: Params<Method>,
+  providerId?: string
+): Promise<RpcResponse<Method>> => {
+  let provider = window.XverseProviders?.BitcoinProvider;
+  if (providerId) {
+    provider = await getProviderById(providerId);
+  }
+  if (!provider) {
+    throw new Error('no wallet provider was found');
+  }
+  if (!method) {
+    throw new Error('A wallet method is required');
+  }
+
+  return provider.request(method, params);
+};
+
+export * from './types';

src/request/types/btcMethods.ts

@@ -0,0 +1,125 @@
+/**
+ * Represents the types and interfaces related to BTC methods.
+ */
+
+import { Address, AddressPurpose } from '../../addresses';
+import { MethodParamsAndResult } from '../../types';
+
+type GetInfoResult = {
+  version: number | string;
+  methods?: Array<string>;
+  supports?: Array<string>;
+};
+
+export type GetInfo = MethodParamsAndResult<null, GetInfoResult>;
+
+type GetAddressesParams = {
+  /**
+   * The purposes for which to generate addresses.
+   * possible values are "payment", "ordinals", ...
+   */
+  purposes: Array<AddressPurpose>;
+  /**
+   * a message to be displayed to the user in the request prompt.
+   */
+  message?: string;
+};
+
+/**
+ * The addresses generated for the given purposes.
+ */
+type GetAddressesResult = {
+  addresses: Array<Address>;
+};
+
+export type GetAddresses = MethodParamsAndResult<GetAddressesParams, GetAddressesResult>;
+
+type SignMessageParams = {
+  /**
+   * The address used for signing.
+   **/
+  address: string;
+  /**
+   * The message to sign.
+   **/
+  message: string;
+};
+
+type SignMessageResult = {
+  /**
+   * The signature of the message.
+   */
+  signature: string;
+  /**
+   * hash of the message.
+   */
+  messageHash: string;
+  /**
+   * The address used for signing.
+   */
+  address: string;
+};
+
+export type SignMessage = MethodParamsAndResult<SignMessageParams, SignMessageResult>;
+
+type Recipient = {
+  /**
+   * The recipient's address.
+   **/
+  address: string;
+  /**
+   * The amount to send to the recipient in satoshis.
+   */
+  amount: number;
+};
+
+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>;

src/request/types/index.ts

@@ -0,0 +1,48 @@
+import { RpcSuccessResponse } from 'src/types';
+import { GetAddresses, GetInfo, SendTransfer, SignMessage, SignPsbt } from './btcMethods';
+import {
+  StxContractCall,
+  StxContractDeploy,
+  StxGetAccounts,
+  StxSignStructuredMessage,
+  StxSignStxMessage,
+  StxSignTransaction,
+  StxTransferStx,
+  StxGetAddresses,
+} from './stxMethods';
+
+export interface StxRequests {
+  stx_contractCall: StxContractCall;
+  stx_transferStx: StxTransferStx;
+  stx_signMessage: StxSignStxMessage;
+  stx_signStructuredMessage: StxSignStructuredMessage;
+  stx_contractDeploy: StxContractDeploy;
+  stx_signTransaction: StxSignTransaction;
+  stx_getAccounts: StxGetAccounts;
+  stx_getAddresses: StxGetAddresses;
+}
+
+export type StxRequestMethod = keyof StxRequests;
+
+export interface BtcRequests {
+  getInfo: GetInfo;
+  getAddresses: GetAddresses;
+  signMessage: SignMessage;
+  sendTransfer: SendTransfer;
+  signPsbt: SignPsbt;
+}
+
+export type BtcRequestMethod = keyof BtcRequests;
+
+export type Requests = BtcRequests & StxRequests;
+
+export type Return<Method> = Method extends keyof Requests ? Requests[Method]['result'] : unknown;
+export type Params<Method> = Method extends keyof Requests ? Requests[Method]['params'] : unknown;
+
+export type Request<Method extends keyof Requests> = (
+  requestMethod: Method,
+  param?: Params<Method>
+) => Promise<RpcSuccessResponse<Method>>;
+
+export * from './stxMethods';
+export * from './btcMethods';