feat: add inscription calls and hooks

api/ordinals.ts

@@ -72,12 +72,18 @@
   return ordinals.sort(sortOrdinalsByConfirmationTime);
 }
 
-export async function getOrdinalIdFromUtxo(utxo: UTXO) {
+export async function getOrdinalIdsFromUtxo(utxo: UTXO): Promise<string[]> {
   const ordinalContentUrl = `${XVERSE_INSCRIBE_URL}/v1/inscriptions/utxo/${utxo.txid}/${utxo.vout}`;
 
-  const ordinalIds = await axios.get<string[]>(ordinalContentUrl);
-  if (ordinalIds.data.length > 0) {
-    return ordinalIds.data[ordinalIds.data.length - 1];
+  const { data: ordinalIds } = await axios.get<string[]>(ordinalContentUrl);
+
+  return ordinalIds;
+}
+
+export async function getOrdinalIdFromUtxo(utxo: UTXO) {
+  const ordinalIds = await getOrdinalIdsFromUtxo(utxo);
+  if (ordinalIds.length > 0) {
+    return ordinalIds[ordinalIds.length - 1];
   } else {
     return null;
   }
@@ -90,8 +96,8 @@
       timeout: 30000,
       transformResponse: [(data) => parseOrdinalTextContentData(data)],
     })
     .then((response) => response!.data)
     .catch((error) => {
       return '';
     });
 }
@@ -121,9 +127,9 @@
     })
     .then((response) => {
       if (response.data) {
         const responseTokensList = response!.data;
         const tokensList: Array<FungibleToken> = [];
         responseTokensList.forEach((responseToken: any) => {
           const token: FungibleToken = {
             name: responseToken.ticker,
             balance: responseToken.overallBalance,
@@ -146,7 +152,7 @@
         return [];
       }
     })
     .catch((error) => {
       return [];
     });
 }
@@ -165,7 +171,7 @@
       });
       return transactions;
     })
     .catch((error) => {
       return [];
     });
 }

api/xverseInscribe.ts

@@ -9,6 +9,12 @@ import {
   Brc20ExecuteOrderResponse,
   Brc20FinalizeTransferOrderRequest,
   Brc20FinalizeTransferOrderResponse,
+  InscriptionCostEstimateRequest,
+  InscriptionCostEstimateResponse,
+  InscriptionCreateOrderRequest,
+  InscriptionCreateOrderResponse,
+  InscriptionExecuteOrderRequest,
+  InscriptionExecuteOrderResponse,
   NetworkType,
 } from 'types';
 
@@ -18,6 +24,26 @@ const apiClient = axios.create({
   baseURL: XVERSE_INSCRIBE_URL,
 });
 
