feat(txbuilder): add builders

Author: hadelive

packages/evolution/src/builders/CertificateBuilder.ts

@@ -0,0 +1,276 @@
+import { Data, Effect as Eff } from "effect"
+
+import type * as Certificate from "../core/Certificate.js"
+import type * as Credential from "../core/Credential.js"
+import * as KeyHash from "../core/KeyHash.js"
+import type * as NativeScripts from "../core/NativeScripts.js"
+import type * as PoolKeyHash from "../core/PoolKeyHash.js"
+import * as ScriptHash from "../core/ScriptHash.js"
+import type {
+  NativeScriptWitnessInfo,
+  PartialPlutusWitness} from "./WitnessBuilder.js";
+import {
+  InputAggregateWitnessData,
+  PlutusScriptWitness,
+  RequiredWitnessSet} from "./WitnessBuilder.js"
+
+/**
+ * Error class for CertificateBuilder related operations.
+ *
+ * @since 2.0.0
+ * @category errors
+ */
+export class CertificateBuilderError extends Data.TaggedError("CertificateBuilderError")<{
+  message?: string
+  cause?: unknown
+}> {}
+
+/**
+ * Calculates required witnesses for a certificate
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+export function certRequiredWits(
+  cert: Certificate.Certificate,
+  requiredWitnesses: RequiredWitnessSet
+): void {
+  switch (cert._tag) {
+    case "StakeRegistration":
+      // Stake key registrations do not require a witness
+      break
+      
+    case "StakeDeregistration":
+      addCredentialWitness(cert.stakeCredential, requiredWitnesses)
+      break
+      
+    case "StakeDelegation":
+      addCredentialWitness(cert.stakeCredential, requiredWitnesses)
+      break
+      
+    case "PoolRegistration":
+      cert.poolParams.poolOwners.forEach(owner => {
+        requiredWitnesses.addVkeyKeyHash(owner) // owner is already KeyHash
+      })
+      requiredWitnesses.addVkeyKeyHash(poolKeyHashToKeyHash(cert.poolParams.operator)) // operator is PoolKeyHash
+      break
+      
+    case "PoolRetirement":
+      requiredWitnesses.addVkeyKeyHash(poolKeyHashToKeyHash(cert.poolKeyHash))
+      break
+      
+    case "RegCert":
+      addCredentialWitness(cert.stakeCredential, requiredWitnesses)
+      break
+      
+    case "UnregCert":
+      addCredentialWitness(cert.stakeCredential, requiredWitnesses)
+      break
+      
+    case "VoteDelegCert":
+      addCredentialWitness(cert.stakeCredential, requiredWitnesses)
+      break
+      
+    case "StakeVoteDelegCert":
+      addCredentialWitness(cert.stakeCredential, requiredWitnesses)
+      break
+      
+    case "StakeRegDelegCert":
+      addCredentialWitness(cert.stakeCredential, requiredWitnesses)
+      break
+      
+    case "VoteRegDelegCert":
+      addCredentialWitness(cert.stakeCredential, requiredWitnesses)
+      break
+      
+    case "StakeVoteRegDelegCert":
+      addCredentialWitness(cert.stakeCredential, requiredWitnesses)
+      break
+      
+    case "AuthCommitteeHotCert":
+      addCredentialWitness(cert.committeeColdCredential, requiredWitnesses)
+      break
+      
+    case "ResignCommitteeColdCert":
+      addCredentialWitness(cert.committeeColdCredential, requiredWitnesses)
+      break
+      
+    case "RegDrepCert":
+      addCredentialWitness(cert.drepCredential, requiredWitnesses)
+      break
+      
+    case "UnregDrepCert":
+      addCredentialWitness(cert.drepCredential, requiredWitnesses)
+      break
+      
+    case "UpdateDrepCert":
+      addCredentialWitness(cert.drepCredential, requiredWitnesses)
+      break
+  }
+}
+
+function addCredentialWitness(
+  credential: Credential.CredentialSchema,
+  requiredWitnesses: RequiredWitnessSet
+): void {
+  switch (credential._tag) {
+    case "KeyHash":
+      requiredWitnesses.addVkeyKeyHash(credential)
+      break
+    case "ScriptHash":
+      requiredWitnesses.addScriptHash(credential)
+      break
+  }
+}
+
+function poolKeyHashToKeyHash(poolKeyHash: PoolKeyHash.PoolKeyHash): KeyHash.KeyHash {
+  // Both PoolKeyHash and KeyHash are based on Hash28, so we can convert by extracting the hash
+  return KeyHash.make({ hash: poolKeyHash.hash })
+}
+
+/**
+ * Result of building a certificate
+ *
+ * @since 2.0.0
+ * @category model
+ */
+export interface CertificateBuilderResult {
+  cert: Certificate.Certificate
+  aggregateWitness?: InputAggregateWitnessData
+  requiredWits: RequiredWitnessSet
+}
+
+/**
+ * Builder for a single certificate
+ *
+ * @since 2.0.0
+ * @category builders
+ */
+export class SingleCertificateBuilder {
+  constructor(
+    public readonly cert: Certificate.Certificate
+  ) {}
+
+  static new(cert: Certificate.Certificate): SingleCertificateBuilder {
+    return new SingleCertificateBuilder(cert)
+  }
+
+  skipWitness(): CertificateBuilderResult {
+    const requiredWits = RequiredWitnessSet.default()
+    certRequiredWits(this.cert, requiredWits)
+
+    return {
+      cert: this.cert,
+      aggregateWitness: undefined,
+      requiredWits
+    }
+  }
+
+  paymentKey(): Eff.Effect<CertificateBuilderResult, CertificateBuilderError> {
+    return Eff.gen(function* (this: SingleCertificateBuilder) {
+      const requiredWits = RequiredWitnessSet.default()
+      certRequiredWits(this.cert, requiredWits)
+
+      if (requiredWits.scripts.length > 0) {
+        return yield* Eff.fail(new CertificateBuilderError({
+          message: `Certificate contains script. Expected public key hash.`
+        }))
+      }
+
+      return {
+        cert: this.cert,
+        aggregateWitness: undefined,
+        requiredWits
+      }
+    }.bind(this))
+  }
+
+  nativeScript(
+    nativeScript: NativeScripts.NativeScript,
+    witnessInfo: NativeScriptWitnessInfo
+  ): Eff.Effect<CertificateBuilderResult, CertificateBuilderError> {
+    return Eff.gen(function* (this: SingleCertificateBuilder) {
+      const requiredWits = RequiredWitnessSet.default()
+      certRequiredWits(this.cert, requiredWits)
+      const requiredWitsLeft = structuredClone(requiredWits)
+
+      const scriptHash = ScriptHash.fromScript(nativeScript)
+
+      // Check if the script is actually required
+      const contains = requiredWitsLeft.scripts.some(h => ScriptHash.equals(h, scriptHash))
+
+      // Remove the script hash  
+      const filteredScripts = requiredWitsLeft.scripts.filter(
+        h => !ScriptHash.equals(h, scriptHash)
+      )
+      const mutableRequiredWitsLeft = { ...requiredWitsLeft, scripts: filteredScripts }
+
+      if (mutableRequiredWitsLeft.scripts.length > 0) {
+        return yield* Eff.fail(new CertificateBuilderError({
+          message: "Missing the following witnesses for the certificate",
+          cause: mutableRequiredWitsLeft
+        }))
+      }
+
+      return {
+        cert: this.cert,
+        aggregateWitness: contains 
+          ? InputAggregateWitnessData.nativeScript(nativeScript, witnessInfo)
+          : undefined,
+        requiredWits
+      }
+    }.bind(this))
+  }
+
+  plutusScript(
+    partialWitness: PartialPlutusWitness,
+    requiredSigners: Array<KeyHash.KeyHash>
+  ): Eff.Effect<CertificateBuilderResult, CertificateBuilderError> {
+    return Eff.gen(function* (this: SingleCertificateBuilder) {
+      const requiredWits = RequiredWitnessSet.default()
+      requiredSigners.forEach(signer => requiredWits.addVkeyKeyHash(signer))
+      certRequiredWits(this.cert, requiredWits)
+      const requiredWitsLeft = structuredClone(requiredWits)
+
+      // Clear vkeys as we don't know which ones will be used
+      const mutableRequiredWitsLeft = { ...requiredWitsLeft, vkeys: [] }
+
+      const scriptHash = PlutusScriptWitness.hash(partialWitness.scriptWitness)
+
+      // Check if the script is actually required
+      const contains = requiredWitsLeft.scripts.some(h => ScriptHash.equals(h, scriptHash))
+
+      // Remove the script hash
+      const filteredPlutusScripts = mutableRequiredWitsLeft.scripts.filter(
+        h => !ScriptHash.equals(h, scriptHash)
+      )
+      const finalRequiredWitsLeft = new RequiredWitnessSet({
+        vkeys: mutableRequiredWitsLeft.vkeys,
+        bootstraps: mutableRequiredWitsLeft.bootstraps,
+        scripts: filteredPlutusScripts,
+        plutusData: mutableRequiredWitsLeft.plutusData,
+        redeemers: mutableRequiredWitsLeft.redeemers,
+        scriptRefs: mutableRequiredWitsLeft.scriptRefs
+      })
+
+      if (finalRequiredWitsLeft.len() > 0) {
+        return yield* Eff.fail(new CertificateBuilderError({
+          message: "Missing the following witnesses for the certificate",
+          cause: finalRequiredWitsLeft
+        }))
+      }
+
+      return {
+        cert: this.cert,
+        aggregateWitness: contains
+          ? InputAggregateWitnessData.plutusScript(
+              partialWitness,
+              requiredSigners,
+              undefined // No datum for certificates
+            )
+          : undefined,
+        requiredWits
+      }
+    }.bind(this))
+  }
+}