fix: add default stx faucet tx fee if estimate not available (#1456)

* test: add integration test for stx faucet requests

* fix: add default stx faucet tx fee if estimate not available

* ci: disable generated doc type file test for now

Author: zone117x

.github/workflows/ci.yml

@@ -86,8 +86,8 @@ jobs:
       - name: Build schema & docs
         run: npm run build
 
-      - name: Validate generated types
-        run: tsc index.d.ts
+      # - name: Validate generated types
+      #   run: npm run validate:types
 
       - name: Lint JSON
         run: npm run lint:json
@@ -349,6 +349,7 @@ jobs:
     strategy:
       matrix:
         suite: [
+          faucet-stx,
           pox-2-auto-unlock,
           pox-2-btc-address-formats,
           pox-2-delegate-aggregation,

src/api/routes/faucets.ts

@@ -4,7 +4,12 @@ import { asyncHandler } from '../async-handler';
 import * as btc from 'bitcoinjs-lib';
 import PQueue from 'p-queue';
 import { BigNumber } from 'bignumber.js';
-import { AnchorMode, makeSTXTokenTransfer, SignedTokenTransferOptions } from '@stacks/transactions';
+import {
+  AnchorMode,
+  makeSTXTokenTransfer,
+  SignedTokenTransferOptions,
+  StacksTransaction,
+} from '@stacks/transactions';
 import { StacksNetwork, StacksTestnet } from '@stacks/network';
 import { makeBtcFaucetPayment, getBtcBalance } from '../../btc-faucet';
 import { DbFaucetRequestCurrency } from '../../datastore/common';
@@ -183,7 +188,11 @@ export function createFaucetRouter(db: PgWriteStore): express.Router {
         }
         const stxAmount = intMax(stxAmounts);
 
-        const generateTx = async (network: StacksNetwork, nonce?: bigint, fee?: bigint) => {
+        const generateTx = async (
+          network: StacksNetwork,
+          nonce?: bigint,
+          fee?: bigint
+        ): Promise<StacksTransaction> => {
           const txOpts: SignedTokenTransferOptions = {
             recipient: address,
             amount: stxAmount,
@@ -198,7 +207,15 @@ export function createFaucetRouter(db: PgWriteStore): express.Router {
           if (nonce !== undefined) {
             txOpts.nonce = nonce;
           }
-          return await makeSTXTokenTransfer(txOpts);
+          try {
+            return await makeSTXTokenTransfer(txOpts);
+          } catch (error: any) {
+            if (fee === undefined && (error as Error).message?.includes('NoEstimateAvailable')) {
+              const defaultFee = 200n;
+              return await generateTx(network, nonce, defaultFee);
+            }
+            throw error;
+          }
         };
 
         const nonces: bigint[] = [];

src/tests-2.1/env-setup.ts

@@ -27,7 +27,7 @@ beforeAll(async () => {
   process.env.STACKS_CHAIN_ID = '0x80000000';
 
   const db = await PgWriteStore.connect({ usageName: 'tests' });
-  const api = await startApiServer({ datastore: db, chainId: ChainID.Testnet });
+  const api = await startApiServer({ datastore: db, writeDatastore: db, chainId: ChainID.Testnet });
   const client = new StacksCoreRpcClient();
   const stacksNetwork = new StacksTestnet({ url: `http://${client.endpoint}` });
 

src/tests-2.1/faucet-stx.ts

@@ -0,0 +1,43 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { Account, accountFromKey, fetchGet, standByForTxSuccess, testEnv } from './test-helpers';
+import { AddressStxBalanceResponse } from 'docs/generated';
+import * as supertest from 'supertest';
+import { RunFaucetResponse } from '@stacks/stacks-blockchain-api-types';
+
+describe('STX Faucet', () => {
+  const reqAccountKey = 'b1ee37d996b1cf95ff67996a38426cff398d3adfeccf8ae8b3651a530837dd5801';
+  let reqAccount: Account;
+  let reqTx: RunFaucetResponse;
+
+  beforeAll(() => {
+    reqAccount = accountFromKey(reqAccountKey);
+  });
+
+  test('STX faucet http request succeeds', async () => {
+    const response = await supertest(testEnv.api.server).post(
+      `/extended/v1/faucets/stx?address=${reqAccount.stxAddr}`
+    );
+    expect(response.status).toBe(200);
+    reqTx = response.body;
+    expect(typeof reqTx.txId).toBe('string');
+    expect(typeof reqTx.txRaw).toBe('string');
+    expect(reqTx.success).toBe(true);
+  });
+
+  test('STX faucet tx mined successfully', async () => {
+    const tx = await standByForTxSuccess(reqTx.txId!);
+    expect(tx.token_transfer_recipient_address).toBe(reqAccount.stxAddr);
+  });
+
+  test('STX faucet recipient balance', async () => {
+    // Validate account has balance from API endpoint
+    const addrBalance = await fetchGet<AddressStxBalanceResponse>(
+      `/extended/v1/address/${reqAccount.stxAddr}/stx`
+    );
+    expect(BigInt(addrBalance.balance)).toBeGreaterThan(0n);
+
+    // Validate account has balance from RPC endpoint
+    const coreBalance = await testEnv.client.getAccount(reqAccount.stxAddr);
+    expect(BigInt(coreBalance.balance)).toBeGreaterThan(0n);
+  });
+});