+const getInscriptionFeeEstimate = async (
+  requestBody: InscriptionCostEstimateRequest,
+): Promise<InscriptionCostEstimateResponse> => {
+  const response = await apiClient.post<InscriptionCostEstimateResponse>('/v1/inscriptions/cost-estimate', requestBody);
+  return response.data;
+};
+
+const createInscriptionOrder = async (
+  requestBody: InscriptionCreateOrderRequest,
+): Promise<InscriptionCreateOrderResponse> => {
+  const response = await apiClient.post<InscriptionCreateOrderResponse>('/v1/inscriptions/place-order', requestBody);
+  return response.data;
+};
+const executeInscriptionOrder = async (
+  requestBody: InscriptionExecuteOrderRequest,
+): Promise<InscriptionExecuteOrderResponse> => {
+  const response = await apiClient.post<InscriptionExecuteOrderResponse>('/v1/inscriptions/execute-order', requestBody);
+  return response.data;
+};
+
 const getBrc20TransferFees = async (
   tick: string,
   amount: number,
@@ -169,6 +195,9 @@ const finalizeBrc20TransferOrder = async (
 };
 
 export default {
+  getInscriptionFeeEstimate,
+  createInscriptionOrder,
+  executeInscriptionOrder,
   getBrc20TransferFees,
   createBrc20TransferOrder,
   getBrc20MintFees,

hooks/brc20/index.ts

@@ -0,0 +1,2 @@
+export { default as useBrc20TransferExecute } from './useBrc20TransferExecute';
+export { default as useBrc20TransferFees } from './useBrc20TransferFees';

hooks/brc20/useBrc20TransferExecute.ts

@@ -0,0 +1,182 @@
+import { useCallback, useState } from 'react';
+
+import { NetworkType, UTXO } from 'types';
+import { CoreError } from '../../utils/coreError';
+
+import { BRC20ErrorCode, ExecuteTransferProgressCodes, brc20TransferExecute } from '../../transactions/brc20';
+
+export enum ErrorCode {
+  INSUFFICIENT_FUNDS = 'INSUFFICIENT_FUNDS',
+  INVALID_TICK = 'INVALID_TICK',
+  INVALID_AMOUNT = 'INVALID_AMOUNT',
+  INVALID_FEE_RATE = 'INVALID_FEE_RATE',
+  BROADCAST_FAILED = 'BROADCAST_FAILED',
+  SERVER_ERROR = 'SERVER_ERROR',
+}
+
+type Props = {
+  seedPhrase: string;
+  accountIndex: number;
+  addressUtxos: UTXO[];
+  tick: string;
+  amount: number;
+  revealAddress: string;
+  changeAddress: string;
+  recipientAddress: string;
+  feeRate: number;
+  network: NetworkType;
+};
+
+const validateProps = (props: Props) => {
+  const { addressUtxos, tick, amount, feeRate } = props;
+
+  if (!addressUtxos.length) {
+    return ErrorCode.INSUFFICIENT_FUNDS;
+  }
+
+  if (tick.length !== 4) {
+    return ErrorCode.INVALID_TICK;
+  }
+
+  if (amount <= 0) {
+    return ErrorCode.INVALID_AMOUNT;
+  }
+
+  if (feeRate <= 0) {
+    return ErrorCode.INVALID_FEE_RATE;
+  }
+  return undefined;
+};
+
+/**
+ *
+ * @param seedPhrase - The seed phrase of the wallet
+ * @param accountIndex - The account index of the seed phrase to use
+ * @param addressUtxos - The UTXOs in the bitcoin address which will be used for payment
+ * @param tick - The 4 letter BRC-20 token name
+ * @param amount - The amount of the BRC-20 token to transfer
+ * @param revealAddress - The address where the balance of the BRC-20 token lives. This is usually the ordinals address.
+ * @param changeAddress - The address where change SATS will be sent to. Should be the Bitcoin address of the wallet.
+ * @param recipientAddress - The address where the BRC-20 tokens will be sent to.
+ * @param feeRate - The desired fee rate for the transactions
+ * @param network - The network to broadcast the transactions on (Mainnet or Testnet)
+ * @returns
+ */
+const useBrc20TransferExecute = (props: Props) => {
+  const {
+    seedPhrase,
+    accountIndex,
+    addressUtxos,
+    tick,
+    amount,
+    revealAddress,
+    changeAddress,
+    recipientAddress,
+    feeRate,
+    network,
+  } = props;
+  const [running, setRunning] = useState(false);
+  const [commitTransactionId, setCommitTransactionId] = useState<string | undefined>();
+  const [revealTransactionId, setRevealTransactionId] = useState<string | undefined>();
+  const [transferTransactionId, setTransferTransactionId] = useState<string | undefined>();
+  const [progress, setProgress] = useState<ExecuteTransferProgressCodes | undefined>();
+  const [errorCode, setErrorCode] = useState<ErrorCode | undefined>();
+
+  const executeTransfer = useCallback(() => {
+    if (running || !!transferTransactionId) return;
+
+    const innerProps = {
+      seedPhrase,
+      accountIndex,
+      addressUtxos,
+      tick,
+      amount,
+      revealAddress,
+      changeAddress,
+      recipientAddress,
+      feeRate,
+      network,
+    };
+
+    const validationErrorCode = validateProps(innerProps);
+    setErrorCode(validationErrorCode);
+
+    if (validationErrorCode) {
+      return;
+    }
+
+    // if we get to here, that means that the transfer is valid and we can try to execute it but we don't want to
+    // be able to accidentally execute it again if something goes wrong, so we set the running flag
+    setRunning(true);
+
+    const runTransfer = async () => {
+      try {
+        const transferGenerator = await brc20TransferExecute(innerProps);
+
+        let done = false;
+        do {
+          const itt = await transferGenerator.next();
+          done = itt.done ?? false;
+
+          if (done) {
+            const result = itt.value as {
+              revealTransactionId: string;
+              commitTransactionId: string;
+              transferTransactionId: string;
+            };
+            setCommitTransactionId(result.commitTransactionId);
+            setRevealTransactionId(result.revealTransactionId);
+            setTransferTransactionId(result.transferTransactionId);
+            setProgress(undefined);
+          } else {
+            setProgress(itt.value as ExecuteTransferProgressCodes);
+          }
+        } while (!done);
+      } catch (e) {
+        let finalErrorCode: string | undefined;
+        if (CoreError.isCoreError(e)) {
+          finalErrorCode = e.code;
+        }
+
+        switch (finalErrorCode) {
+          case BRC20ErrorCode.FAILED_TO_FINALIZE:
+            setErrorCode(ErrorCode.BROADCAST_FAILED);
+            break;
+          case BRC20ErrorCode.INSUFFICIENT_FUNDS:
+            setErrorCode(ErrorCode.INSUFFICIENT_FUNDS);
+            break;
+          default:
+            setErrorCode(ErrorCode.SERVER_ERROR);
+            break;
+        }
+      }
+    };
+
+    runTransfer();
+  }, [
+    seedPhrase,
+    accountIndex,
+    addressUtxos,
+    tick,
+    amount,
+    revealAddress,
+    changeAddress,
+    recipientAddress,
+    feeRate,
+    network,
+    running,
+    transferTransactionId,
+  ]);
+
+  return {
+    executeTransfer,
+    transferTransactionId,
+    commitTransactionId,
+    revealTransactionId,
+    complete: !!transferTransactionId,
+    progress,
+    errorCode,
+  };
+};
+
+export default useBrc20TransferExecute;

hooks/brc20/useBrc20TransferFees.ts

@@ -0,0 +1,124 @@
+import { useEffect, useState } from 'react';
+
+import { UTXO } from 'types';
+import { brc20TransferEstimateFees } from '../../transactions/brc20';
+
+type CommitValueBreakdown = {
+  commitChainFee: number;
+  revealChainFee: number;
+  revealServiceFee: number;
+  transferChainFee: number;
+  transferUtxoValue: number;
+};
+
+export enum ErrorCode {
+  UTXOS_MISSING = 'UTXOS_MISSING',
+  INSUFFICIENT_FUNDS = 'INSUFFICIENT_FUNDS',
+  INVALID_TICK = 'INVALID_TICK',
+  INVALID_AMOUNT = 'INVALID_AMOUNT',
+  INVALID_FEE_RATE = 'INVALID_FEE_RATE',
+  SERVER_ERROR = 'SERVER_ERROR',
+}
+
+type Props = {
+  addressUtxos: UTXO[] | undefined;
+  tick: string;
+  amount: number;
+  feeRate: number;
+  revealAddress: string;
+};
+
+const validateProps = (props: Props) => {
+  const { addressUtxos, tick, amount, feeRate } = props;
+
+  if (!addressUtxos) {
+    return ErrorCode.UTXOS_MISSING;
+  }
+
+  if (!addressUtxos.length) {
+    return ErrorCode.INSUFFICIENT_FUNDS;
+  }
+
+  if (tick.length !== 4) {
+    return ErrorCode.INVALID_TICK;
+  }
+
+  if (amount <= 0) {
+    return ErrorCode.INVALID_AMOUNT;
+  }
+
+  if (feeRate <= 0) {
+    return ErrorCode.INVALID_FEE_RATE;
+  }
+
+  return null;
+};
+
+/**
+ * Estimates the fees for a BRC-20 1-step transfer
+ * @param addressUtxos - The UTXOs in the bitcoin address which will be used for payment
+ * @param tick - The 4 letter BRC-20 token name
+ * @param amount - The amount of the BRC-20 token to transfer
+ * @param feeRate - The desired fee rate for the transactions
+ * @param revealAddress - The address where the balance of the BRC-20 token lives. This is usually the ordinals address.
+ */
+const useBrc20TransferFees = (props: Props) => {
+  const { addressUtxos, tick, amount, feeRate, revealAddress } = props;
+  const [commitValue, setCommitValue] = useState<number | undefined>();
+  const [commitValueBreakdown, setCommitValueBreakdown] = useState<CommitValueBreakdown | undefined>();
+  const [isInitialised, setIsInitialised] = useState(false);
+  const [isLoading, setIsLoading] = useState(false);
+  const [errorCode, setErrorCode] = useState<ErrorCode | undefined>();
+
+  useEffect(() => {
+    const validationErrorCode = validateProps(props);
+
+    if (validationErrorCode) {
+      setErrorCode(validationErrorCode);
+
+      if (validationErrorCode !== ErrorCode.UTXOS_MISSING) {
+        setIsInitialised(true);
+      }
+
+      return;
+    }
+
+    setIsInitialised(true);
+    setIsLoading(true);
+    setErrorCode(undefined);
+
+    const runEstimate = async () => {
+      try {
+        const result = await brc20TransferEstimateFees({
+          addressUtxos: addressUtxos!,
+          tick,
+          amount,
+          revealAddress,
+          feeRate,
+        });
+        setCommitValue(result.commitValue);
+        setCommitValueBreakdown(result.valueBreakdown);
+      } catch (e) {
+        if (e.message === 'Not enough funds at selected fee rate') {
+          setErrorCode(ErrorCode.INSUFFICIENT_FUNDS);
+        } else {
+          setErrorCode(ErrorCode.SERVER_ERROR);
+        }
+      }
+
+      setIsLoading(false);
+    };
+
+    runEstimate();
+  }, [addressUtxos, tick, amount, revealAddress, feeRate]);
+
+  return {
+    commitValue,
+    commitValueBreakdown,
+    isLoading,
+    errorCode: isInitialised ? errorCode : undefined,
+    isInitialised,
+  };
+};
+
+export default useBrc20TransferFees;

hooks/index.ts

@@ -0,0 +1,2 @@
+export * from './brc20';
+export * from './inscriptions';

hooks/inscriptions/index.ts

@@ -0,0 +1,2 @@
+export { default as useInscriptionExecute } from './useInscriptionExecute';
+export { default as useInscriptionFees } from './useInscriptionFees';