@easy1staking/cip113-sdk-ts 0.7.0 → 0.9.0

package/dist/standard/scripts.d.ts

@@ -1,58 +1,146 @@
 /**
- * Standard script parameterization — CIP-113 0.5.0-alpha.2 (upstream 9db7e06).
+ * Standard script parameterization — CIP-113 0.5.0-alpha.4 (upstream 7e8a631).
  *
  * Uses Evolution SDK directly for UPLC.applyParamsToScript and ScriptHash.
  *
- * Dependency graph. Note it is NO LONGER a single chain: upstream #110 removed
- * programmable_logic_global, and PLB is now parameterised by the params-NFT
- * policy rather than by PLG's credential, so everything downstream hangs off
- * `params_policy` in parallel instead of in series.
+ * Dependency graph. It is NOT a single chain: `programmable_logic_base` hangs
+ * off the params-NFT policy, so everything downstream of it fans out in
+ * parallel rather than in series.
  *
- *   always_fail(nonce)                          -> hash   (issuance side only now)
- *   coordination_spend(nonce)                   -> hash   NEW: the lock target
- *   protocol_params_mint(utxo_ref, coord_hash)  -> policy  == params_policy
+ *   always_fail(nonce)                          -> hash   (issuance side only)
+ *   protocol_params(utxo_ref)                   -> policy  == params_policy
  *     |
- *     +-- programmable_logic_base(params_policy) -> hash
- *     +-- transfer(params_policy)                -> hash   (PLG's transfer arm, renamed)
- *     +-- third_party(params_policy)             -> hash   NEW: seize / clawback
- *     +-- unfracking(params_policy)              -> hash
- *     +-- registry_spend(params_policy)          -> hash
+ *     +-- programmable_logic_base(params_policy)                  -> hash  == plb
+ *     |     |
+ *     |     +-- transfer(Script(plb), registry_node_cs, max_inline)     -> hash
+ *     |     +-- third_party(Script(plb), registry_node_cs, max_inline)  -> hash
+ *     |     +-- unfracking(Script(plb), registry_node_cs, max_inline)   -> hash
+ *     |     +-- issuance_logic(Script(plb), registry_node_cs,
+ *     |                        params_policy, max_inline)              -> hash  NEW in alpha.4
+ *     |
+ *     +-- issuance_mint(Script(minting_logic), params_policy)     -> policy
+ *
+ *   programmable_logic_global(transfer_hash, third_party_hash, unfracking_hash)
+ *                                                                -> hash   (built LAST)
+ *
+ *   issuance_cbor_hex_mint(utxo_ref, always_fail_hash)            -> policy
+ *   registry(utxo_ref, issuance_cbor_hex_cs)                      -> policy
  *
- *   issuance_cbor_hex_mint(utxo_ref, always_fail_hash)              -> policy
- *   registry_mint(utxo_ref, issuance_cbor_hex_cs, registry_spend_cred) -> policy
- *   issuance_mint(PLB_cred, registry_node_cs, minting_logic_cred, params_policy)
- *   upgrade_multisig(signers, threshold)        -> hash   (independent)
+ *   upgrade_multisig(utxo_ref)                  -> hash   (independent one-shot)
  *
  * ⚠ PARAMETER TYPES ARE NOT INTERCHANGEABLE and TypeScript cannot tell them
  * apart — every one of these is a hex string at the call site. `params_policy`
- * is a PolicyId (a bare ByteArray); `minting_logic_cred` and friends are
- * Credentials (a constructor-wrapped Script/VerificationKey). Passing a policy
- * where a credential belongs produces a valid script with the wrong hash. The
- * types below come from the blueprint's own parameter schemas, not from
+ * and `registry_node_cs` are PolicyIds (bare ByteArrays); `minting_logic_cred`
+ * and `programmable_logic_base` are Credentials (constructor-wrapped
+ * Script/VerificationKey). `scriptCredential()` wraps; `Data.bytearray()` does
+ * not. Passing a policy where a credential belongs produces a valid script with
+ * the wrong hash.
+ *
+ * ⛔ alpha.4 makes that sharper: `issuance_logic` takes TWO ADJACENT PolicyId
+ * parameters — `registry_node_cs` then `params_policy`. They are the same type,
+ * the same length, and both are `string` here. Swapping them yields a script
+ * that builds, hashes and deploys, and nothing before the ledger will say so.
+ *
+ * The types below come from the blueprint's own parameter schemas, not from
  * upstream's prose docs — see the hazard note in blueprint.ts.
  */
 import { Data } from "@evolution-sdk/evolution";
 import type { DeploymentParams, HexString, PlutusBlueprint, PlutusScript, PolicyId, ScriptHash, TxInput } from "../types.js";
 export interface StandardScripts {
     alwaysFail(nonce: HexString): PlutusScript;
-    /** NEW in 0.5.x — the coordination UTxO's spender; nonce is arbitrary, per deployment. */
-    coordinationSpend(nonce: HexString): PlutusScript;
-    /** 2nd param is coordination_spend's hash in 0.5.x, always_fail's in 0.3.x. */
-    protocolParamsMint(utxoRef: TxInput, coordinationHash: ScriptHash): PlutusScript;
-    /** Takes the params-NFT POLICY now, not PLG's credential. */
+    /**
+     * `protocol_params` — mint AND spend in one validator (#118).
+     *
+     * ⚑ ITS HASH IS BOTH THE PARAMS-NFT POLICY ID AND THE PARAMS ADDRESS'S
+     * PAYMENT CREDENTIAL. The mint handler locks the NFT at `Script(own_policy)`
+     * — the minting policy naming itself. Callers that used to derive the policy
+     * from `protocol_params_mint` and the address from `protocol_params_spend`
+     * must collapse to this one derivation.
+     *
+     * ⚠ NO NONCE, and no lock-target parameter. `protocol_params_mint` took
+     * `(utxo_ref, coordination_hash)` and `coordination_spend` took `(nonce)`;
+     * both are gone. The ordering cycle they created is dissolved with them.
+     */
+    protocolParams(utxoRef: TxInput): PlutusScript;
+    /** Takes the params-NFT POLICY — which is now also the params address. */
     programmableLogicBase(paramsPolicy: PolicyId): PlutusScript;
-    /** PLG's transfer arm, renamed by #110. */
-    transfer(paramsPolicy: PolicyId): PlutusScript;
-    /** Seize / clawback, split out of PLG by #110. */
-    thirdParty(paramsPolicy: PolicyId): PlutusScript;
-    unfracking(paramsPolicy: PolicyId): PlutusScript;
-    upgradeMultisig(signers: HexString[], threshold: number | bigint): PlutusScript;
+    /**
+     * The three withdraw-0 delegates. Arity 1 -> 3 in alpha.3, SAME TITLES.
+     *
+     * ⚠ `progLogicCred` is programmable_logic_base's hash, NOT the dispatcher's.
+     * The dispatcher is parameterised BY these three, so pointing them at it
+     * would be a parameter cycle: a value derived from your own script hash can
+     * never be your own parameter.
+     */
+    transfer(progLogicCred: ScriptHash, registryPolicy: PolicyId, maxInlineDatumBytes: number | bigint): PlutusScript;
+    thirdParty(progLogicCred: ScriptHash, registryPolicy: PolicyId, maxInlineDatumBytes: number | bigint): PlutusScript;
+    unfracking(progLogicCred: ScriptHash, registryPolicy: PolicyId, maxInlineDatumBytes: number | bigint): PlutusScript;
+    /**
+     * `programmable_logic_global` — the dispatcher, reintroduced by #117.
+     *
+     * Carries the three delegate hashes as compile-time parameters, so replacing
+     * ONE delegate requires deploying a new dispatcher too. Must be built AFTER
+     * all three delegates.
+     *
+     * ⚠ Its parameters are bare ScriptHashes, not Credentials — unlike
+     * `issuance_mint`'s, which wrap the same 28 bytes in a Credential
+     * constructor. Same bytes, different encoding, no type to tell them apart.
+     */
+    programmableLogicGlobal(transferHash: ScriptHash, thirdPartyHash: ScriptHash, unfrackingHash: ScriptHash): PlutusScript;
+    /**
+     * `upgrade_multisig` — a ONE-SHOT in alpha.4: `(signers, threshold)` are gone
+     * and a single `utxo_ref` takes their place.
+     *
+     * ⚑ ONE VALUE, THREE ROLES. Its hash is the config NFT's POLICY ID, the
+     * config UTxO's ADDRESS payment credential, AND the withdraw-0 CREDENTIAL the
+     * upgrade authority is satisfied by. Do not derive any of the three
+     * separately — that is the dual-hash collapse of `protocol_params` and
+     * `registry` again, with one more role attached.
+     *
+     * The signer set moved OFF the parameters and INTO a `MultisigScript` tree in
+     * the config UTxO's datum, so rotating signers no longer changes the hash.
+     * Build those trees with `multisigScriptDatum` in `src/core/evo-utils.ts`
+     * (T-F02-1), which enforces upstream's `well_formed`.
+     */
+    upgradeMultisig(utxoRef: TxInput): PlutusScript;
     issuanceCborHexMint(utxoRef: TxInput, alwaysFailHash: ScriptHash): PlutusScript;
-    /** Arity 2 -> 3: gained registry_spend's credential. */
-    registryMint(utxoRef: TxInput, issuanceCborHexPolicy: PolicyId, registrySpendHash: ScriptHash): PlutusScript;
-    registrySpend(paramsPolicy: PolicyId): PlutusScript;
-    /** Arity 3 -> 4: gained params_policy. */
-    issuanceMint(plbHash: ScriptHash, registryNodePolicy: PolicyId, mintingLogicHash: ScriptHash, paramsPolicy: PolicyId): PlutusScript;
+    /**
+     * `registry` — mint AND spend in one validator (#117).
+     *
+     * ⚑ ONE HASH FOR POLICY AND ADDRESS, exactly as `protocolParams`. Arity
+     * dropped 3 -> 2: `registry_spend_cred` is gone, and so is the params-policy
+     * parameter the old spend side took — the registry no longer depends on the
+     * protocol-params chain at all and can be built immediately after
+     * `issuanceCborHexMint`.
+     */
+    registry(utxoRef: TxInput, issuanceCborHexPolicy: PolicyId): PlutusScript;
+    /**
+     * `issuance_mint` — arity 4 -> 2 in alpha.4.
+     *
+     * ⚠ `programmable_logic_base` and `registry_node_cs` are GONE from its
+     * parameters. It reads the delegate credentials out of the params datum at
+     * runtime instead, which is why `params_policy` survives and the other two do
+     * not. Its POLICY ID therefore CHANGES for the same minting logic — see
+     * {@link ResolvedStandardScripts.buildIssuanceMint}.
+     */
+    issuanceMint(mintingLogicHash: ScriptHash, paramsPolicy: PolicyId): PlutusScript;
+    /**
+     * `issuance_logic` — NEW in alpha.4. The replaceable half of issuance: the
+     * params datum's field 1 names its credential, and its withdraw-0 rides on
+     * EVERY mint and burn.
+     *
+     * ⛔ ONE CREDENTIAL, THEN TWO BARE POLICIES, AND THE TWO POLICIES ARE NOT
+     * INTERCHANGEABLE. `progLogicCred` is constructor-wrapped by
+     * `scriptCredential()`; `registryPolicy` and `paramsPolicy` are bare
+     * ByteArrays applied in THAT ORDER (`registry_node_cs`, then
+     * `params_policy`). Both are `string` at the call site and nothing — not the
+     * compiler, not the parameteriser, not the hash — can tell a swap from the
+     * intended order.
+     *
+     * ⚠ `progLogicCred` is programmable_logic_base's hash, NOT the dispatcher's,
+     * exactly as for the three delegates.
+     */
+    issuanceLogic(progLogicCred: ScriptHash, registryPolicy: PolicyId, paramsPolicy: PolicyId, maxInlineDatumBytes: number | bigint): PlutusScript;
 }
 /**
  * Create standard script builders from a blueprint.
@@ -114,39 +202,6 @@ export declare class DeploymentMismatchError extends Error {
     readonly mismatches: ScriptHashCheck[];
     constructor(mismatches: ScriptHashCheck[], blueprintTitle: string);
 }
-/**
- * Derive every parameterizable standard script hash from the blueprint and
- * check it against DeploymentParams. Throws DeploymentMismatchError on any
- * difference; returns the full check list on success.
- *
- * Why this exists: parameterization changes are not always visible to the
- * compiler. Upstream has changed a parameter's *meaning* while keeping its
- * arity and type (protocol_params_mint's `always_fail_hash` became
- * `coordination_addr_hash` in 0.5.0-alpha.1), so a wrong value typechecks,
- * builds, and only fails when the ledger rejects the transaction. This is the
- * check that catches it, and it is why buildDeploymentScripts no longer
- * overwrites derived hashes with deployment values.
- *
- * Not covered: always_fail (its nonce is not carried in DeploymentParams),
- * issuance_mint (parameterized per minting logic), and upgrade_multisig (its
- * signers/threshold are an authority choice, not a derived protocol value).
- * coordination_spend IS covered — DeploymentParams carries its nonce precisely
- * so the lock target can be re-derived rather than trusted.
- *
- * WHERE THIS CHECK HAS VALUE — and where it has none.
- *
- * It is only meaningful when the blueprint and the deployment come from
- * INDEPENDENT sources, so that they can actually disagree: a deployment loaded
- * from disk, a database, or the chain, checked against the blueprint currently
- * bundled. That is the case it catches, and the failure it catches is real —
- * this repo shipped a blueprint swapped in place under an unchanged directory
- * name, with 4 of 8 validator hashes moved.
- *
- * It proves NOTHING at bootstrap time. A deployment script derives the hashes,
- * populates DeploymentParams from those same values, and then asserts against
- * them — a tautology that cannot fail. Do not read a passing assertion inside a
- * bootstrap as evidence that the deployment is correct; assert on LOAD instead.
- */
 export declare function assertDeploymentScripts(blueprint: PlutusBlueprint, deployment: DeploymentParams): ScriptHashCheck[];
 /**
  * Build resolved standard scripts from deployment params.
@@ -158,17 +213,30 @@ export declare function assertDeploymentScripts(blueprint: PlutusBlueprint, depl
  */
 export declare function buildDeploymentScripts(blueprint: PlutusBlueprint, deployment: DeploymentParams): ResolvedStandardScripts;
 export interface ResolvedStandardScripts {
-    coordinationSpend: PlutusScript;
-    protocolParamsMint: PlutusScript;
+    /** Mint AND spend in one script; its hash is both policy and address. */
+    protocolParams: PlutusScript;
     programmableLogicBase: PlutusScript;
-    /** PLG's transfer arm, renamed by #110. */
+    /** Withdraw-0 delegates. Parameterised (plb, registryPolicy, maxInlineDatumBytes). */
     transfer: PlutusScript;
     /** Seize / clawback. */
     thirdParty: PlutusScript;
     unfracking: PlutusScript;
+    /** The dispatcher every programmable transaction withdraws through. */
+    programmableLogicGlobal: PlutusScript;
     issuanceCborHexMint: PlutusScript;
-    registryMint: PlutusScript;
-    registrySpend: PlutusScript;
+    /** Mint AND spend in one script; its hash is both policy and address. */
+    registry: PlutusScript;
+    /**
+     * The replaceable half of issuance (alpha.4). Its withdraw-0 rides on every
+     * mint and burn, and its credential must be REGISTERED to do so.
+     */
+    issuanceLogic: PlutusScript;
+    /**
+     * The reference upgrade authority. ⚑ Its hash is the config NFT policy, the
+     * config UTxO's address payment credential, AND the withdraw-0 credential —
+     * one value, three roles.
+     */
+    upgradeMultisig: PlutusScript;
     /** Build issuance_mint for a specific minting logic — NOT cached */
     buildIssuanceMint(mintingLogicHash: ScriptHash): PlutusScript;
 }

package/dist/standard/scripts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scripts.d.ts","sourceRoot":"","sources":["../../src/standard/scripts.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"scripts.d.ts","sourceRoot":"","sources":["../../src/standard/scripts.ts"],"names":[],"mappings":"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"}