add more test create treasury

lib/lb_v2/utils.ak

@@ -48,6 +48,7 @@ pub const manager_minimum_ada = 2_000_000
 
 pub const seller_minimum_ada = 2_000_000
 
+// sort 2 assets in bytearray ascending
 pub fn sort_two_assets(asset_a: Asset, asset_b: Asset) -> (Asset, Asset) {
   let Asset { policy_id: asset_a_policy_id, asset_name: asset_a_asset_name } =
     asset_a
@@ -68,6 +69,7 @@ pub fn sort_two_assets(asset_a: Asset, asset_b: Asset) -> (Asset, Asset) {
   }
 }
 
+// compute from asset_a, asset_b to get AMM LP Asset Name
 pub fn compute_lp_asset_name(
   asset_a_policy_id: PolicyId,
   asset_a_asset_name: AssetName,

src/build-tx.ts

@@ -1227,34 +1227,32 @@ export class WarehouseBuilder {
     }
   }
 
-  payingFactoryOutput() {
-    const innerPay = (datum: FactoryValidateFactory["datum"]) => {
-      this.tx.payToAddressWithData(
-        this.factoryAddress,
-        {
-          inline: this.toDatumFactory(datum),
-        },
-        {
-          [this.factoryToken]: 1n,
-        },
-      );
-    };
+  innerPayFactory(datum: FactoryValidateFactory["datum"]) {
+    this.tx.payToAddressWithData(
+      this.factoryAddress,
+      {
+        inline: this.toDatumFactory(datum),
+      },
+      {
+        [this.factoryToken]: 1n,
+      },
+    );
+  }
 
+  payingFactoryOutput() {
     const cases: Record<number, () => void> = {
       // Init System
       0: () => {
         const factoryDatum: FactoryValidateFactory["datum"] = {
           head: LBE_INIT_FACTORY_HEAD,
           tail: LBE_INIT_FACTORY_TAIL,
         };
-        innerPay(factoryDatum);
+        this.innerPayFactory(factoryDatum);
       },
       // Create Treasury
       1: () => {
-        invariant(this.factoryRedeemer);
         invariant(this.factoryInputs.length == 1);
         invariant(this.factoryInputs[0].datum);
-        invariant(typeof this.factoryRedeemer.wrapper !== "string");
         invariant(this.lpAssetName);
         const factoryDatum = this.fromDatumFactory(this.factoryInputs[0].datum);
         const newFactoryHeadDatum: FactoryValidateFactory["datum"] = {
@@ -1265,8 +1263,8 @@ export class WarehouseBuilder {
           head: this.lpAssetName,
           tail: factoryDatum.tail,
         };
-        innerPay(newFactoryHeadDatum);
-        innerPay(newFactoryTailDatum);
+        this.innerPayFactory(newFactoryHeadDatum);
+        this.innerPayFactory(newFactoryTailDatum);
       },
       // Remove Treasury
       2: () => {
@@ -1280,7 +1278,7 @@ export class WarehouseBuilder {
           head: headDatum.head,
           tail: tailDatum.tail,
         };
-        innerPay(newDatum);
+        this.innerPayFactory(newDatum);
       },
     };
 

src/tests/create-treasury.test.ts

@@ -92,3 +92,51 @@ test("create-treasury | FAIL | have 2 Factory Inputs", async () => {
   });
   assertValidatorFail(txBuilder);
 });
+
+test("create-treasury | FAIL | have 0 Factory Out", async () => {
+  let builder: WarehouseBuilder = W.builder;
+  builder = builder.buildCreateTreasury(W.options);
+  builder.tasks[1] = () => {};
+  // await (builder.complete()).complete();
+  assertValidatorFail(builder);
+});
+
+test("create-treasury | FAIL | have 3 Factory Outs", async () => {
+  let builder: WarehouseBuilder = W.builder;
+  builder = builder.buildCreateTreasury(W.options);
+  builder.tasks.push(() => {
+    builder.tx.payToAddressWithData(
+      builder.factoryAddress,
+      {
+        inline: builder.toDatumFactory({ head: "00", tail: "ff" }),
+      },
+      {
+        lovelace: 1_000_000n,
+      },
+    );
+  });
+  // await (builder.complete()).complete();
+  assertValidatorFail(builder);
+});
+
+test("create-treasury | FAIL | Factory Out Datum incorrect!", async () => {
+  let builder: WarehouseBuilder = W.builder;
+  builder = builder.buildCreateTreasury(W.options);
+  builder.tasks[1] = () => {
+    const factoryDatum = builder.fromDatumFactory(
+      builder.factoryInputs[0].datum!,
+    );
+    const newFactoryHeadDatum = {
+      head: factoryDatum.head,
+      tail: builder.lpAssetName!,
+    };
+    const newFactoryTailDatum = {
+      // INCORRECT!
+      head: builder.lpAssetName!,
+      tail: "00".repeat(10),
+    };
+    builder.innerPayFactory(newFactoryHeadDatum);
+    builder.innerPayFactory(newFactoryTailDatum);
+  };
+  assertValidator(builder, "2 Factory Outputs must pay correctly!");
+});

validators/factory.ak

@@ -112,7 +112,7 @@ validator(
           (d_base_asset, d_raise_asset)
         CloseTreasury { base_asset: d_base_asset, raise_asset: d_raise_asset } ->
           (d_base_asset, d_raise_asset)
-        _ -> fail
+        _ -> fail @"Only spending Factory Input when Create | Close Treasury"
       }
     // sort to compute `asset_a`, `asset_b` in term AMM Pool Assets  
     let (asset_a, asset_b) = utils.sort_two_assets(base_asset, raise_asset)