From 1be326af96546c24499620debc7f51f3b1c9cd5c Mon Sep 17 00:00:00 2001
From: Denis Nebytov <nebytov.d@gmail.com>
Date: Mon, 24 Aug 2026 13:25:10 +0300
Subject: [PATCH 1/2] Mint token batches across chained transactions.

Wire planning and CSL mint helpers into TokenTab, including CIP-68 on the last token and progress for each signed chunk.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 src/components/tabs/subtabs/tokenTab.js | 266 ++++++++++++++++--------
 src/utils/tokenBatchMint.js             | 148 +++++++++++++
 2 files changed, 324 insertions(+), 90 deletions(-)
 create mode 100644 src/utils/tokenBatchMint.js

diff --git a/src/components/tabs/subtabs/tokenTab.js b/src/components/tabs/subtabs/tokenTab.js
index f8bdba7..5c10b19 100644
--- a/src/components/tabs/subtabs/tokenTab.js
+++ b/src/components/tabs/subtabs/tokenTab.js
@@ -1,21 +1,11 @@
 import logger from '../../../utils/logger'
-import {useState} from 'react'
+import {useMemo, useState} from 'react'
 import useCardano from '../../../hooks/cardanoProvider'
-import {
-  getAddressFromBytes,
-  getAssetName,
-  getCslUtxos,
-  getFixedTxFromBytes,
-  getLargestFirstMultiAsset,
-  getNativeScript,
-  getPubKeyHash,
-  getTransactionOutputBuilder,
-  getTransactionWitnessSetFromBytes,
-  getTxBuilder,
-  toInt,
-} from '../../../utils/cslTools'
+import {getTransactionWitnessSetFromBytes} from '../../../utils/cslTools'
 import {CONNECTED} from '../../../utils/connectionStates'
 import {firstOrThrow} from '../../../utils/helpFunctions'
