diff --git a/src/App.css b/src/App.css
index 2e4dc00..85d4f74 100644
--- a/src/App.css
+++ b/src/App.css
@@ -192,6 +192,38 @@
   color: #fff;
 }
 
+.fee-toggle {
+  display: inline-flex;
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  overflow: hidden;
+}
+
+.fee-btn {
+  border: none;
+  background: none;
+  padding: 6px 16px;
+  font-size: 13px;
+  font-family: var(--sans);
+  font-weight: 500;
+  cursor: pointer;
+  color: var(--text);
+  transition: background 0.15s, color 0.15s;
+
+  &:not(:last-child) {
+    border-right: 1px solid var(--border);
+  }
+
+  &:hover:not(.fee-btn--active) {
+    background: var(--code-bg);
+  }
+}
+
+.fee-btn--active {
+  background: var(--accent);
+  color: #fff;
+}
+
 .records-list {
   list-style: none;
   padding: 0;
@@ -219,6 +251,14 @@
   white-space: nowrap;
 }
 
+.record-number-label {
+  font-weight: 700;
+  color: var(--text);
+  white-space: nowrap;
+  text-decoration: underline;
+  font-size: 14px;
+}
+
 .record-value {
   font-family: var(--mono);
   color: var(--text-h);
diff --git a/src/App.tsx b/src/App.tsx
index a15ba5d..633841c 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -35,6 +35,7 @@ function App() {
   const [aleoClient, setAleoClient] = useState<AleoClient<'testnet' | 'mainnet'>>(testnetAleoClient);
   const [network, setNetwork] = useState<'testnet' | 'mainnet'>('testnet');
   const [joinStrategy, setJoinStrategy] = useState<joinStrategyName>("basic");
+  const [feePrivate, setFeePrivate] = useState<boolean>(false);
   const [aleoAutoJoin, setAutoJoinClient] = useState<AutoJoinClient | undefined>();
 
   const [privateKeyInput, setPrivateKeyInput] = useState(import.meta.env.VITE_DEFAULT_PKEY || '');
@@ -121,8 +122,8 @@ function App() {
     setError(null);
     setJoinLoading(true);
     try {
-      const newRecord = await aleoAutoJoin.joinRecords(records);
-      setRecords([newRecord]);
+      const newRecords = await aleoAutoJoin.joinRecords(records, feePrivate);
+      setRecords(newRecords);
     } catch (e: unknown) {
       if (e instanceof Error) {
         setError(`Join operation failed: ${e}`);
@@ -233,7 +234,7 @@ function App() {
             onClick={() => {
               setLoading(true);
               setJoinStrategy("basic");
-              setAutoJoinClient(new AutoJoinClient(aleoClient, aleoAccount!, BasicAutoJoinStrategy));
+              setAutoJoinClient(new AutoJoinClient(aleoClient, aleoAccount!, getJoinStrategyClass("basic")));
               setLoading(false);
             }}
           >
@@ -245,13 +246,43 @@ function App() {
             onClick={() => {
               setLoading(true);
               setJoinStrategy("batch");
-              setAutoJoinClient(new AutoJoinClient(aleoClient, aleoAccount!, BatchAutoJoinStrategy));
+              setAutoJoinClient(new AutoJoinClient(aleoClient, aleoAccount!, getJoinStrategyClass("batch")));
               setLoading(false);
             }}
           >
             Batch
           </button>
         </div>
+        <label className="field-label">Fee</label>
+        <div className="fee-toggle">
+          <button
+            type="button"
+            className={`strategy-btn${feePrivate === false ? ' strategy-btn--active' : ''}`}
+            onClick={() => {
+              setFeePrivate(false);
+            }}
+          >
+            Public
+          </button>
+          <button
+            type="button"
+            className={`strategy-btn${feePrivate === true ? ' strategy-btn--active' : ''}`}
+            onClick={() => {
+              setFeePrivate(true);
+            }}
+          >
+            Private
+          </button>
+        </div>
+        {/* {feePrivate && (
+        <div>
+          <label className="field-label">Fee Record (Ciphertext)</label>
+          <div className="input-wrap">
+            <input className="form-input" placeholder='record1...' onChange={e => setPrivateFeeRecord(e.target.value)}/>
+          </div>
+        </div>
+        )} */}
+
         <div className="form-group">
           <label htmlFor="program-name" className="field-label">
             Program Name
@@ -280,10 +311,14 @@ function App() {
             <ul className="records-list">
               {records.map((record, i) => (
                 <li key={i} className="record-item">
+                  <span className="record-number-label">Record #{i+1}:</span>
+                  <span className="record-value"/>
                   <span className="record-label">Amount</span>
                   <span className="record-value">
                     {record.amount === undefined ? "-" : (Number(record.amount) / 1e6).toFixed(6)}
                   </span>
+                  <span className="record-label">Ciphertext</span>
+                  <span className="record-value">{record.cipherText.toString()}</span>
                   <span className="record-label">Tx ID</span>
                   <span className="record-value">{record.transactionId}</span>
                 </li>
diff --git a/src/aleo/aleoClient.ts b/src/aleo/aleoClient.ts
index 28558d6..ad0851f 100644
--- a/src/aleo/aleoClient.ts
+++ b/src/aleo/aleoClient.ts
@@ -158,7 +158,12 @@ export class AleoClient<NetworkKey extends AleoNetwork> {
       unspent: true,
       filter: { programs: programNames },
     });
-    return records.map(r => this.ownedRecordToAleoRecord(r, account));
+
+    // Only return Token (USAD/USDCx) or credits (ALEO) records, not Credentials or any other record type
+    return records
+      .filter(r => (r.record_name === "credits" || r.record_name == "Token"))
+      .map(r =>this.ownedRecordToAleoRecord(r, account))
+      .filter(r => r.amount!=="0");
   }
 
   ownedRecordToAleoRecord(ownedRecord: OwnedRecord, account: Account): AleoRecord {
@@ -221,6 +226,27 @@ export class AleoClient<NetworkKey extends AleoNetwork> {
     });
   }
 
+  /** Calls out to the delegated proving system to submit a request for proving, retrying a number of times if there's an error. **/
+  async submitProvingRequestwithRetries(provingRequest: ProvingRequest, retries: number, attempts?: number): Promise<ProvingResponse> {
+    try {
+      const provingResponse = await this.submitProvingRequest(provingRequest);
+      return provingResponse;
+    } catch (error) {
+      let num_attempts = (attempts ? attempts : 0);
+      if (retries > 0) {
+        await new Promise(res => setTimeout(res, 5000 * (num_attempts+1)));
+        console.log(`Retrying... (${retries} left)`);
+        return this.submitProvingRequestwithRetries(provingRequest, retries - 1,(num_attempts+1));
+      } else {
+          if (error instanceof Error) {
+            throw Error(error.message);
+          } else {
+            throw Error("An unexpected error occurred");
+          }
+      }
+    }
+  }
+
   async submitTransaction(transaction: Transaction, waitForConfirmation: boolean = false) {
     const transactionId = await this.networkClient.submitTransaction(transaction);
     if (waitForConfirmation) {
diff --git a/src/aleo/autojoin/autoJoinClient.ts b/src/aleo/autojoin/autoJoinClient.ts
index 020f043..110507a 100644
--- a/src/aleo/autojoin/autoJoinClient.ts
+++ b/src/aleo/autojoin/autoJoinClient.ts
@@ -35,11 +35,78 @@ export class AutoJoinClient {
     return this.programManager;
   }
 
-  async joinRecords(records: AleoRecord[]): Promise<AleoRecord> {
+  async joinRecords(records: AleoRecord[], feePrivate: boolean): Promise<AleoRecord[]> {
     if (records.length === 0) throw new Error('No records found');
-    if (records.length === 1) return records[0];
+    if (records.length === 1) return [records[0]];
     const joinStrategy = new this.joinStrategyClass(this);
     AutoJoinClient.validateRecordsForJoining(records, joinStrategy);
-    return await joinStrategy.joinRecords(records);
+    return await joinStrategy.joinRecords(records, feePrivate);
+  }
+
+  async splitCreditsRecord(creditsRecord: AleoRecord, amountInMicrocredits: number): Promise<[AleoRecord, AleoRecord]>{
+    const programManager = await this.getProgramManager();
+    const provingRequest = await programManager.provingRequest({
+      programName: "credits.aleo",
+      functionName: 'split',
+      priorityFee: 0,
+      privateFee: false,
+      inputs: [
+        creditsRecord.plainText.toString(),
+        amountInMicrocredits.toString() + "u64"
+      ],
+      broadcast: true,
+    });
+    const {transaction, broadcast_result} = await this.aleoClient.submitProvingRequestwithRetries(provingRequest,3);
+    if (broadcast_result?.status !== "Accepted") throw new Error(`Broadcast status not accepted: ${JSON.stringify(broadcast_result)}`);
+    const transactionId = transaction?.id;
+    if (!transactionId) throw new Error(`Transaction invalid: ${transaction}`);
+
+    const firstOutput = transaction.execution?.transitions?.[0]?.outputs?.[0];
+    if (!firstOutput?.value) throw new Error('No output record 1 in split transaction');
+    let newRecord = this.aleoClient.recordCipherTextStringToAleoRecord(
+      firstOutput.value,
+      this.account,
+      "credits.aleo",
+      transaction.id.trim(),
+    );
+
+    const secondOutput = transaction.execution?.transitions?.[0]?.outputs?.[1];
+    if (!secondOutput?.value) throw new Error('No output record 2 in split transaction');
+    let change  = this.aleoClient.recordCipherTextStringToAleoRecord(
+      secondOutput.value,
+      this.account,
+      "credits.aleo",
+      transaction.id.trim(),
+    );
+    
+    return [newRecord, change];
+  }
+
+  async generateMasterFeeRecord(creditsRecords: AleoRecord[], totalCostInMicrocredits: number): Promise<[AleoRecord[],AleoRecord]> {
+    // Sort credits records in ascending order of value
+    creditsRecords.sort((r1, r2) => Number(r1.amount) - Number(r2.amount!));
+    for (let i: number = 0; i < creditsRecords.length; i++) {
+      // Find the first (smallest balance) credits record that is enough to cover the total cost of fees
+      if (Number(creditsRecords[i].amount) >= totalCostInMicrocredits){
+        let [newRecord, change] = await this.splitCreditsRecord(creditsRecords[i], totalCostInMicrocredits);
+        creditsRecords.splice(i,1);
+        creditsRecords.push(change);
+        return [creditsRecords, newRecord];;
+      }
+    }
+
+    throw Error("No records with large enough balance to pay for gas fees.");
+  }
+
+  async generateFeeRecords(creditsRecord: AleoRecord, numberOfRecordsNeeded: number, amountPerRecord: number): Promise<[AleoRecord[],AleoRecord]> {
+    let leftovers: AleoRecord = creditsRecord;
+    let feeRecords: AleoRecord[] = [];
+
+    for (let i: number = 0; i < numberOfRecordsNeeded; i++) {
+      let [newRecord, change] = await this.splitCreditsRecord(leftovers, amountPerRecord);
+      feeRecords.push(newRecord);
+      leftovers = change
+    }
+    return [feeRecords,leftovers];
   }
 }
diff --git a/src/aleo/autojoin/joinStrategy.ts b/src/aleo/autojoin/joinStrategy.ts
index 19eea9f..186a87b 100644
--- a/src/aleo/autojoin/joinStrategy.ts
+++ b/src/aleo/autojoin/joinStrategy.ts
@@ -2,7 +2,7 @@ import type {AutoJoinClient} from "./autoJoinClient.ts";
 import type {AleoRecord} from "../aleoClient.ts";
 
 export interface JoinStrategy {
-  joinRecords(records: AleoRecord[]): Promise<AleoRecord>;
+  joinRecords(records: AleoRecord[], feePrivate: boolean): Promise<AleoRecord[]>;
   isSupportedProgram(programName: string): boolean;
 }
 
diff --git a/src/aleo/autojoin/strategies/basicAutoJoinStrategy.ts b/src/aleo/autojoin/strategies/basicAutoJoinStrategy.ts
index 3401548..4b166cc 100644
--- a/src/aleo/autojoin/strategies/basicAutoJoinStrategy.ts
+++ b/src/aleo/autojoin/strategies/basicAutoJoinStrategy.ts
@@ -25,59 +25,106 @@ export class BasicAutoJoinStrategy implements JoinStrategy {
     return this.supportedPrograms.includes(programName.trim().toLowerCase());
   }
 
-  async joinRecords(records: AleoRecord[]): Promise<AleoRecord> {
+
+  async joinRecords(records: AleoRecord[], feePrivate: boolean): Promise<AleoRecord[]> {
     if (records.length === 0) throw new Error('No records found');
-    if (records.length === 1) return records[0];
+    if (records.length === 1) return [records[0]];
     let current = records;
+    const programManager = await this.autoJoinClient.getProgramManager();
+
+    if (feePrivate) {
+      // Determine number of join operations needed and the cost for each operation
+      const totalJoinOps = current.length - 1;
+      const joinCostInMicrocredits = Number(await programManager.estimateExecutionFee({
+        programName: records[0].programName,
+        functionName: "join",
+      }));
+      const totalCostInMicrocredits = (joinCostInMicrocredits + 10000) * totalJoinOps;
 
-    while (current.length > 1) {
-      // Pair up records, potentially leaving the last one unpaired
-      const pairs: [AleoRecord, AleoRecord][] = [];
-      for (let i = 0; i + 1 < current.length; i += 2) {
-        pairs.push([current[i], current[i + 1]]);
+      // Fetch the list of available Aleo Credits records (if joining USDCx / USAD)
+      let creditsRecords = (records[0].programName) === "credits.aleo" ? records : await this.autoJoinClient.aleoClient.fetchUnspentRecords(this.autoJoinClient.account, ["credits.aleo"], this.autoJoinClient.accountAddress);
+      // Find a large enough record, split into a master fee record, then split that into the individual fee reocrds      
+      let [leftoverCreditsRecords, masterFeeRecord] = await this.autoJoinClient.generateMasterFeeRecord(creditsRecords,totalCostInMicrocredits);
+      let [feeRecords, remainder] = await this.autoJoinClient.generateFeeRecords(masterFeeRecord, totalJoinOps, joinCostInMicrocredits);
+      if (records[0].programName === "credits.aleo") {
+        current = leftoverCreditsRecords;
+        current.push(remainder);
       }
+      
+      while (current.length > 1) {
+        // Greedily pair up records with a private fee, potentially leaving the last one unpaired
+        const triplets: [AleoRecord, AleoRecord, AleoRecord][] = [];
+        for (let i = 0; i + 1 < current.length; i += 2) {
+          triplets.push([current[i], current[i + 1], feeRecords.pop()!]);
+        }
+        const joinedRecords = await Promise.all(triplets.map(async ([a, b, fee]) => {
+          const {transactionId, newRecord} = await this.join2(a, b, fee);
+          await this.autoJoinClient.aleoClient.waitForTransactionConfirmation(transactionId);
+          return newRecord;
+        }));
 
-      const joinedRecords = await Promise.all(pairs.map(async ([a, b]) => {
-        const {transactionId, newRecord} = await this.join2(a, b);
-        await this.autoJoinClient.aleoClient.waitForTransactionConfirmation(transactionId);
-        return newRecord;
-      }));
+        if (triplets.length * 2 < current.length) {
+          current = joinedRecords.concat(current[current.length - 1]);
+        } else {
+          current = joinedRecords;
+        }
+      }
+      return [current[0]]; 
 
-      if (pairs.length * 2 < current.length) {
-        current = joinedRecords.concat(current[current.length - 1]);
-      } else {
-        current = joinedRecords;
+    } else {
+      while (current.length > 1) {
+        // Greedily pair up records, potentially leaving the last one unpaired
+        const pairs: [AleoRecord, AleoRecord][] = [];
+        for (let i = 0; i + 1 < current.length; i += 2) {
+          pairs.push([current[i], current[i + 1]]);
+        }
+
+        const joinedRecords = await Promise.all(pairs.map(async ([a, b]) => {
+          const {transactionId, newRecord} = await this.join2(a, b);
+          await this.autoJoinClient.aleoClient.waitForTransactionConfirmation(transactionId);
+          return newRecord;
+        }));
+
+        if (pairs.length * 2 < current.length) {
+          current = joinedRecords.concat(current[current.length - 1]);
+        } else {
+          current = joinedRecords;
+        }
       }
+    return [current[0]];
     }
-
-    return current[0];
   }
 
-  private async join2(recordA: AleoRecord, recordB: AleoRecord): Promise<{transactionId: string, newRecord: AleoRecord}> {
+  private async join2(recordA: AleoRecord, recordB: AleoRecord, privateFeeRecord?: AleoRecord): Promise<{transactionId: string, newRecord: AleoRecord}> {
     const programManager = await this.autoJoinClient.getProgramManager();
     const provingRequest = await programManager.provingRequest({
       programName: recordA.programName,
       functionName: 'join',
       priorityFee: 0,
-      privateFee: false,
+      privateFee: (privateFeeRecord ? true : false),
+      feeRecord: privateFeeRecord?.plainText,
       inputs: [
         recordA.plainText.toString(),
         recordB.plainText.toString(),
       ],
       broadcast: true,
     });
-    const {transaction, broadcast_result} = await this.autoJoinClient.aleoClient.submitProvingRequest(provingRequest);
+    const {transaction, broadcast_result} = await this.autoJoinClient.aleoClient.submitProvingRequestwithRetries(provingRequest,3);
     if (broadcast_result?.status !== "Accepted") throw new Error(`Broadcast status not accepted: ${JSON.stringify(broadcast_result)}`);
+    
     const transactionId = transaction?.id;
     if (!transactionId) throw new Error(`Transaction invalid: ${transaction}`);
+    
     const firstOutput = transaction.execution?.transitions?.[0]?.outputs?.[0];
     if (!firstOutput?.value) throw new Error('No output record in join transaction');
+
     const newRecord = this.autoJoinClient.aleoClient.recordCipherTextStringToAleoRecord(
       firstOutput.value,
       this.autoJoinClient.account,
       recordA.programName,
       transaction.id.trim(),
     );
+
     return {transactionId, newRecord};
   }
 }
\ No newline at end of file
diff --git a/src/aleo/autojoin/strategies/batchAutoJoinStrategy.ts b/src/aleo/autojoin/strategies/batchAutoJoinStrategy.ts
index 7ec5fa3..c21d585 100644
--- a/src/aleo/autojoin/strategies/batchAutoJoinStrategy.ts
+++ b/src/aleo/autojoin/strategies/batchAutoJoinStrategy.ts
@@ -54,41 +54,95 @@ export class BatchAutoJoinStrategy implements JoinStrategy {
     return `${prefix}_${programName.split(".")[0]}_${suffix}.aleo`;
   }
 
-  async joinRecords(records: AleoRecord[]): Promise<AleoRecord> {
+  async joinRecords(records: AleoRecord[], feePrivate: boolean): Promise<AleoRecord[]> {
     if (records.length === 0) throw new Error('No records found');
-    if (records.length === 1) return records[0];
+    if (records.length === 1) return [records[0]];
     let current = records;
 
-    while (current.length > 1) {
-      const batches: AleoRecord[][] = [];
-      while (current.length > 0) {
-        batches.push(current.splice(0, Math.min(current.length, 16)));
+    if (feePrivate) {
+      // Determine number of join operations needed and the cost for each operation
+      // NOTE: the largest function that can be called with a private fee is join_15 (not join_16),
+      // as the max number of record inputs for a TX is 16, and the fee record counts as one
+      const programManager = await this.autoJoinClient.getProgramManager();
+      const totalJoin15Ops = Math.floor((records.length - 1) / 14);
+      const finalJoinNFunction = `join_${((records.length - 1) % 14) + 1}`;
+      const join15CostInMicrocredits = Number(await programManager.estimateExecutionFee({
+        programName: this.getBatchProgram(records[0].programName, 15),
+        functionName: `join_15`,
+      }));
+      const joinNCostInMicrocredits = Number(await programManager.estimateExecutionFee({
+        programName: this.getBatchProgram(records[0].programName, ((records.length - 1) % 14)+1),
+        functionName: finalJoinNFunction
+      }));
+      const totalCostInMicrocredits = totalJoin15Ops * (join15CostInMicrocredits + 10000) + joinNCostInMicrocredits;
+
+      // Fetch the list of available Aleo Credits records (if joining USDCx / USAD)
+      let creditsRecords = (records[0].programName) === "credits.aleo" ? records : await this.autoJoinClient.aleoClient.fetchUnspentRecords(this.autoJoinClient.account, ["credits.aleo"], this.autoJoinClient.accountAddress);
+      // Find a large enough record, split into a master fee record, then split that into the individual fee reocrds
+      let [leftoverCreditsRecords, masterFeeRecord] = await this.autoJoinClient.generateMasterFeeRecord(creditsRecords,totalCostInMicrocredits);
+      let [join15FeeRecords, joinNFeeRecord] = await this.autoJoinClient.generateFeeRecords(masterFeeRecord, totalJoin15Ops, join15CostInMicrocredits);
+      if (records[0].programName === "credits.aleo") {
+        current = leftoverCreditsRecords;
+      }
+      // Sanity Check
+      if (Number(joinNFeeRecord.amount) !== joinNCostInMicrocredits) {
+        throw Error("Error with fee calculations");
+      }
+
+      // Batch up records into groups of 15 along with a fee record, potentially leaving some amount < (15 - totalJoin15Ops) unbatched
+      const batches: [AleoRecord[],AleoRecord][] = [];
+      for (let i: number = 0; i < totalJoin15Ops; i++) {
+        batches.push([current.splice(0, 15),join15FeeRecords.pop()!]);
       }
 
-      const joinedRecords = await Promise.all(batches.map(async (batch) => {
-        const { transactionId, newRecord } = await this.joinN(batch);
+      // Join all the batches of records
+      const intermediateRecords = await Promise.all(batches.map(async ([batch,fee]) => {
+        const { transactionId, newRecord } = await this.joinN(batch,fee);
         await this.autoJoinClient.aleoClient.waitForTransactionConfirmation(transactionId);
         return newRecord;
       }));
+      current = current.concat(intermediateRecords);
 
-      current = current.concat(joinedRecords);
-    }
+      // Perform the final join_N with the results of the intermediate join and the originally unbatched records
+      const { transactionId, newRecord } = await this.joinN(current, joinNFeeRecord);
+      await this.autoJoinClient.aleoClient.waitForTransactionConfirmation(transactionId);
+
+      return [newRecord]; 
+    } else {
+      while (current.length > 1) {
+        // Greedily up records into groups of 16, with a final group of potentially less than 16
+        const batches: AleoRecord[][] = [];
+        while (current.length > 0) {
+          batches.push(current.splice(0, Math.min(current.length, 16)));
+        }
+
+        // Join all the batches of records
+        const joinedRecords = await Promise.all(batches.map(async (batch) => {
+          const { transactionId, newRecord } = await this.joinN(batch);
+          await this.autoJoinClient.aleoClient.waitForTransactionConfirmation(transactionId);
+          return newRecord;
+        }));
 
-    return current[0];
+        current = current.concat(joinedRecords);
+      }
+
+      return [current[0]];
+    }
   }
 
-private async joinN(records: AleoRecord[]) :Promise<{transactionId: string, newRecord: AleoRecord}> {
+  private async joinN(records: AleoRecord[], privateFeeRecord?: AleoRecord) :Promise<{transactionId: string, newRecord: AleoRecord}> {
     const programManager = await this.autoJoinClient.getProgramManager();
     const provingRequest = await programManager.provingRequest({
       programName: this.getBatchProgram(records[0].programName, records.length),
       functionName: `join_${records.length}`,
       priorityFee: 0,
-      privateFee: false,
+      privateFee: (privateFeeRecord ? true : false),
+      feeRecord: privateFeeRecord?.plainText,
       inputs: records.map(r => r.plainText.toString()),
       broadcast: true,
     });
 
-    const {transaction, broadcast_result} = await this.autoJoinClient.aleoClient.submitProvingRequest(provingRequest);
+    const {transaction, broadcast_result} = await this.autoJoinClient.aleoClient.submitProvingRequestwithRetries(provingRequest,3);
     if (broadcast_result?.status !== "Accepted") throw new Error(`Broadcast status not accepted: ${JSON.stringify(broadcast_result)}`);
 
     const transactionId = transaction?.id;