fix onMint reciever

Author: colll78

frontend/src/app/mint-authority/page.tsx

@@ -20,6 +20,7 @@ import WSTTextField from '../components/WSTTextField';
 import CopyTextField from '../components/CopyTextField';
 import WSTTable from '../components/WSTTable';
 import AlertBar from '../components/AlertBar';
+import { adjustMintOutput, deriveProgrammableAddress } from '../utils/walletUtils';
 
 export default function Home() {
   const { lucid, mintAccount, selectedTab, errorMessage, setAlertStatus } = useStore();
@@ -55,7 +56,9 @@ export default function Home() {
       console.log('Mint response:', response.data);
       const tx = await lucid.fromTx(response.data.cborHex);
       const txBuilder = await makeTxSignBuilder(lucid.wallet(), tx.toTransaction()).complete();
-      const cmlTx = txBuilder.toTransaction();
+      const cmlTxInternal = txBuilder.toTransaction()
+      console.log("TxBody: " + cmlTxInternal.body().to_json());
+      const cmlTx = adjustMintOutput(cmlTxInternal, (await deriveProgrammableAddress(lucid, recipientAddress)), BigInt(mintTokens))
       const witnessSet = txBuilder.toTransaction().witness_set();
       const expectedScriptDataHash : CML.ScriptDataHash | undefined = CML.calc_script_data_hash(witnessSet.redeemers()!, CML.PlutusDataList.new(), lucid.config().costModels!, witnessSet.languages());
       console.log('Calculated Script Data Hash:', expectedScriptDataHash?.to_hex());

frontend/src/app/utils/walletUtils.ts

@@ -2,7 +2,7 @@
 import axios from 'axios';
 
 //Lucis imports
-import { Blockfrost, CML, Lucid, LucidEvolution, TxSigned, walletFromSeed } from "@lucid-evolution/lucid";
+import { Blockfrost, CML, Lucid, LucidEvolution, TxSigned, walletFromSeed, Credential, valueToAssets, Assets, UTxO, Address, paymentCredentialOf, credentialToAddress, toUnit, Unit } from "@lucid-evolution/lucid";
 
 async function loadKey() {
   const response = await axios.get("/blockfrost-key",
@@ -85,4 +85,135 @@ export type WalletType = "Lace" | "Eternl" | "Nami" | "Yoroi";
 export async function selectLucidWallet(lucid: LucidEvolution, wallet: WalletType) {
   const api = (await window.cardano[wallet.toLowerCase()].enable());
   lucid.selectWallet.fromAPI(api);
+}
+
+const progLogicBase : Credential = {
+  type: "Script",
+  hash: "fca77bcce1e5e73c97a0bfa8c90f7cd2faff6fd6ed5b6fec1c04eefa"
+}
+
+const stableCoin : Unit = toUnit("b34a184f1f2871aa4d33544caecefef5242025f45c3fa5213d7662a9", "575354")
+
+export function adjustMintOutput(tx: CML.Transaction, receiverAddress: Address, mintedAmount: bigint) {
+  const txB : CML.TransactionBody = tx.body()
+  const new_outputs = CML.TransactionOutputList.new()
+
+  const outputs : CML.TransactionOutputList = txB.outputs()
+  const outputsLen = outputs.len()
+  for (let i = 0; i < outputsLen; i++) {
+    const output : CML.TransactionOutput = outputs.get(i)
+    const address = output.address()
+    const assets : Assets = valueToAssets(output.amount())
+    if (stableCoin in assets) {
+      console.log("Found stablecoin in output")
+      const stablecoinAmount = assets[stableCoin]
+      if (stablecoinAmount == mintedAmount){
+        console.log("Found minted amount in output")
+        const newOutput = CML.TransactionOutput.new(CML.Address.from_bech32(receiverAddress), output.amount(), output.datum(), output.script_ref())
+        new_outputs.add(newOutput)
+        //new(address: Address, amount: Value, datum_option?: DatumOption, script_reference?: Script): TransactionOutput;
+      } else {
+        new_outputs.add(output)
+      }
+    } else {
+      new_outputs.add(output)
+    }
+  }
+  const newTxB : CML.TransactionBody = CML.TransactionBody.new(txB.inputs(), new_outputs, txB.fee());
+  const oldTxAuxHash = txB.auxiliary_data_hash()
+  if(oldTxAuxHash){
+    newTxB.set_auxiliary_data_hash(oldTxAuxHash)
+  }
+  const oldWithdrawals = txB.withdrawals()
+  if(oldWithdrawals){
+    newTxB.set_withdrawals(oldWithdrawals)
+  }
+  const oldTTL = txB.ttl()
+  if(oldTTL){
+    newTxB.set_ttl(oldTTL)
+  }
+  const oldCerts = txB.certs()
+  if(oldCerts){
+    newTxB.set_certs(oldCerts)
+  }
+
+  const oldValidityStart = txB.validity_interval_start()
+  if(oldValidityStart){
+    newTxB.set_validity_interval_start(oldValidityStart)
+  }
+
+  const oldMint = txB.mint()
+  if(oldMint){
+    newTxB.set_mint(oldMint)
+  }
+
+  const oldCollateral = txB.collateral_inputs()
+  if(oldCollateral){
+    newTxB.set_collateral_inputs(oldCollateral)
+  }
+
+  const oldRequiredSigners = txB.required_signers()
+  if(oldRequiredSigners){
+    newTxB.set_required_signers(oldRequiredSigners)
+  }
+
+  const oldNetworkId = txB.network_id()
+  if(oldNetworkId){
+    newTxB.set_network_id(oldNetworkId)
+  }
+
+  const oldCollateralReturn = txB.collateral_return()
+  if(oldCollateralReturn){
+    newTxB.set_collateral_return(oldCollateralReturn)
+  }
+
+  const oldTotalCollateral = txB.total_collateral()
+  if(oldTotalCollateral){
+    newTxB.set_total_collateral(oldTotalCollateral)
+  }
+
+  const oldReferenceInputs = txB.reference_inputs();
+  if(oldReferenceInputs){
+    newTxB.set_reference_inputs(oldReferenceInputs)
+  }
+
+  const oldTreasuryValue = txB.current_treasury_value()
+  if(oldTreasuryValue){
+    newTxB.set_current_treasury_value(oldTreasuryValue)
+  }
+
+  console.log("New outputs length: ", new_outputs.len())  
+  // const oldAuxiliaryData = tx.auxiliary_data()
+  // if(oldAuxiliaryData){
+  
+  // }
+  return CML.Transaction.new(newTxB, tx.witness_set(), true, tx.auxiliary_data())
+
+}
+
+export async function getStablecoinAccounts(lucid: LucidEvolution) {
+  const progUTxOs : UTxO[] = await lucid.utxosAtWithUnit(progLogicBase, stableCoin);
+  const addresses = new Set<string>();
+  const valueMap = new Map<Address, number>();
+  progUTxOs.forEach(utxo => {
+    addresses.add(utxo.address)
+    valueMap.set(utxo.address, Number(utxo.assets[stableCoin]))
+  });
+  return { addresses: Array.from(addresses), valueMap };
+}
+
+export async function deriveProgrammableAddress(lucid: LucidEvolution, userAddress: Address){
+  const network = lucid.config().network!;
+  // user's payment credential
+  const ownerCred : Credential = paymentCredentialOf(userAddress);
+
+  // construct the user's programmable token address
+  // payment credential is always the programmable token base script hash
+  // staking credential is the user's payment credential        
+  const userProgrammableTokenAddress = credentialToAddress(
+        network,
+        progLogicBase,
+        ownerCred,
+      );
+  return userProgrammableTokenAddress;
 }