diff --git a/src/oauth/client.ts b/src/oauth/client.ts
index caa52da..0c3b09e 100644
--- a/src/oauth/client.ts
+++ b/src/oauth/client.ts
@@ -39,303 +39,153 @@ export class Client {
     };
   }
 
-  accountBalance(
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    params: {},
-    request_options?: Partial<RequestOptions>,
-  ): Promise<GetAccountBalanceResponse> {
+  // HTTP handlers
+  private httpGet<T>(
+    endpoint: string,
+    params?: any,
+    options?: Partial<RequestOptions>,
+  ): Promise<T> {
     return rest({
       auth: this.auth,
       ...this.defaultRequestOptions,
-      ...request_options,
-      endpoint: `/balance`,
+      ...options,
+      endpoint,
       params,
       method: "GET",
     });
   }
 
-  signMessage(
-    message: SignMessageRequestParams,
-    request_options?: Partial<RequestOptions>,
-  ): Promise<SignMessageResponse> {
+  private httpPost<T>(
+    endpoint: string,
+    body?: any,
+    options?: Partial<RequestOptions>,
+  ): Promise<T> {
     return rest({
       auth: this.auth,
       ...this.defaultRequestOptions,
-      ...request_options,
-      endpoint: `/signatures`,
-      request_body: message,
+      ...options,
+      endpoint,
+      request_body: body,
       method: "POST",
     });
   }
 
-  accountSummary(
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    params: {},
-    request_options?: Partial<RequestOptions>,
-  ) {
+  private httpDelete<T>(
+    endpoint: string,
+    options?: Partial<RequestOptions>,
+  ): Promise<T> {
     return rest({
       auth: this.auth,
       ...this.defaultRequestOptions,
-      ...request_options,
-      endpoint: `/user/summary`,
-      params,
-      method: "GET",
+      ...options,
+      endpoint,
+      method: "DELETE",
     });
   }
 
-  accountInformation(
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    params: {},
-    request_options?: Partial<RequestOptions>,
-  ): Promise<GetAccountInformationResponse> {
-    return rest({
-      auth: this.auth,
-      ...this.defaultRequestOptions,
-      ...request_options,
-      endpoint: `/user/me`,
-      params,
-      method: "GET",
-    });
+  accountBalance(): Promise<GetAccountBalanceResponse> {
+    return this.httpGet<GetAccountBalanceResponse>("/balance");
   }
 
-  accountValue4Value(
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    params: {},
-    request_options?: Partial<RequestOptions>,
-  ) {
-    return rest({
-      auth: this.auth,
-      ...this.defaultRequestOptions,
-      ...request_options,
-      endpoint: `/user/value4value`,
-      params,
-      method: "GET",
-    });
+  signMessage(message: SignMessageRequestParams): Promise<SignMessageResponse> {
+    return this.httpPost<SignMessageResponse>("/signatures", message);
   }
 
-  incomingInvoices(
-    params: GetInvoicesRequestParams,
-    request_options?: Partial<RequestOptions>,
-  ): Promise<Invoice[]> {
-    return rest({
-      auth: this.auth,
-      ...this.defaultRequestOptions,
-      ...request_options,
-      endpoint: `/invoices/incoming`,
-      params,
-      method: "GET",
-    });
+  accountSummary() {
+    return this.httpGet("/user/summary");
   }
 
-  outgoingInvoices(
-    params: GetInvoicesRequestParams,
-    request_options?: Partial<RequestOptions>,
-  ): Promise<Invoice[]> {
-    return rest({
-      auth: this.auth,
-      ...this.defaultRequestOptions,
-      ...request_options,
-      endpoint: `/invoices/outgoing`,
-      params,
-      method: "GET",
-    });
+  accountInformation(): Promise<GetAccountInformationResponse> {
+    return this.httpGet<GetAccountInformationResponse>("/user/me");
   }
 
-  invoices(
-    params: GetInvoicesRequestParams,
-    request_options?: Partial<RequestOptions>,
-  ): Promise<Invoice[]> {
-    return rest({
-      auth: this.auth,
-      ...this.defaultRequestOptions,
-      ...request_options,
-      endpoint: `/invoices`,
-      params,
-      method: "GET",
-    });
+  accountValue4Value() {
+    return this.httpGet("/user/value4value");
   }
 
-  getInvoice(
-    paymentHash: string,
-    request_options?: Partial<RequestOptions>,
-  ): Promise<Invoice> {
-    return rest({
-      auth: this.auth,
-      ...this.defaultRequestOptions,
-      ...request_options,
-      endpoint: `/invoices/${paymentHash}`,
-      method: "GET",
-    });
+  incomingInvoices(params: GetInvoicesRequestParams) {
+    return this.httpGet<Invoice[]>("/invoices/incoming", params);
   }
 
-  decodeInvoice(
-    paymentRequest: string,
-    request_options?: Partial<RequestOptions>,
-  ): Promise<DecodedInvoice> {
-    return rest({
-      auth: this.auth,
-      ...this.defaultRequestOptions,
-      ...request_options,
-      endpoint: `/decode/bolt11/${paymentRequest}`,
-      method: "GET",
-    });
+  outgoingInvoices(params: GetInvoicesRequestParams) {
+    return this.httpGet<Invoice[]>("/invoices/outgoing", params);
   }
 
-  createInvoice(
-    invoice: InvoiceRequestParams,
-    request_options?: Partial<RequestOptions>,
-  ): Promise<Invoice> {
-    return rest({
-      auth: this.auth,
-      ...this.defaultRequestOptions,
-      ...request_options,
-      endpoint: `/invoices`,
-      request_body: invoice,
-      method: "POST",
-    });
+  invoices(params: GetInvoicesRequestParams) {
+    return this.httpGet<Invoice[]>("/invoices", params);
   }
 
-  keysend(
-    args: KeysendRequestParams | KeysendRequestParams[],
-    request_options?: Partial<RequestOptions>,
-  ): Promise<SendPaymentResponse> {
-    let endpoint, request_body;
-    if (Array.isArray(args)) {
-      endpoint = "/payments/keysend/multi";
-      request_body = {
-        keysends: args.map((args) => ({
-          ...args,
-          custom_records: args.customRecords,
-        })),
-      };
-    } else {
-      endpoint = "/payments/keysend";
-      request_body = {
-        ...args,
-        custom_records: args.customRecords,
-      };
-    }
-    return rest({
-      auth: this.auth,
-      ...this.defaultRequestOptions,
-      ...request_options,
-      endpoint,
-      request_body,
-      method: "POST",
-    });
+  getInvoice(paymentHash: string) {
+    return this.httpGet<Invoice>("/invoices/${paymentHash}");
   }
 
-  sendPayment(
-    params: SendPaymentRequestParams,
-    request_options?: Partial<RequestOptions>,
-  ): Promise<SendPaymentResponse> {
-    return rest({
-      auth: this.auth,
-      ...this.defaultRequestOptions,
-      ...request_options,
-      endpoint: `/payments/bolt11`,
-      request_body: params,
-      method: "POST",
-    });
+  decodeInvoice(paymentRequest: string) {
+    return this.httpGet<DecodedInvoice>("/decode/bolt11/${paymentRequest}");
+  }
+
+  createInvoice(invoice: InvoiceRequestParams) {
+    return this.httpPost<Invoice>("/invoices", invoice);
+  }
+
+  keysend(args: KeysendRequestParams | KeysendRequestParams[]) {
+    const isMulti = Array.isArray(args);
+    const endpoint = isMulti ? "/payments/keysend/multi" : "/payments/keysend";
+    const body = isMulti
+      ? {
+          keysends: args.map((a) => ({
+            ...a,
+            custom_records: a.customRecords,
+          })),
+        }
+      : { ...args, custom_records: args.customRecords };
+
+    return this.httpPost<SendPaymentResponse>(endpoint, body);
+  }
+
+  sendPayment(params: SendPaymentRequestParams) {
+    return this.httpPost<SendPaymentResponse>("/payments/bolt11", params);
   }
 
   sendBoostagram(
     args: SendBoostagramRequestParams | SendBoostagramRequestParams[],
-    request_options?: Partial<RequestOptions>,
   ) {
-    let endpoint, request_body;
-    if (Array.isArray(args)) {
-      endpoint = "/payments/keysend/multi";
-      const keysends = args.map((b) => keysendParamsFromBoostagram(b));
-      request_body = { keysends };
-    } else {
-      endpoint = "/payments/keysend";
-      request_body = keysendParamsFromBoostagram(args);
-    }
+    const isMulti = Array.isArray(args);
+    const endpoint = isMulti ? "/payments/keysend/multi" : "/payments/keysend";
+    const body = isMulti
+      ? { keysends: args.map(keysendParamsFromBoostagram) }
+      : keysendParamsFromBoostagram(args);
 
-    return rest({
-      auth: this.auth,
-      ...this.defaultRequestOptions,
-      ...request_options,
-      endpoint,
-      request_body,
-      method: "POST",
-    });
+    return this.httpPost(endpoint, body);
   }
 
-  sendBoostagramToAlbyAccount(
-    args: SendBoostagramToAlbyRequestParams,
-    request_options?: Partial<RequestOptions>,
-  ) {
-    const params = {
+  sendBoostagramToAlbyAccount(args: SendBoostagramToAlbyRequestParams) {
+    return this.httpPost("/payments/keysend", {
       destination:
         "030a58b8653d32b99200a2334cfe913e51dc7d155aa0116c176657a4f1722677a3",
-      custom_records: {
-        "696969": args.account,
-      },
+      custom_records: { "696969": args.account },
       amount: args.amount,
       memo: args.memo,
-    };
-    return rest({
-      auth: this.auth,
-      ...this.defaultRequestOptions,
-      ...request_options,
-      endpoint: `/payments/keysend`,
-      request_body: params,
-      method: "POST",
     });
   }
 
-  createWebhookEndpoint(
-    params: CreateWebhookEndpointParams,
-    request_options?: Partial<RequestOptions>,
-  ): Promise<CreateWebhookEndpointResponse> {
-    return rest({
-      auth: this.auth,
-      ...this.defaultRequestOptions,
-      ...request_options,
-      endpoint: `/webhook_endpoints`,
-      request_body: params,
-      method: "POST",
-    });
+  createWebhookEndpoint(params: CreateWebhookEndpointParams) {
+    return this.httpPost<CreateWebhookEndpointResponse>(
+      "/webhook_endpoints",
+      params,
+    );
   }
 
-  deleteWebhookEndpoint(
-    id: string,
-    request_options?: Partial<RequestOptions>,
-  ): Promise<BaseWebhookEndpointResponse> {
-    return rest({
-      auth: this.auth,
-      ...this.defaultRequestOptions,
-      ...request_options,
-      endpoint: `/webhook_endpoints/${id}`,
-      method: "DELETE",
-    });
+  deleteWebhookEndpoint(id: string) {
+    return this.httpDelete<BaseWebhookEndpointResponse>(
+      "/webhook_endpoints/${id}",
+    );
   }
 
-  getSwapInfo(
-    request_options?: Partial<RequestOptions>,
-  ): Promise<SwapInfoResponse> {
-    return rest({
-      auth: this.auth,
-      ...this.defaultRequestOptions,
-      ...request_options,
-      endpoint: `/swaps/info`,
-      method: "GET",
-    });
+  getSwapInfo() {
+    return this.httpGet<SwapInfoResponse>("/swaps/info");
   }
 
-  createSwap(
-    params: CreateSwapParams,
-    request_options?: Partial<RequestOptions>,
-  ): Promise<CreateSwapResponse> {
-    return rest({
-      auth: this.auth,
-      ...this.defaultRequestOptions,
-      ...request_options,
-      endpoint: `/swaps`,
-      method: "POST",
-      request_body: params,
-    });
+  createSwap(params: CreateSwapParams) {
+    return this.httpPost<CreateSwapResponse>("/swaps", params);
   }
 }
diff --git a/src/webln/OauthWeblnProvider.ts b/src/webln/OauthWeblnProvider.ts
index b2b3197..31af912 100644
--- a/src/webln/OauthWeblnProvider.ts
+++ b/src/webln/OauthWeblnProvider.ts
@@ -35,63 +35,46 @@ export class OauthWeblnProvider {
     }
   }
 
-  async enable() {
-    if (this.isExecuting) {
-      return;
+  private async execute<T>(fn: () => Promise<T>): Promise<T | undefined> {
+    if (this.isExecuting) return;
+    this.isExecuting = true;
+    try {
+      return await fn();
+    } catch (error) {
+      let message = "Unknown Error";
+      if (error instanceof Error) {
+        message = error.message;
+      }
+      throw new Error(message);
+    } finally {
+      this.isExecuting = false;
     }
+  }
+
+  async enable() {
     if (this.auth.token?.access_token) {
       return { enabled: true };
     }
-    if (isBrowser()) {
-      try {
-        this.isExecuting = true;
-        await this.openAuthorization();
-      } finally {
-        this.isExecuting = false;
-      }
-    } else {
+    if (!isBrowser()) {
       throw new Error("Missing access token");
     }
+    await this.execute(() => this.openAuthorization());
   }
 
   async sendPayment(invoice: string) {
-    if (this.isExecuting) {
-      return;
-    }
-    try {
-      this.isExecuting = true;
+    return this.execute(async () => {
       const result = await this.client.sendPayment({ invoice });
       this.notify("sendPayment", result);
-      return {
-        preimage: result.payment_preimage,
-      };
-    } catch (error) {
-      let message = "Unknown Error";
-      if (error instanceof Error) message = error.message;
-      throw new Error(message);
-    } finally {
-      this.isExecuting = false;
-    }
+      return { preimage: result.payment_preimage };
+    });
   }
 
   async keysend(params: KeysendRequestParams) {
-    if (this.isExecuting) {
-      return;
-    }
-    try {
-      this.isExecuting = true;
+    return this.execute(async () => {
       const result = await this.client.keysend(params);
       this.notify("keysend", result);
-      return {
-        preimage: result.payment_preimage,
-      };
-    } catch (error) {
-      let message = "Unknown Error";
-      if (error instanceof Error) message = error.message;
-      throw new Error(message);
-    } finally {
-      this.isExecuting = false;
-    }
+      return { preimage: result.payment_preimage };
+    });
   }
 
   async getInfo() {
@@ -101,26 +84,14 @@ export class OauthWeblnProvider {
   }
 
   async makeInvoice(params: RequestInvoiceArgs) {
-    if (this.isExecuting) {
-      return;
-    }
-    try {
-      this.isExecuting = true;
+    return this.execute(async () => {
       const result = await this.client.createInvoice({
         amount: parseInt(params.amount.toString()),
         description: params.defaultMemo,
       });
       this.notify("makeInvoice", result);
-      return {
-        paymentRequest: result.payment_request,
-      };
-    } catch (error) {
-      let message = "Unknown Error";
-      if (error instanceof Error) message = error.message;
-      throw new Error(message);
-    } finally {
-      this.isExecuting = false;
-    }
+      return { paymentRequest: result.payment_request };
+    });
   }
 
   async openAuthorization() {