feat/runes-rpf

src/adapters/satsConnectAdapter.ts

@@ -55,6 +55,7 @@ abstract class SatsConnectAdapter {
         result: {
           orderId: orderResponse.data.orderId,
           fundTransactionId: paymentResponse.result.txid,
+          fundingAddress: orderResponse.data.fundAddress,
         },
       };
     } catch (error) {
@@ -124,6 +125,7 @@ abstract class SatsConnectAdapter {
         result: {
           orderId: orderResponse.data.orderId,
           fundTransactionId: paymentResponse.result.txid,
+          fundingAddress: orderResponse.data.fundAddress,
         },
       };
     } catch (error) {
@@ -219,6 +221,88 @@ abstract class SatsConnectAdapter {
     };
   }
 
+  private async estimateRbfOrder(
+    params: Params<'runes_estimateRbfOrder'>
+  ): Promise<RpcResult<'runes_estimateRbfOrder'>> {
+    const rbfOrderRequest: Omit<Params<'runes_estimateRbfOrder'>, 'network'> = {
+      newFeeRate: params.newFeeRate,
+      orderId: params.orderId,
+    };
+    const response = await getRunesApiClient(params.network).rbfOrder(rbfOrderRequest);
+    if (response.data) {
+      return {
+        status: 'success',
+        result: {
+          fundingAddress: response.data.fundingAddress,
+          rbfCost: response.data.rbfCost,
+        },
+      };
+    }
+    return {
+      status: 'error',
+      error: {
+        code:
+          response.error.code === 400 ? RpcErrorCode.INVALID_REQUEST : RpcErrorCode.INTERNAL_ERROR,
+        message: response.error.message,
+      },
+    };
+  }
+
+  private async rbfOrder(params: Params<'runes_rbfOrder'>): Promise<RpcResult<'runes_rbfOrder'>> {
+    try {
+      const rbfOrderRequest: Omit<Params<'runes_rbfOrder'>, 'network'> = {
+        newFeeRate: params.newFeeRate,
+        orderId: params.orderId,
+      };
+      const orderResponse = await getRunesApiClient(params.network).rbfOrder(rbfOrderRequest);
+      if (!orderResponse.data) {
+        return {
+          status: 'error',
+          error: {
+            code:
+              orderResponse.error.code === 400
+                ? RpcErrorCode.INVALID_REQUEST
+                : RpcErrorCode.INTERNAL_ERROR,
+            message: orderResponse.error.message,
+          },
+        };
+      }
+      const paymentResponse = await this.requestInternal('sendTransfer', {
+        recipients: [
+          {
+            address: orderResponse.data.fundingAddress,
+            amount: orderResponse.data.rbfCost,
+          },
+        ],
+      });
+      if (paymentResponse?.status !== 'success') {
+        return {
+          status: 'error',
+          error: {
+            code: RpcErrorCode.USER_REJECTION,
+            message: 'User rejected the payment request',
+          },
+        };
+      }
+      return {
+        status: 'success',
+        result: {
+          fundingAddress: orderResponse.data.fundingAddress,
+          orderId: rbfOrderRequest.orderId,
+          fundRBFTransactionId: paymentResponse.result.txid,
+        },
+      };
+    } catch (error) {
+      return {
+        status: 'error',
+        error: {
+          code: RpcErrorCode.INTERNAL_ERROR,
+          message: error.message,
+        },
+      };
+    }
+  }
+
   async request<Method extends keyof Requests>(
     method: Method,
     params: Params<Method>
@@ -239,6 +323,14 @@ abstract class SatsConnectAdapter {
       case 'runes_getOrder': {
         return this.getOrder(params as Params<'runes_getOrder'>) as Promise<RpcResult<Method>>;
       }
+      case 'runes_estimateRbfOrder': {
+        return this.estimateRbfOrder(params as Params<'runes_estimateRbfOrder'>) as Promise<
+          RpcResult<Method>
+        >;
+      }
+      case 'runes_rbfOrder': {
+        return this.rbfOrder(params as Params<'runes_rbfOrder'>) as Promise<RpcResult<Method>>;
+      }
       default:
         return this.requestInternal(method, params);
     }

src/request/types/index.ts

@@ -7,11 +7,13 @@ import {
   SignPsbt,
 } from './btcMethods';
 import {
+  EstimateRbfOrder,
   EstimateRunesEtch,
   EstimateRunesMint,
   EtchRunes,
   GetOrder,
   MintRunes,
+  RbfOrder,
 } from './runesMethods';
 import {
   StxCallContract,
@@ -54,6 +56,8 @@ export interface RunesRequests {
   runes_estimateEtch: EstimateRunesEtch;
   runes_etch: EtchRunes;
   runes_getOrder: GetOrder;
+  runes_estimateRbfOrder: EstimateRbfOrder;
+  runes_rbfOrder: RbfOrder;
 }
 
 export type RunesRequestMethod = keyof RunesRequests;

src/request/types/runesMethods.ts

@@ -6,6 +6,8 @@ import {
   EstimateOrderResponse,
   GetOrderRequest,
   GetOrderResponse,
+  RBFOrderRequest,
+  RBFOrderResponse,
 } from '../../runes/types';
 import { BitcoinNetworkType, MethodParamsAndResult } from '../../types';
 
@@ -27,6 +29,7 @@ export interface MintRunesParams extends CreateMintOrderRequest {
 export type MintRunesResult = {
   orderId: string;
   fundTransactionId: string;
+  fundingAddress: string;
 };
 
 export type MintRunes = MethodParamsAndResult<MintRunesParams, MintRunesResult>;
@@ -49,6 +52,7 @@ export interface EtchRunesParams extends CreateEtchOrderRequest {
 export type EtchRunesResult = {
   orderId: string;
   fundTransactionId: string;
+  fundingAddress: string;
 };
 
 export type EtchRunes = MethodParamsAndResult<EtchRunesParams, EtchRunesResult>;
@@ -58,3 +62,21 @@ interface GetOrderParams extends GetOrderRequest {
 }
 
 export type GetOrder = MethodParamsAndResult<GetOrderParams, GetOrderResponse>;
+
+interface EstimateRbfOrderParams extends RBFOrderRequest {
+  network?: BitcoinNetworkType;
+}
+
+export type EstimateRbfOrder = MethodParamsAndResult<EstimateRbfOrderParams, RBFOrderResponse>;
+
+interface RbfOrderParams extends RBFOrderRequest {
+  network?: BitcoinNetworkType;
+}
+
+interface RbfOrderResult {
+  orderId: string;
+  fundRBFTransactionId: string;
+  fundingAddress: string;
+}
+
+export type RbfOrder = MethodParamsAndResult<RbfOrderParams, RbfOrderResult>;

src/runes/index.ts

@@ -6,6 +6,8 @@ import {
   EstimateMintOrderRequest,
   EstimateOrderResponse,
   GetOrderResponse,
+  RBFOrderRequest,
+  RBFOrderResponse,
 } from './types';
 import { BitcoinNetworkType } from '../types';
 
@@ -139,6 +141,23 @@ export class RunesApi {
       };
     }
   };
+
+  rbfOrder = async (rbfRequest: RBFOrderRequest) => {
+    const { orderId, newFeeRate } = rbfRequest;
+    try {
+      const response = await this.client.post<RBFOrderResponse>(`/orders/${orderId}/rbf-estimate`, {
+        newFeeRate,
+      });
+      return {
+        data: response.data,
+      };
+    } catch (error) {
+      const err = error as AxiosError;
+      return {
+        error: this.parseError(err),
+      };
+    }
+  };
 }
 
 const testnetClient = new RunesApi(BitcoinNetworkType.Testnet);

src/runes/types.ts

@@ -79,6 +79,17 @@ export type GetOrderResponse = {
   id: string;
   orderType: 'rune_mint' | 'rune_etch';
   state: 'new' | 'pending' | 'executing' | 'complete' | 'failed' | 'refunded' | 'stale';
+  fundingAddress: string;
   reason?: string;
   createdAt: string;
 };
+
+export type RBFOrderRequest = {
+  orderId: string;
+  newFeeRate: number;
+};
+
+export type RBFOrderResponse = {
+  rbfCost: number;
+  fundingAddress: string;
+};