Improve APIs and types (BREAKING) (#16)

* Remove unused type

* Rename AddressPurposes enum for best practices

* Extract call types into separate file

* Remove unused CallMethod enum

* Extract provider types into separate file

* Rename directories for consistency

* Rename sendBtcTransaction -> sendTransaction

* Extract transactions types to separate file

* Extract networks module

* Improve types

* Use [] instead of Array<> for consistency

* Fix copy-paste oversight

* Move index.ts inside src

* Use import type for types

* Revert sendBtcTransaction -> sendTransaction renaming

* Simplify types

---------

Co-authored-by: Victor Kirov <victor.kirov@gmail.com>

src/address/index.ts → src/addresses/index.ts

@@ -1,7 +1,8 @@
-import { createUnsecuredToken, Json } from 'jsontokens';
+import type { Json } from 'jsontokens';
+import { createUnsecuredToken } from 'jsontokens';
 
 import { getDefaultProvider } from '../provider';
-import { GetAddressOptions } from './types';
+import type { GetAddressOptions } from './types';
 
 export const getAddress = async (options: GetAddressOptions) => {
   const { getProvider = getDefaultProvider } = options;
@@ -17,8 +18,8 @@ export const getAddress = async (options: GetAddressOptions) => {
 
   try {
     const request = createUnsecuredToken(options.payload as unknown as Json);
-    const addressResponse = await provider.connect(request);
-    options.onFinish?.(addressResponse);
+    const response = await provider.connect(request);
+    options.onFinish?.(response);
   } catch (error) {
     console.error('[Connect] Error during address request', error);
     options.onCancel?.();

src/addresses/types.ts

@@ -0,0 +1,23 @@
+import type { RequestOptions, RequestPayload } from '../types';
+
+export enum AddressPurpose {
+  Ordinals = 'ordinals',
+  Payment = 'payment',
+}
+
+export interface GetAddressPayload extends RequestPayload {
+  purposes: AddressPurpose[];
+  message: string;
+}
+
+export interface Address {
+  address: string;
+  publicKey: string;
+  purpose: AddressPurpose;
+}
+
+export interface GetAddressResponse {
+  addresses: Address[];
+}
+
+export type GetAddressOptions = RequestOptions<GetAddressPayload, GetAddressResponse>;

src/call/index.ts

@@ -1,24 +1,8 @@
-import { createUnsecuredToken, Json } from 'jsontokens';
+import type { Json } from 'jsontokens';
+import { createUnsecuredToken } from 'jsontokens';
 
-import { BitcoinNetwork, GetBitcoinProviderFunc, getDefaultProvider } from '../provider';
-
-export interface CallWalletPayload {
-  method: string;
-  network: BitcoinNetwork;
-  params?: Array<any>;
-}
-
-export interface CallWalletOptions {
-  getProvider?: GetBitcoinProviderFunc;
-  onFinish: (response: Record<string, any>) => void;
-  onCancel: () => void;
-  payload: CallWalletPayload;
-}
-
-export enum CallMethod {
-  SIGN_TRANSACTION = 'signTransaction',
-  GET_ADDRESS = 'getAddress',
-}
+import { getDefaultProvider } from '../provider';
+import type { CallWalletOptions } from './types';
 
 export const callWalletPopup = async (options: CallWalletOptions) => {
   const { getProvider = getDefaultProvider } = options;
@@ -34,10 +18,12 @@ export const callWalletPopup = async (options: CallWalletOptions) => {
 
   const request = createUnsecuredToken(options.payload as unknown as Json);
   try {
-    const callResponse = await provider.call(request);
-    options.onFinish?.(callResponse);
+    const response = await provider.call(request);
+    options.onFinish?.(response);
   } catch (error) {
     console.error('[Connect] Error during call request', error);
     options.onCancel?.();
   }
 };
+
+export * from './types';

src/call/types.ts

@@ -0,0 +1,10 @@
+import type { RequestOptions, RequestPayload } from '../types';
+
+export interface CallWalletPayload extends RequestPayload {
+  method: string;
+  params?: any[];
+}
+
+export type CallWalletResponse = Record<string, any>;
+
+export type CallWalletOptions = RequestOptions<CallWalletPayload, CallWalletResponse>;

src/index.ts

@@ -0,0 +1,6 @@
+export * from './addresses';
+export * from './call';
+export * from './messages';
+export * from './provider';
+export * from './transactions';
+export * from './types';

src/signatures/index.ts → src/messages/index.ts

@@ -1,7 +1,8 @@
-import { createUnsecuredToken, Json } from 'jsontokens';
+import type { Json } from 'jsontokens';
+import { createUnsecuredToken } from 'jsontokens';
 
 import { getDefaultProvider } from '../provider';
-import { SignMessageOptions } from './types';
+import type { SignMessageOptions } from './types';
 
 export const signMessage = async (options: SignMessageOptions) => {
   const { getProvider = getDefaultProvider } = options;

src/messages/types.ts

@@ -0,0 +1,10 @@
+import type { RequestOptions, RequestPayload } from '../types';
+
+export interface SignMessagePayload extends RequestPayload {
+  address: string;
+  message: string;
+}
+
+export type SignMessageResponse = string;
+
+export type SignMessageOptions = RequestOptions<SignMessagePayload, SignMessageResponse>;

src/provider/index.ts

@@ -1,27 +1,7 @@
-import { GetAddressResponse } from '../address';
-import { SignTransactionResponse } from '../transactions/signTransaction';
-
-export interface BitcoinNetwork {
-  type: 'Mainnet' | 'Testnet';
-  address?: string;
-}
-
-export interface BitcoinProvider {
-  connect: (request: string) => Promise<GetAddressResponse>;
-  call: (request: string) => Promise<Record<string, any>>;
-  signTransaction: (request: string) => Promise<SignTransactionResponse>;
-  signMessage: (request: string) => Promise<string>;
-  sendBtcTransaction: (request: string) => Promise<string>;
-}
-
-declare global {
-  interface Window {
-    BitcoinProvider?: BitcoinProvider;
-  }
-}
-
-export type GetBitcoinProviderFunc = () => Promise<BitcoinProvider | undefined>;
+import type { BitcoinProvider } from './types';
 
 export async function getDefaultProvider(): Promise<BitcoinProvider | undefined> {
   return window.BitcoinProvider;
 }
+
+export * from './types';

src/provider/types.ts

@@ -0,0 +1,18 @@
+import type { GetAddressResponse } from '../addresses';
+import type { CallWalletResponse } from '../call';
+import type { SignMessageResponse } from '../messages';
+import type { SendBtcTransactionResponse, SignTransactionResponse } from '../transactions';
+
+export interface BitcoinProvider {
+  call: (request: string) => Promise<CallWalletResponse>;
+  connect: (request: string) => Promise<GetAddressResponse>;
+  signMessage: (request: string) => Promise<SignMessageResponse>;
+  signTransaction: (request: string) => Promise<SignTransactionResponse>;
+  sendBtcTransaction: (request: string) => Promise<SendBtcTransactionResponse>;
+}
+
+declare global {
+  interface Window {
+    BitcoinProvider?: BitcoinProvider;
+  }
+}

src/transactions/index.ts

@@ -0,0 +1,3 @@
+export * from './sendBtcTransaction';
+export * from './signTransaction';
+export * from './types';

src/transactions/sendBtcTransaction.ts

@@ -1,25 +1,8 @@
-import { createUnsecuredToken, Json } from 'jsontokens';
+import type { Json } from 'jsontokens';
+import { createUnsecuredToken } from 'jsontokens';
 
-import { BitcoinNetwork, GetBitcoinProviderFunc, getDefaultProvider } from '../provider';
-
-export interface Recipient {
-  address: string;
-  amountSats: bigint;
-}
-
-export interface SendBtcTransactionPayload {
-  network: BitcoinNetwork;
-  recipients: Recipient[];
-  senderAddress: string;
-  message?: string;
-}
-
-export interface SendBtcTransactionOptions {
-  getProvider?: GetBitcoinProviderFunc;
-  onFinish: (response: string) => void;
-  onCancel: () => void;
-  payload: SendBtcTransactionPayload;
-}
+import { getDefaultProvider } from '../provider';
+import type { SendBtcTransactionOptions } from './types';
 
 export const sendBtcTransaction = async (options: SendBtcTransactionOptions) => {
   const { getProvider = getDefaultProvider } = options;
@@ -38,8 +21,8 @@ export const sendBtcTransaction = async (options: SendBtcTransactionOptions) =>
 
   try {
     const request = createUnsecuredToken(options.payload as unknown as Json);
-    const addressResponse = await provider.sendBtcTransaction(request);
-    options.onFinish?.(addressResponse);
+    const response = await provider.sendBtcTransaction(request);
+    options.onFinish?.(response);
   } catch (error) {
     console.error('[Connect] Error during send BTC transaction request', error);
     options.onCancel?.();

src/transactions/signTransaction.ts

@@ -1,32 +1,8 @@
-import { createUnsecuredToken, Json } from 'jsontokens';
+import type { Json } from 'jsontokens';
+import { createUnsecuredToken } from 'jsontokens';
 
-import { BitcoinNetwork, GetBitcoinProviderFunc, getDefaultProvider } from '../provider';
-
-export interface InputToSign {
-  address: string;
-  signingIndexes: Array<number>;
-  sigHash?: number;
-}
-
-export interface SignTransactionPayload {
-  network: BitcoinNetwork;
-  message: string;
-  psbtBase64: string;
-  broadcast?: boolean;
-  inputsToSign: InputToSign[];
-}
-
-export interface SignTransactionOptions {
-  getProvider?: GetBitcoinProviderFunc;
-  onFinish: (response: any) => void;
-  onCancel: () => void;
-  payload: SignTransactionPayload;
-}
-
-export interface SignTransactionResponse {
-  psbtBase64: string;
-  txId?: string;
-}
+import { getDefaultProvider } from '../provider';
+import type { SignTransactionOptions } from './types';
 
 export const signTransaction = async (options: SignTransactionOptions) => {
   const { getProvider = getDefaultProvider } = options;
@@ -45,8 +21,8 @@ export const signTransaction = async (options: SignTransactionOptions) => {
 
   try {
     const request = createUnsecuredToken(options.payload as unknown as Json);
-    const addressResponse = await provider.signTransaction(request);
-    options.onFinish?.(addressResponse);
+    const response = await provider.signTransaction(request);
+    options.onFinish?.(response);
   } catch (error) {
     console.error('[Connect] Error during sign transaction request', error);
     options.onCancel?.();

src/transactions/types.ts

@@ -0,0 +1,42 @@
+import type { RequestOptions, RequestPayload } from '../types';
+
+export interface Recipient {
+  address: string;
+  amountSats: bigint;
+}
+
+export interface SendBtcTransactionPayload extends RequestPayload {
+  recipients: Recipient[];
+  senderAddress: string;
+  message?: string;
+}
+
+export type SendBtcTransactionResponse = string;
+
+export type SendBtcTransactionOptions = RequestOptions<
+  SendBtcTransactionPayload,
+  SendBtcTransactionResponse
+>;
+
+export interface InputToSign {
+  address: string;
+  signingIndexes: number[];
+  sigHash?: number;
+}
+
+export interface SignTransactionPayload extends RequestPayload {
+  message: string;
+  psbtBase64: string;
+  inputsToSign: InputToSign[];
+  broadcast?: boolean;
+}
+
+export interface SignTransactionResponse {
+  psbtBase64: string;
+  txId?: string;
+}
+
+export type SignTransactionOptions = RequestOptions<
+  SignTransactionPayload,
+  SignTransactionResponse
+>;

src/types.ts

@@ -0,0 +1,22 @@
+import type { BitcoinProvider } from './provider';
+
+export enum BitcoinNetworkType {
+  Mainnet = 'Mainnet',
+  Testnet = 'Testnet',
+}
+
+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<BitcoinProvider | undefined>;
+}