Refactor last remaining TODO in LibauthTemplate

Author: rkalis

packages/cashscript/src/libauth-template/LibauthTemplate.ts

@@ -25,6 +25,7 @@ import {
   isP2PKHUnlocker,
   isStandardUnlockableUtxo,
   isUnlockableUtxo,
+  LibauthOutput,
   Output,
   StandardUnlockableUtxo,
   Utxo,
@@ -34,7 +35,7 @@ import { addressToLockScript, extendedStringify, zip } from '../utils.js';
 import { TransactionBuilder } from '../TransactionBuilder.js';
 import { deflate } from 'pako';
 import MockNetworkProvider from '../network/MockNetworkProvider.js';
-import { addHexPrefixExceptEmpty, DEFAULT_VM_TARGET, formatBytecodeForDebugging, formatParametersForDebugging, getLockScriptName, getSignatureAndPubkeyFromP2PKHInput, getUnlockScriptName, lockingBytecodeIsSetToSlot, serialiseTokenDetails } from './utils.js';
+import { addHexPrefixExceptEmpty, DEFAULT_VM_TARGET, formatBytecodeForDebugging, formatParametersForDebugging, getLockScriptName, getSignatureAndPubkeyFromP2PKHInput, getUnlockScriptName, serialiseTokenDetails } from './utils.js';
 
 // TODO: Add / improve descriptions throughout the template generation
 
@@ -62,70 +63,6 @@ export const getLibauthTemplate = (
     scenarios: generateAllTemplateScenarios(libauthTransaction, transactionBuilder),
   };
 
-  // TODO: Refactor the below code to not have deep reassignment of scenario.sourceOutputs and scenario.transaction.outputs
-
-  // Initialize bytecode mappings, these will be used to map the locking and unlocking scripts and naming the scripts
-  const unlockingBytecodeToLockingBytecodeParams: Record<string, WalletTemplateScenarioBytecode> = {};
-  const lockingBytecodeToLockingBytecodeParams: Record<string, WalletTemplateScenarioBytecode> = {};
-
-  // We can typecast this because we check that all inputs are standard unlockable at the top of this function
-  for (const [inputIndex, input] of (transactionBuilder.inputs as StandardUnlockableUtxo[]).entries()) {
-    if (isContractUnlocker(input.unlocker)) {
-      const lockScriptName = getLockScriptName(input.unlocker.contract);
-      if (!lockScriptName) continue;
-
-      const lockingScriptParams = generateLockingScriptParams(input.unlocker.contract, input, lockScriptName);
-
-      const unlockingBytecode = binToHex(libauthTransaction.inputs[inputIndex].unlockingBytecode);
-      unlockingBytecodeToLockingBytecodeParams[unlockingBytecode] = lockingScriptParams;
-
-      const lockingBytecode = binToHex(addressToLockScript(input.unlocker.contract.address));
-      lockingBytecodeToLockingBytecodeParams[lockingBytecode] = lockingScriptParams;
-    }
-  }
-
-  for (const scenario of Object.values(template.scenarios!)) {
-    // For Inputs
-    for (const [idx, input] of libauthTransaction.inputs.entries()) {
-      const unlockingBytecode = binToHex(input.unlockingBytecode);
-      const lockingBytecodeParams = unlockingBytecodeToLockingBytecodeParams[unlockingBytecode];
-
-      // If lockingBytecodeParams is unknown, then it stays at default: {}
-      if (!lockingBytecodeParams) continue;
-
-      //  If locking bytecode is set to ['slot'] then this is being evaluated by the scenario, so we don't replace bytecode
-      if (lockingBytecodeIsSetToSlot(scenario?.sourceOutputs?.[idx]?.lockingBytecode)) continue;
-
-      // If lockingBytecodeParams is known, and this input is not ['slot'] then assign a locking bytecode as source output
-      if (scenario.sourceOutputs?.[idx]) {
-        scenario.sourceOutputs[idx] = {
-          ...scenario.sourceOutputs[idx],
-          lockingBytecode: lockingBytecodeParams,
-        };
-      }
-    }
-
-    // For Outputs
-    for (const [idx, output] of libauthTransaction.outputs.entries()) {
-      const lockingBytecode = binToHex(output.lockingBytecode);
-      const lockingBytecodeParams = lockingBytecodeToLockingBytecodeParams[lockingBytecode];
-
-      // If lockingBytecodeParams is unknown, then it stays at default: {}
-      if (!lockingBytecodeParams) continue;
-
-      //  If locking bytecode is set to ['slot'] then this is being evaluated by the scenario, so we don't replace bytecode
-      if (lockingBytecodeIsSetToSlot(scenario?.transaction?.outputs?.[idx]?.lockingBytecode)) continue;
-
-      // If lockingBytecodeParams is known, and this input is not ['slot'] then assign a locking bytecode as source output
-      if (scenario?.transaction?.outputs?.[idx]) {
-        scenario.transaction.outputs[idx] = {
-          ...scenario.transaction.outputs[idx],
-          lockingBytecode: lockingBytecodeParams,
-        };
-      }
-    }
-  }
-
   return template;
 };
 