+import {MAX_BATCH_SIZE, planTokenBatch} from '../../../utils/tokenBatchPlan'
+import {buildBatchChunkTx, chainUtxosAfterTx} from '../../../utils/tokenBatchMint'
 import InputWithLabel from '../../inputWithLabel'
 
 const TokenTab = () => {
@@ -24,10 +14,15 @@ const TokenTab = () => {
   const [currentTokenTicker, setCurrentTokenTicker] = useState('')
   const [currentTokenDescription, setCurrentTokenDescription] = useState('')
   const [currentQuantity, setCurrentQuantity] = useState('10')
+  const [isBatch, setIsBatch] = useState(false)
+  const [batchSize, setBatchSize] = useState('1')
+  const [cip68LastToken, setCip68LastToken] = useState(false)
   const [currentErrorState, setCurrentErrorState] = useState(false)
   const [signingRejected, setSigningRejected] = useState(false)
-  const [tokenNameErrorState, setTokenNameErrorState] = useState(false)
-  const [tokenQuantityErrorState, setTokenQuantityErrorState] = useState(false)
+  const [validationError, setValidationError] = useState('')
+  const [isMinting, setIsMinting] = useState(false)
+  const [batchStatus, setBatchStatus] = useState('')
+  const [submittedTxIds, setSubmittedTxIds] = useState([])
 
   const handleError = (errorObject) => {
     if (errorObject.code === 2) {
@@ -41,14 +36,9 @@ const TokenTab = () => {
     }, 5000)
   }
 
-  const handleEmptyTokenName = () => {
-    setTokenNameErrorState(true)
-    setTimeout(() => setTokenNameErrorState(false), 5000)
-  }
-
-  const handleEmptyTokenQuantity = () => {
-    setTokenQuantityErrorState(true)
-    setTimeout(() => setTokenQuantityErrorState(false), 5000)
+  const handleValidationError = (message) => {
+    setValidationError(message)
+    setTimeout(() => setValidationError(''), 5000)
   }
 
   const handleErrors = () => {
@@ -64,93 +54,116 @@ const TokenTab = () => {
           <p /> !!! The error appeared. Please check logs !!!
         </div>
       )
-    } else if (tokenNameErrorState) {
-      return (
-        <div className="text-red-500 text-2xl font-bold text-center">
-          <p /> !!! The token name is not suitable !!!
-        </div>
-      )
-    } else if (tokenQuantityErrorState) {
-      return (
-        <div className="text-red-500 text-2xl font-bold text-center">
-          <p /> !!! The token quantity is not suitable !!!
-        </div>
-      )
+    } else if (validationError) {
+      return <div className="text-red-500 text-xl font-bold text-center">{validationError}</div>
     } else {
       return <></>
     }
   }
 
-  const mintToken = async () => {
-    const clearTokenName = currentTokenName.trim()
-    if (clearTokenName.length === 0) {
-      handleEmptyTokenName()
-      logger.error("The token name shouldn't be empty")
-      return
+  // Live preview of how the entered batch will be split, or the reason it
+  // cannot be minted. Reporting the reason while typing matters: the limits
+  // depend on the other fields (a CIP-68 asset name loses 4 bytes to its label
+  // prefix), so a name that is fine on its own can become invalid when the
+  // batch size grows or CIP-68 is ticked.
+  const batchPreview = useMemo(() => {
+    // An untouched form is not an error to shout about — pressing Mint reports it.
+    if (currentTokenName.trim().length === 0) {
+      return {}
     }
-
-    if (currentQuantity === '0') {
-      handleEmptyTokenQuantity()
-      logger.error("The token quantity isn't suitable")
-      return
+    try {
+      const {tokens, chunks, maxPerTx} = planTokenBatch({
+        tokenName: currentTokenName,
+        ticker: currentTokenTicker,
+        description: currentTokenDescription,
+        quantity: currentQuantity,
+        isBatch,
+        batchSize,
+        cip68LastToken,
+      })
+      return {tokenCount: tokens.length, txCount: chunks.length, maxPerTx, firstName: tokens[0].assetName}
+    } catch (error) {
+      return {error: error.message}
     }
-    let quantityInt = 0
+  }, [
+    currentTokenName,
+    currentTokenTicker,
+    currentTokenDescription,
+    currentQuantity,
+    isBatch,
+    batchSize,
+    cip68LastToken,
+  ])
+
+  const mintTokens = async () => {
+    setValidationError('')
+    setSubmittedTxIds([])
+    setBatchStatus('')
+
+    let plan
     try {
-      quantityInt = toInt(currentQuantity)
+      plan = planTokenBatch({
+        tokenName: currentTokenName,
+        ticker: currentTokenTicker,
+        description: currentTokenDescription,
+        quantity: currentQuantity,
+        isBatch,
+        batchSize,
+        cip68LastToken,
+      })
     } catch (error) {
-      handleEmptyTokenQuantity()
+      handleValidationError(error.message)
       logger.error(error)
       return
     }
 
-    const txBuilder = getTxBuilder()
-
-    const changeAddress = await api?.getChangeAddress()
-    logger.debug(`[dApp][Tokens_Tab][mint] changeAddress -> ${changeAddress}`)
+    logger.debug(
+      `[TokenTab][mint] ${plan.tokens.length} token(s) in ${plan.chunks.length} tx(s), max ${plan.maxPerTx} per tx`,
+    )
 
-    const wasmChangeAddress = getAddressFromBytes(changeAddress)
+    setIsMinting(true)
     try {
+      const changeAddressHex = await api?.getChangeAddress()
       const usedAddresses = await api?.getUsedAddresses()
-      const usedAddress = getAddressFromBytes(firstOrThrow(usedAddresses, 'No used address available from wallet'))
-      const pubkeyHash = getPubKeyHash(usedAddress)
-      const wasmNativeScript = getNativeScript(pubkeyHash)
+      const usedAddressHex = firstOrThrow(usedAddresses, 'No used address available from wallet')
+      let hexUtxos = await api?.getUtxos()
 
-      // magic should happen here
-      txBuilder.add_mint_asset_and_output_min_required_coin(
-        wasmNativeScript,
-        getAssetName(clearTokenName),
-        quantityInt,
-        getTransactionOutputBuilder(wasmChangeAddress),
-      )
-
-      logger.debug(`[TokenTab][mint] getting UTxOs`)
-      const hexInputUtxos = await api?.getUtxos()
+      for (const [index, chunk] of plan.chunks.entries()) {
+        const progress = `transaction ${index + 1} of ${plan.chunks.length}`
+        setBatchStatus(`Building ${progress} (${chunk.length} token(s))...`)
+        const {fixedTx, explicitOutputCount} = buildBatchChunkTx({
+          chunk,
+          hexUtxos,
+          changeAddressHex,
+          usedAddressHex,
+        })
+        logger.log(`[TokenTab][mint] Unsigned Tx (${progress}):`, fixedTx.to_hex())
 
-      logger.debug(`[TokenTab][mint] preparing wasmUTxOs`)
-      const wasmUtxos = getCslUtxos(hexInputUtxos)
+        setBatchStatus(`Waiting for signature - ${progress}...`)
+        const witnessHex = await api?.signTx(fixedTx.to_hex())
+        const vkeys = getTransactionWitnessSetFromBytes(witnessHex).vkeys()
+        for (let i = 0; i < vkeys.len(); i++) {
+          fixedTx.add_vkey_witness(vkeys.get(i))
+        }
+        const signedTxHex = fixedTx.to_hex()
+        logger.log(`[TokenTab][mint] Signed Tx (${progress}):`, signedTxHex)
 
-      logger.debug(`[TokenTab][mint] adding inputs`)
-      txBuilder.add_inputs_from(wasmUtxos, getLargestFirstMultiAsset())
-      txBuilder.add_required_signer(pubkeyHash)
-      txBuilder.add_change_if_needed(wasmChangeAddress)
+        setBatchStatus(`Submitting ${progress}...`)
+        const txId = await api?.submitTx(signedTxHex)
+        logger.log(`[TokenTab][mint] Transaction successfully submitted: ${txId}`)
+        setSubmittedTxIds((previous) => [...previous, txId])
 
-      const wasmUnsignedTransaction = txBuilder.build_tx()
-      const fixedTx = getFixedTxFromBytes(wasmUnsignedTransaction.to_bytes())
-      logger.log('[TokenTab] Unsigned Tx:', fixedTx.to_hex())
-      logger.debug(`[TokenTab][mint] signing the tx`)
-      const witnessHex = await api?.signTx(fixedTx.to_hex())
-      const wasmWitnessSet = getTransactionWitnessSetFromBytes(witnessHex)
-      const vkeys = wasmWitnessSet.vkeys()
-      for (let i = 0; i < vkeys.len(); i++) {
-        fixedTx.add_vkey_witness(vkeys.get(i))
+        // Chain forward: the wallet still reports the spent UTxOs until this tx
+        // is confirmed, so the next chunk must build on a locally updated set.
+        hexUtxos = chainUtxosAfterTx({fixedTx, hexUtxos, explicitOutputCount})
       }
-      const signedTxHex = fixedTx.to_hex()
-      logger.log('[TokenTab][mint] Signed Tx:', signedTxHex)
-      const txId = await api?.submitTx(signedTxHex)
-      logger.log(`[TokenTab][mint] Transaction successfully submitted: ${txId}`)
+      setBatchStatus(`Done - ${plan.tokens.length} token(s) minted in ${plan.chunks.length} transaction(s).`)
     } catch (error) {
+      setBatchStatus('Stopped - see the error above and the logs.')
       handleError(error)
       logger.error(error)
+    } finally {
+      setIsMinting(false)
     }
   }
 
@@ -168,6 +181,9 @@ const TokenTab = () => {
                 The minting policy is hardcoded to basically just use the pubkeyhash of your first used address, so all
                 the tokens you mint here will have the same policy id.
                 <p />
+                Ticker and description are written as CIP-25 (label 721) metadata. A batch is minted into a single
+                pooled output per transaction, and is split across several transactions when it does not fit into one.
+                <p />
                 {handleErrors()}
               </div>
             </div>
@@ -201,22 +217,92 @@ const TokenTab = () => {
                   <InputWithLabel
                     inputName="Token Quantity"
                     type="number"
+                    min={1}
                     inputValue={currentQuantity}
                     onChangeFunction={(event) => {
                       setCurrentQuantity(event.target.value)
                     }}
                   />
+                  <div className="text-l tracking-tight text-gray-300 mt-3">
+                    <input
+                      type="checkbox"
+                      id="isBatch"
+                      name="batchCheckbox"
+                      checked={isBatch}
+                      onChange={() => setIsBatch(!isBatch)}
+                    />
+                    <label htmlFor="isBatch" className="font-bold">
+                      <span /> Generate batch of different tokens
+                    </label>
+                    {isBatch ? (
+                      <InputWithLabel
+                        inputName="Number Of Tokens"
+                        type="number"
+                        min={1}
+                        inputValue={batchSize}
+                        onChangeFunction={(event) => setBatchSize(event.target.value)}
+                        helpText={
+                          batchPreview.tokenCount
+                            ? `${batchPreview.tokenCount} token(s) starting at "${batchPreview.firstName}" - about ` +
+                              `${batchPreview.maxPerTx} fit per transaction, so this needs ${batchPreview.txCount} ` +
+                              `transaction(s) and ${batchPreview.txCount} signature(s). Max ${MAX_BATCH_SIZE}.`
+                            : `Each token gets its index appended: name0, ticker0, "... Token 0.". Max ${MAX_BATCH_SIZE}.`
+                        }
+                      />
+                    ) : (
+                      <></>
+                    )}
+                  </div>
+                  <div className="text-l tracking-tight text-gray-300 mt-3">
+                    <input
+                      type="checkbox"
+                      id="cip68LastToken"
+                      name="cip68Checkbox"
+                      checked={cip68LastToken}
+                      onChange={() => setCip68LastToken(!cip68LastToken)}
+                    />
+                    <label htmlFor="cip68LastToken" className="font-bold">
+                      <span /> Make the last token a CIP-68 token
+                    </label>
+                    <p /> Mints it as a (333) fungible token plus a (100) reference token whose inline datum carries the
+                    metadata. The reference token is sent to your own change address.
+                  </div>
                 </div>
               </div>
+              {/* Single place for "this batch cannot be minted", shown while
+                  typing rather than only after pressing Mint. */}
+              {batchPreview.error ? (
+                <div className="text-red-500 font-bold text-center pb-3">{batchPreview.error}</div>
+              ) : (
+                <></>
+              )}
               <div className="flex pb-5">
                 <button
                   type="button"
-                  className="text-white font-medium text-base rounded-lg w-full px-5 py-2.5 text-center bg-blue-600 hover:bg-blue-700 focus:ring-blue-800"
-                  onClick={mintToken}
+                  className="text-white font-medium text-base rounded-lg w-full px-5 py-2.5 text-center bg-blue-600 hover:bg-blue-700 focus:ring-blue-800 disabled:bg-gray-600"
+                  onClick={mintTokens}
+                  disabled={isMinting || Boolean(batchPreview.error)}
                 >
-                  Mint
+                  {isMinting ? 'Minting...' : 'Mint'}
                 </button>
               </div>
+              {batchStatus ? <div className="text-white text-center">{batchStatus}</div> : <></>}
+              {submittedTxIds.length > 0 ? (
+                <div className="mt-3">
+                  <label htmlFor="submittedTxIds" className="block mb-2 text-sm font-medium text-gray-300">
+                    Submitted Transactions
+                  </label>
+                  <textarea
+                    className="w-full rounded bg-gray-900 text-white px-2 readonly"
+                    rows="5"
+                    id="submittedTxIds"
+                    readOnly
+                    value={submittedTxIds.join('\n')}
+                  />
+                </div>
+              ) : (
+                <></>
+              )}
             </div>
           </div>
         </>
diff --git a/src/utils/tokenBatchMint.js b/src/utils/tokenBatchMint.js
new file mode 100644
index 0000000..39f56a6
--- /dev/null
+++ b/src/utils/tokenBatchMint.js
@@ -0,0 +1,148 @@
+import {Buffer} from 'buffer'
+import logger from './logger'
+import {
+  buildAssetOutputWithMinCoin,
+  getAddressFromBytes,
+  getAssetName,
+  getAssetNameFromHex,
+  getCip68Datum,
+  getCslUtxos,
+  getFixedTxFromBytes,
+  getInputKeysFromBody,
+  getLargestFirstMultiAsset,
+  getMintBuilder,
+  getMultiAssetForPolicy,
+  getNativeScript,
+  getNativeScriptMintWitness,
+  getPubKeyHash,
+  getTxBuilder,
+  getUnspentOutputHex,
+  getUtxoFromHex,
+  strToBigNum,
+  toInt,
+} from './cslTools'
+import {chunkMessageTo64Bytes} from './utils'
+import {CIP67_FUNGIBLE_TOKEN_PREFIX, CIP67_REFERENCE_NFT_PREFIX} from './tokenBatchPlan'
+
+// Builds the mint transaction for one chunk of a token batch. Every asset in a
+// chunk lands in ONE pooled output, so the min-ada deposit is paid once per
+// transaction instead of once per token.
+
+// CIP-25 stores a field as a plain string when it fits in one 64-byte chunk, or
+// as an array of <=64-byte chunks when longer.
+const sliceBy64Bytes = (value) => {
+  const chunks = chunkMessageTo64Bytes(value)
+  return chunks.length <= 1 ? value : chunks
+}
+
+const cip67AssetNameHex = (prefix, assetName) => `${prefix}${Buffer.from(assetName, 'utf8').toString('hex')}`
+
+/**
+ * Builds an unsigned mint transaction for one chunk of tokens.
+ *
+ * Build order is load-bearing: mint + metadata must be registered before
+ * inputs/change so coin selection and the fee account for them.
+ *
+ * @returns {{fixedTx, explicitOutputCount: number, policyId: string, pubkeyHash}}
+ */
+export const buildBatchChunkTx = ({chunk, hexUtxos, changeAddressHex, usedAddressHex}) => {
+  const wasmChangeAddress = getAddressFromBytes(changeAddressHex)
+  const pubkeyHash = getPubKeyHash(getAddressFromBytes(usedAddressHex))
+  const wasmNativeScript = getNativeScript(pubkeyHash)
+  const wasmScriptHash = wasmNativeScript.hash()
+  const policyId = wasmScriptHash.to_hex()
+
+  const txBuilder = getTxBuilder()
+  const mintBuilder = getMintBuilder()
+  const mintWitness = getNativeScriptMintWitness(wasmNativeScript)
+
+  const pooledAssets = []
+  const metadata = {[policyId]: {}, version: '1.0'}
+  const referenceOutputs = []
+
+  for (const token of chunk) {
+    if (token.isCip68) {
+      // CIP-68: a (100) reference token carrying the metadata as an inline
+      // datum, plus the (333) fungible token the user actually holds.
+      const referenceAssetName = getAssetNameFromHex(cip67AssetNameHex(CIP67_REFERENCE_NFT_PREFIX, token.assetName))
+      const userAssetName = getAssetNameFromHex(cip67AssetNameHex(CIP67_FUNGIBLE_TOKEN_PREFIX, token.assetName))
+      mintBuilder.add_asset(mintWitness, referenceAssetName, toInt('1'))
+      mintBuilder.add_asset(mintWitness, userAssetName, toInt(token.quantity))
+      pooledAssets.push({assetName: userAssetName, quantity: token.quantity})
+      const datum = getCip68Datum({
+        name: token.assetName,
+        description: token.description,
+        ticker: token.ticker,
+        decimals: 0,
+      })
+      referenceOutputs.push(
+        buildAssetOutputWithMinCoin(
+          wasmChangeAddress,
+          getMultiAssetForPolicy(wasmScriptHash, [{assetName: referenceAssetName, quantity: '1'}]),
+          datum,
+        ),
+      )
+    } else {
+      const wasmAssetName = getAssetName(token.assetName)
+      mintBuilder.add_asset(mintWitness, wasmAssetName, toInt(token.quantity))
+      pooledAssets.push({assetName: wasmAssetName, quantity: token.quantity})
+      metadata[policyId][token.assetName] = {
+        name: token.assetName,
+        ticker: token.ticker,
+        description: sliceBy64Bytes(token.description),
+      }
+    }
+  }
+
+  txBuilder.set_mint_builder(mintBuilder)
+  // A chunk holding only the CIP-68 token has no 721 entries — its metadata
+  // lives in the reference token's datum instead.
+  if (Object.keys(metadata[policyId]).length > 0) {
+    logger.debug(`[tokenBatchMint] 721 metadata -> ${JSON.stringify(metadata)}`)
+    txBuilder.add_json_metadatum(strToBigNum('721'), JSON.stringify(metadata))
+  }
+
+  txBuilder.add_output(
+    buildAssetOutputWithMinCoin(wasmChangeAddress, getMultiAssetForPolicy(wasmScriptHash, pooledAssets)),
+  )
+  for (const referenceOutput of referenceOutputs) {
+    txBuilder.add_output(referenceOutput)
+  }
+  const explicitOutputCount = 1 + referenceOutputs.length
+
+  txBuilder.add_inputs_from(getCslUtxos(hexUtxos), getLargestFirstMultiAsset())
+  txBuilder.add_required_signer(pubkeyHash)
+  txBuilder.add_change_if_needed(wasmChangeAddress)
+
+  const fixedTx = getFixedTxFromBytes(txBuilder.build_tx().to_bytes())
+  return {fixedTx, explicitOutputCount, policyId, pubkeyHash}
+}
+
+/**
+ * Advances the local UTxO set after a chunk is submitted: drops the inputs the
+ * transaction spent and adds back its change output as a synthetic UTxO. The
+ * wallet cannot do this for us — getUtxos() keeps reporting the pre-submission
+ * set until the transaction is confirmed, so the next chunk would double-spend.
+ *
+ * The pooled mint output is deliberately NOT added back: it holds the freshly
+ * minted assets, and there is no reason for a later chunk to spend them.
+ */
+export const chainUtxosAfterTx = ({fixedTx, hexUtxos, explicitOutputCount}) => {
+  const body = fixedTx.body()
+  const spentKeys = getInputKeysFromBody(body)
+  const remaining = hexUtxos.filter((hexUtxo) => {
+    const utxo = getUtxoFromHex(hexUtxo)
+    return !spentKeys.has(`${utxo.tx_hash}#${utxo.tx_index}`)
+  })
+
+  const outputs = body.outputs()
+  if (outputs.len() > explicitOutputCount) {
+    // add_change_if_needed appends the change output last.
+    const changeIndex = outputs.len() - 1
+    remaining.push(getUnspentOutputHex(fixedTx.transaction_hash().to_hex(), changeIndex, outputs.get(changeIndex)))
+  } else {
+    logger.debug('[tokenBatchMint][chainUtxosAfterTx] no change output produced — nothing to chain forward')
+  }
+
+  return remaining
+}

From fe48c00cb4a0217dbc91d95e7b1a968ef06a0509 Mon Sep 17 00:00:00 2001
From: Denis Nebytov <nebytov.d@gmail.com>
Date: Mon, 24 Aug 2026 14:40:46 +0300
Subject: [PATCH 2/2] Keep every change UTxO and split long CIP-25 tickers.

add_change_if_needed can emit several change outputs; chaining only the last one dropped ada for later mint chunks. Tickers over 64 bytes now use the same metadatum split as descriptions.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 src/utils/tokenBatchMint.js | 27 +++++++++++++++++----------
 1 file changed, 17 insertions(+), 10 deletions(-)

diff --git a/src/utils/tokenBatchMint.js b/src/utils/tokenBatchMint.js
index 39f56a6..d80cfec 100644
--- a/src/utils/tokenBatchMint.js
+++ b/src/utils/tokenBatchMint.js
@@ -29,7 +29,8 @@ import {CIP67_FUNGIBLE_TOKEN_PREFIX, CIP67_REFERENCE_NFT_PREFIX} from './tokenBa
 // transaction instead of once per token.
 
 // CIP-25 stores a field as a plain string when it fits in one 64-byte chunk, or
-// as an array of <=64-byte chunks when longer.
+// as an array of <=64-byte chunks when longer. Applied to ticker and description
+// (asset `name` is already capped at 32 bytes).
 const sliceBy64Bytes = (value) => {
   const chunks = chunkMessageTo64Bytes(value)
   return chunks.length <= 1 ? value : chunks
@@ -88,7 +89,7 @@ export const buildBatchChunkTx = ({chunk, hexUtxos, changeAddressHex, usedAddres
       pooledAssets.push({assetName: wasmAssetName, quantity: token.quantity})
       metadata[policyId][token.assetName] = {
         name: token.assetName,
-        ticker: token.ticker,
+        ticker: sliceBy64Bytes(token.ticker),
         description: sliceBy64Bytes(token.description),
       }
     }
@@ -120,12 +121,13 @@ export const buildBatchChunkTx = ({chunk, hexUtxos, changeAddressHex, usedAddres
 
 /**
  * Advances the local UTxO set after a chunk is submitted: drops the inputs the
- * transaction spent and adds back its change output as a synthetic UTxO. The
+ * transaction spent and adds back its change outputs as synthetic UTxOs. The
  * wallet cannot do this for us — getUtxos() keeps reporting the pre-submission
  * set until the transaction is confirmed, so the next chunk would double-spend.
  *
- * The pooled mint output is deliberately NOT added back: it holds the freshly
- * minted assets, and there is no reason for a later chunk to spend them.
+ * The pooled mint output (and any CIP-68 reference outputs) are deliberately
+ * NOT added back: they hold the freshly minted assets, and later chunks have
+ * no reason to spend them.
  */
 export const chainUtxosAfterTx = ({fixedTx, hexUtxos, explicitOutputCount}) => {
   const body = fixedTx.body()
@@ -136,12 +138,17 @@ export const chainUtxosAfterTx = ({fixedTx, hexUtxos, explicitOutputCount}) => {
   })
 
   const outputs = body.outputs()
-  if (outputs.len() > explicitOutputCount) {
-    // add_change_if_needed appends the change output last.
-    const changeIndex = outputs.len() - 1
-    remaining.push(getUnspentOutputHex(fixedTx.transaction_hash().to_hex(), changeIndex, outputs.get(changeIndex)))
-  } else {
+  if (outputs.len() <= explicitOutputCount) {
     logger.debug('[tokenBatchMint][chainUtxosAfterTx] no change output produced — nothing to chain forward')
+    return remaining
+  }
+
+  // add_change_if_needed appends change after the explicit mint/reference
+  // outputs. Leftover multi-assets can force several change UTxOs when one
+  // would exceed maxValueSize — chain every one of them, not only the last.
+  const txHashHex = fixedTx.transaction_hash().to_hex()
+  for (let changeIndex = explicitOutputCount; changeIndex < outputs.len(); changeIndex++) {
+    remaining.push(getUnspentOutputHex(txHashHex, changeIndex, outputs.get(changeIndex)))
   }
 
   return remaining