@@ -188,6 +125,25 @@ const generateAllTemplateScripts = (
   return scripts.reduce((acc, script) => ({ ...acc, ...script }), {});
 };
 
+const generateLockingBytecodeParamsMapping = (
+  transactionBuilder: TransactionBuilder,
+): Record<string, WalletTemplateScenarioBytecode> => {
+  // Initialize bytecode mapping, this will be used to map the locking bytecode to the locking bytecode params
+  const mapping: Record<string, WalletTemplateScenarioBytecode> = {};
+
+  // We can typecast this because we check that all inputs are standard unlockable at the top of this function
+  for (const input of (transactionBuilder.inputs as StandardUnlockableUtxo[])) {
+    if (isContractUnlocker(input.unlocker)) {
+      const lockScriptName = getLockScriptName(input.unlocker.contract);
+      const lockingScriptParams = generateLockingScriptParams(input.unlocker.contract, input, lockScriptName);
+      const lockingBytecode = binToHex(addressToLockScript(input.unlocker.contract.address));
+      mapping[lockingBytecode] = lockingScriptParams;
+    }
+  }
+
+  return mapping;
+};
+
 const generateAllTemplateScenarios = (
   libauthTransaction: TransactionBch,
   transactionBuilder: TransactionBuilder,
@@ -451,6 +407,8 @@ const generateTemplateScenarioTransaction = (
   transactionBuilder: TransactionBuilder,
   slotIndex: number,
 ): WalletTemplateScenario['transaction'] => {
+  const lockingBytecodeParamsMapping = generateLockingBytecodeParamsMapping(transactionBuilder);
+
   const zippedInputs = zip(transactionBuilder.inputs, libauthTransaction.inputs);
   const inputs = zippedInputs.map(([csInput, libauthInput], inputIndex) => {
     return {
@@ -465,16 +423,10 @@ const generateTemplateScenarioTransaction = (
 
   const zippedOutputs = zip(transactionBuilder.outputs, libauthTransaction.outputs);
   const outputs = zippedOutputs.map(([csOutput, libauthOutput]) => {
-    if (csOutput && contract) {
-      return {
-        lockingBytecode: generateTemplateScenarioTransactionOutputLockingBytecode(csOutput, contract),
-        token: serialiseTokenDetails(libauthOutput.token),
-        valueSatoshis: Number(libauthOutput.valueSatoshis),
-      };
-    }
-
     return {
-      lockingBytecode: `${binToHex(libauthOutput.lockingBytecode)}`,
+      lockingBytecode: generateTemplateScenarioTransactionOutputLockingBytecode(
+        csOutput, libauthOutput, contract, lockingBytecodeParamsMapping,
+      ),
       token: serialiseTokenDetails(libauthOutput.token),
       valueSatoshis: Number(libauthOutput.valueSatoshis),
     };
@@ -493,7 +445,7 @@ const generateTemplateScenarioSourceOutputs = (
   const zippedInputs = zip(transactionBuilder.inputs, libauthTransaction.inputs);
   return zippedInputs.map(([csInput, libauthInput], inputIndex) => {
     return {
-      lockingBytecode: generateTemplateScenarioBytecode(csInput, libauthInput, inputIndex, 'p2pkh_placeholder_lock', inputIndex === slotIndex),
+      lockingBytecode: generateTemplateScenarioBytecodeForSourceOutputs(csInput, libauthInput, inputIndex, 'p2pkh_placeholder_lock', inputIndex === slotIndex),
       valueSatoshis: Number(csInput.satoshis),
       token: serialiseTokenDetails(csInput.token),
     };
@@ -619,12 +571,45 @@ const generateTemplateScenarioBytecode = (
   return {};
 };
 
+const generateTemplateScenarioBytecodeForSourceOutputs = (
+  input: Utxo,
+  libauthInput: Input,
+  inputIndex: number,
+  p2pkhScriptNameTemplate: string,
+  insertSlot?: boolean,
+): WalletTemplateScenarioBytecode | ['slot'] => {
+  if (insertSlot) return ['slot'];
+
+  if (isUnlockableUtxo(input) && isStandardUnlockableUtxo(input)) {
+    // If the input is a contract unlocker, we need to generate the locking bytecode params for the source outputs
+    if (isContractUnlocker(input.unlocker)) {
+      const lockScriptName = getLockScriptName(input.unlocker.contract);
+      const lockingBytecodeParams = generateLockingScriptParams(input.unlocker.contract, input, lockScriptName);
+      return lockingBytecodeParams;
+    }
+
+    // For a P2PKH unlocker, the sourceOutputs "locking bytecode params" are the same as the unlocking bytecode params
+    return generateUnlockingScriptParams(input, libauthInput, p2pkhScriptNameTemplate, inputIndex);
+  }
+
+  // 'slot' means that we are currently evaluating this specific input,
+  // {} means that it is the same script type, but not being evaluated
+  return {};
+};
+
 const generateTemplateScenarioTransactionOutputLockingBytecode = (
   csOutput: Output,
-  contract: Contract,
+  libauthOutput: LibauthOutput,
+  contract: Contract | undefined,
+  lockingBytecodeParamsMapping: Record<string, WalletTemplateScenarioBytecode>,
 ): string | {} => {
+  // If lockingBytecodeParams is known from the mapping, return it
+  const lockingBytecode = binToHex(libauthOutput.lockingBytecode);
+  const lockingBytecodeParams = lockingBytecodeParamsMapping[lockingBytecode];
+  if (lockingBytecodeParams) return lockingBytecodeParams;
+
   if (csOutput.to instanceof Uint8Array) return binToHex(csOutput.to);
-  if ([contract.address, contract.tokenAddress].includes(csOutput.to)) return {};
+  if (contract && [contract.address, contract.tokenAddress].includes(csOutput.to)) return {};
   return binToHex(addressToLockScript(csOutput.to));
 };
 

packages/cashscript/src/libauth-template/utils.ts

@@ -1,6 +1,6 @@
 import { AbiFunction, AbiInput, Artifact, bytecodeToScript, formatBitAuthScript } from '@cashscript/utils';
 import { HashType, LibauthTokenDetails, SignatureAlgorithm, TokenDetails, VmTarget } from '../interfaces.js';
-import { hexToBin, binToHex, isHex, decodeCashAddress, type WalletTemplateScenarioBytecode, Input, assertSuccess, decodeAuthenticationInstructions, AuthenticationInstructionPush } from '@bitauth/libauth';
+import { hexToBin, binToHex, isHex, decodeCashAddress, Input, assertSuccess, decodeAuthenticationInstructions, AuthenticationInstructionPush } from '@bitauth/libauth';
 import { EncodedFunctionArgument } from '../Argument.js';
 import { zip } from '../utils.js';
 import SignatureTemplate from '../SignatureTemplate.js';
@@ -111,10 +111,6 @@ interface LibauthTemplateTokenDetails {
   };
 }
 
-export const lockingBytecodeIsSetToSlot = (lockingBytecode?: WalletTemplateScenarioBytecode | ['slot']): boolean => {
-  return Array.isArray(lockingBytecode) && lockingBytecode.length === 1 && lockingBytecode[0] === 'slot';
-};
-
 export const getSignatureAndPubkeyFromP2PKHInput = (
   libauthInput: Input,
 ): { signature: Uint8Array; publicKey: Uint8Array } => {