type

src/lbe-v2.ts

@@ -0,0 +1,281 @@
+import invariant from "@minswap/tiny-invariant";
+import {
+  Address,
+  Assets,
+  Constr,
+  Data,
+  Lucid,
+  TxComplete,
+  UTxO,
+} from "lucid-cardano";
+
+import {
+  FIXED_DEPOSIT_ADA,
+  LbeV2Constant,
+  MAX_POOL_V2_TRADING_FEE_NUMERATOR,
+  MetadataMessage,
+  MIN_POOL_V2_TRADING_FEE_NUMERATOR,
+  PoolV2,
+  StableOrder,
+  StableswapConstant,
+} from ".";
+import { calculateBatcherFee } from "./batcher-fee-reduction/calculate";
+import { Asset } from "./types/asset";
+import { LbeV2Types } from "./types/lbe-v2";
+import { NetworkEnvironment, NetworkId } from "./types/network";
+import { lucidToNetworkEnv } from "./utils/network.internal";
+import { buildUtxoToStoreDatum } from "./utils/tx.internal";
+
+export type CreateLbeV2EventOptions = {
+  networkEnv: NetworkEnvironment;
+  factoryUtxo: UTxO;
+  lbeV2Parameters: LbeV2Types.LbeV2Parameters;
+  currentSlot: number;
+  sellerOwner: Address;
+  sellerCount?: number;
+  projectDetails?: string[];
+};
+
+export class LbeV2 {
+  private readonly lucid: Lucid;
+  private readonly networkId: NetworkId;
+  private readonly networkEnv: NetworkEnvironment;
+
+  constructor(lucid: Lucid) {
+    this.lucid = lucid;
+    this.networkId =
+      lucid.network === "Mainnet" ? NetworkId.MAINNET : NetworkId.TESTNET;
+    this.networkEnv = lucidToNetworkEnv(lucid.network);
+  }
+
+  // MARK: Create Event
+  private validateCreateEvent(options: CreateLbeV2EventOptions): void {
+    const { lbeV2Parameters, currentSlot, factoryUtxo } = options;
+    const currentTime = this.lucid.utils.slotToUnixTime(currentSlot);
+    const { baseAsset, raiseAsset } = lbeV2Parameters;
+    const datum = factoryUtxo.datum;
+    invariant(datum, "Factory utxo must have inline datum");
+    const factory = LbeV2Types.FactoryDatum.fromPlutusData(Data.from(datum));
+    const config = LbeV2Constant.CONFIG[this.networkId];
+    invariant(
+      config.factoryAsset in factoryUtxo.assets,
+      "Factory utxo assets must have factory asset"
+    );
+    const lbeV2Id = PoolV2.computeLPAssetName(baseAsset, raiseAsset);
+    invariant(
+      factory.head < lbeV2Id && lbeV2Id < factory.tail,
+      "LBE ID name must be between factory head and tail"
+    );
+    this.validateLbeV2Parameters(lbeV2Parameters, currentTime);
+  }
+
+  validateLbeV2Parameters(
+    params: LbeV2Types.LbeV2Parameters,
+    currentTime: number
+  ): void {
+    const {
+      poolBaseFee,
+      penaltyConfig,
+      reserveBase,
+      minimumRaise,
+      maximumRaise,
+      minimumOrderRaise,
+      poolAllocation,
+      startTime,
+      endTime,
+      baseAsset,
+      raiseAsset,
+    } = params;
+    invariant(
+      Asset.toString(baseAsset) !== Asset.toString(raiseAsset),
+      "Base Asset, Raise Asset must be different"
+    );
+    invariant(
+      Asset.toString(baseAsset) !== "lovelace",
+      "Base Asset must not equal ADA"
+    );
+    invariant(startTime >= BigInt(currentTime), "LBE must start in future");
+    invariant(startTime < endTime, "StartTime < EndTime");
+    invariant(
+      endTime - startTime <= LbeV2Constant.MAX_DISCOVERY_RANGE,
+      "Discovery Phase must in a month"
+    );
+    invariant(
+      poolAllocation >= LbeV2Constant.MIN_POOL_ALLOCATION_POINT,
+      `Pool Allocation must greater than ${LbeV2Constant.MIN_POOL_ALLOCATION_POINT}`
+    );
+    invariant(
+      poolAllocation <= LbeV2Constant.MAX_POOL_ALLOCATION_POINT,
+      `Pool Allocation must less than ${LbeV2Constant.MAX_POOL_ALLOCATION_POINT}`
+    );
+    if (minimumOrderRaise) {
+      invariant(minimumOrderRaise > 0n, "Minimum Order > 0");
+    }
+    if (maximumRaise) {
+      invariant(maximumRaise > 0n, "Maximum Raise > 0");
+    }
+    if (minimumRaise) {
+      invariant(minimumRaise > 0n, "Minimum Raise > 0");
+      if (maximumRaise !== undefined) {
+        invariant(minimumRaise < maximumRaise, "Minimum Raise < Maximum Raise");
+      }
+    }
+    invariant(reserveBase > 0n, "Reserve Base > 0");
+    if (penaltyConfig) {
+      const { penaltyStartTime, percent } = penaltyConfig;
+      invariant(
+        penaltyStartTime > startTime,
+        "Penalty Start Time > Start Time"
+      );
+      invariant(penaltyStartTime < endTime, "Penalty Start Time < End Time");
+      invariant(
+        penaltyStartTime >= endTime - LbeV2Constant.MAX_PENALTY_RANGE,
+        "Maximum penalty period of 2 final days"
+      );
+      invariant(percent > 0n, "Penalty Percent > 0");
+      invariant(
+        percent <= LbeV2Constant.MAX_PENALTY_RATE,
+        `Penalty Percent <= ${LbeV2Constant.MAX_PENALTY_RATE}`
+      );
+    }
+    const poolBaseFeeMin = MIN_POOL_V2_TRADING_FEE_NUMERATOR;
+    const poolBaseFeeMax = MAX_POOL_V2_TRADING_FEE_NUMERATOR;
+    invariant(
+      poolBaseFee >= poolBaseFeeMin && poolBaseFee <= poolBaseFeeMax,
+      `Pool Base Fee must in range ${poolBaseFeeMin} - ${poolBaseFeeMax}`
+    );
+  }
+
+  async createTreasury(options: CreateLbeV2EventOptions): Promise<TxComplete> {
+    const {
+      lbeV2Parameters,
+      factoryUtxo,
+      sellerOwner,
+      projectDetails,
+      networkEnv,
+    } = options;
+    const sellerCount: number =
+      options.sellerCount ?? Number(LbeV2Constant.DEFAULT_SELLER_COUNT);
+    this.validateCreateEvent(options);
+    const factory = Result.unwrap(LbeV2Factory.fromUtxo(factoryUtxo));
+    const warehouse = LbeV2Warehouse.getInstance(networkEnv);
+    const factoryRedeemer = LbeV2FactoryRedeemer.toPlutusJson({
+      type: LbeV2FactoryRedeemerType.CREATE_TREASURY,
+      baseAsset: lbeV2Parameters.baseAsset,
+      raiseAsset: lbeV2Parameters.raiseAsset,
+    });
+    const wrapperFactoryRedeemer =
+      RedeemerWrapper.wrapRedeemer(factoryRedeemer);
+
+    const treasuryValue = warehouse
+      .getDefaultTreasuryValue()
+      .add(lbeV2Parameters.baseAsset, lbeV2Parameters.reserveBase);
+
+    const treasuryDatum: LbeV2TreasuryDatum =
+      LbeV2TreasuryDatum.fromLbeV2Parameters(lbeV2Parameters);
+    const treasuryOutput = new TxOut(
+      warehouse.getTreasuryAddress(),
+      treasuryValue,
+      LbeV2TreasuryDatum.toDatumSource(treasuryDatum)
+    );
+    const lbeV2Id = PoolV2.computeLPAssetName(
+      lbeV2Parameters.baseAsset,
+      lbeV2Parameters.raiseAsset
+    );
+    const factoryHeadOutput = new TxOut(
+      warehouse.getFactoryAddress(),
+      warehouse.getDefaultFactoryValue(),
+      LbeV2FactoryDatum.toDatumSource({
+        head: factory.head,
+        tail: lbeV2Id,
+      })
+    );
+
+    const factoryTailOutput = new TxOut(
+      warehouse.getFactoryAddress(),
+      warehouse.getDefaultFactoryValue(),
+      LbeV2FactoryDatum.toDatumSource({
+        head: lbeV2Id,
+        tail: factory.tail,
+      })
+    );
+
+    const managerOutput = new TxOut(
+      warehouse.getManagerAddress(),
+      warehouse.getDefaultManagerValue(),
+      LbeV2ManagerDatum.toDatumSource({
+        factoryPolicyId: warehouse.getFactoryHash(),
+        baseAsset: lbeV2Parameters.baseAsset,
+        raiseAsset: lbeV2Parameters.raiseAsset,
+        sellerCount: BigInt(sellerCount),
+        reserveRaise: 0n,
+        totalPenalty: 0n,
+      })
+    );
+
+    const sellerOutputs: TxOut[] = [];
+    for (let i = 0; i < sellerCount; i++) {
+      const txOut = new TxOut(
+        warehouse.getSellerAddress(),
+        warehouse.getDefaultSellerValue(),
+        LbeV2SellerDatum.toDatumSource({
+          factoryPolicyId: warehouse.getFactoryHash(),
+          owner: sellerOwner,
+          baseAsset: lbeV2Parameters.baseAsset,
+          raiseAsset: lbeV2Parameters.raiseAsset,
+          amount: 0n,
+          penaltyAmount: 0n,
+        })
+      );
+      sellerOutputs.push(txOut);
+    }
+
+    const mintValue = new Value()
+      .add(warehouse.getFactoryAsset(), 1n)
+      .add(warehouse.getTreasuryAsset(), 1n)
+      .add(warehouse.getManagerAsset(), 1n)
+      .add(warehouse.getSellerAsset(), BigInt(sellerCount));
+
+    const validTo = Math.min(
+      Number(lbeV2Parameters.startTime) - 1,
+      Date.now() + Duration.newHours(3).milliseconds
+    );
+
+    const txb: TxBuilderV2 = new TxBuilderV2(networkEnv);
+    txb
+      .readFrom(warehouse.getFactoryRefInput())
+      .collectFromPlutusContract([factoryUtxo], wrapperFactoryRedeemer)
+      .payTo(factoryHeadOutput)
+      .payTo(factoryTailOutput)
+      .payTo(treasuryOutput)
+      .payTo(managerOutput)
+      .payTo(...sellerOutputs)
+      .mintAssets(mintValue, factoryRedeemer)
+      .validToUnixTime(validTo)
+      .addMessageMetadata("msg", [MetadataMessage.LBE_V2_CREATE_EVENT])
+      .addMessageMetadata("extraData", projectDetails ?? []);
+
+    if (Maybe.isJust(treasuryDatum.owner.toPubKeyHash())) {
+      txb.addSigner(treasuryDatum.owner);
+    }
+
+    if (sponsorship) {
+      const sellerFees = new Value();
+      for (let i = 0; i < sellerCount; i++) {
+        sellerFees.add(ADA, warehouse.getDefaultSellerValue().get(ADA));
+      }
+      const sResult = Sponsorship.validate({
+        sponsorship,
+        requiredValue: sellerFees,
+      });
+      if (sResult.type === "ok") {
+        txb.collectFromPubKey(...sponsorship.utxos);
+        txb.payTo(...sponsorship.changeOutputs);
+      } else {
+        throw sResult.error;
+      }
+    }
+
+    return txb;
+  }
+}

src/types/common.ts

@@ -0,0 +1,77 @@
+import { Constr, Data } from "lucid-cardano";
+
+export namespace Options {
+  export function toPlutusData<T>(
+    data: T | undefined,
+    toPlutusDataFn: (data: T) => Data
+  ): Constr<Data> {
+    return data !== undefined
+      ? new Constr(0, [toPlutusDataFn(data)])
+      : new Constr(1, []);
+  }
+
+  export function fromPlutusData<T>(
+    data: Constr<Data>,
+    fromPlutusDataFn: (data: Constr<Data>) => T
+  ): T | undefined {
+    switch (data.index) {
+      case 0: {
+        return fromPlutusDataFn(data.fields[0] as Constr<Data>);
+      }
+      case 1: {
+        return undefined;
+      }
+      default: {
+        throw Error(`Index of Options must be 0 or 1, actual: ${data.index}`);
+      }
+    }
+  }
+}
+
+export namespace Dummy {
+  export function toPlutusData(x: Data): Data {
+    return x;
+  }
+  export function fromPlutusData<T>(x: Data): T {
+    return x as T;
+  }
+}
+
+export namespace Bool {
+  export function toPlutusData(data: boolean): Constr<Data> {
+    return data ? new Constr(1, []) : new Constr(0, []);
+  }
+
+  export function fromPlutusData(data: Constr<Data>): boolean {
+    switch (data.index) {
+      case 0: {
+        return false;
+      }
+      case 1: {
+        return true;
+      }
+      default: {
+        throw Error(`Index of Bool must be 0 or 1, actual: ${data.index}`);
+      }
+    }
+  }
+}
+
+export namespace RedeemerWrapper {
+  export function toPlutusData(d: Data): Data {
+    return new Constr(1, [d]);
+  }
+
+  export function fromPlutusData(data: Constr<Data>): Data {
+    switch (data.index) {
+      case 1: {
+        return data.fields[0];
+      }
+      default: {
+        throw Error(
+          `Index of RedeemerWrapper must be 1, actual: ${data.index}`
+        );
+      }
+    }
+  }
+}

src/types/constants.ts

@@ -579,8 +579,10 @@ export namespace LbeV2Constant {
   export const MINIMUM_ORDER_COLLECTED = 30n;
   export const MINIMUM_ORDER_REDEEMED = 30n;
 
-  export const MAX_DISCOVERY_RANGE = "30D in ms";
-  export const MAX_PENALTY_RANGE = "2D in ms";
+  export const MAX_DISCOVERY_RANGE = 2592000000n;
+  export const MAX_PENALTY_RANGE = 172800000n;
+
+  export const DEFAULT_SELLER_COUNT = 20n;
 
   export type Config = {
     factoryAsset: string;

src/types/lbe-v2.ts

@@ -2,6 +2,7 @@ import { Address, Constr, Data } from "lucid-cardano";
 
 import { Asset, LbeV2Constant, NetworkId } from "..";
 import { AddressPlutusData } from "./address.internal";
+import { Bool, Dummy, Options } from "./common";
 export namespace LbeV2Types {
   export enum ReceiverDatumType {
     NO_DATUM = 0,
@@ -118,63 +119,6 @@ export namespace LbeV2Types {
     isManagerCollected: boolean;
   };
 
-  export namespace Options {
-    export function toPlutusData<T>(
-      data: T | undefined,
-      toPlutusDataFn: (data: T) => Data
-    ): Constr<Data> {
-      return data !== undefined
-        ? new Constr(0, [toPlutusDataFn(data)])
-        : new Constr(1, []);
-    }
-
-    export function fromPlutusData<T>(
-      data: Constr<Data>,
-      fromPlutusDataFn: (data: Constr<Data>) => T
-    ): T | undefined {
-      switch (data.index) {
-        case 0: {
-          return fromPlutusDataFn(data.fields[0] as Constr<Data>);
-        }
-        case 1: {
-          return undefined;
-        }
-        default: {
-          throw Error(`Index of Options must be 0 or 1, actual: ${data.index}`);
-        }
-      }
-    }
-  }
-
-  export namespace Dummy {
-    export function toPlutusData(x: Data): Data {
-      return x;
-    }
-    export function fromPlutusData<T>(x: Data): T {
-      return x as T;
-    }
-  }
-
-  export namespace Bool {
-    export function toPlutusData(data: boolean): Constr<Data> {
-      return data ? new Constr(1, []) : new Constr(0, []);
-    }
-
-    export function fromPlutusData(data: Constr<Data>): boolean {
-      switch (data.index) {
-        case 0: {
-          return false;
-        }
-        case 1: {
-          return true;
-        }
-        default: {
-          throw Error(`Index of Bool must be 0 or 1, actual: ${data.index}`);
-        }
-      }
-    }
-  }
-
   export namespace TreasuryDatum {
     export function toPlutusData(datum: TreasuryDatum): Constr<Data> {
       const {
@@ -304,6 +248,55 @@ export namespace LbeV2Types {
     }
   }
 
+  export enum TreasuryRedeemerType {
+    COLLECT_MANAGER = 0,
+    COLLECT_ORDERS = 1,
+    CREATE_AMM_POOL = 2,
+    REDEEM_ORDERS = 3,
+    CLOSE_EVENT = 4,
+    CANCEL_LBE = 5,
+    UPDATE_LBE = 6,
+  }
+
+  export enum CancelReason {
+    CREATED_POOL = 0,
+    BY_OWNER = 1,
+    NOT_REACH_MINIMUM = 2,
+  }
+
+  export type TreasuryRedeemer =
+    | {
+        type:
+          | TreasuryRedeemerType.COLLECT_MANAGER
+          | TreasuryRedeemerType.COLLECT_ORDERS
+          | TreasuryRedeemerType.CREATE_AMM_POOL
+          | TreasuryRedeemerType.REDEEM_ORDERS
+          | TreasuryRedeemerType.CLOSE_EVENT
+          | TreasuryRedeemerType.UPDATE_LBE;
+      }
+    | {
+        type: TreasuryRedeemerType.CANCEL_LBE;
+        reason: CancelReason;
+      };
+
+  export namespace TreasuryRedeemer {
+    export function toPlutusData(data: TreasuryRedeemer): Constr<Data> {
+      switch (data.type) {
+        case TreasuryRedeemerType.COLLECT_MANAGER:
+        case TreasuryRedeemerType.COLLECT_ORDERS:
+        case TreasuryRedeemerType.CREATE_AMM_POOL:
+        case TreasuryRedeemerType.REDEEM_ORDERS:
+        case TreasuryRedeemerType.CLOSE_EVENT:
+        case TreasuryRedeemerType.UPDATE_LBE: {
+          return new Constr(data.type, []);
+        }
+        case TreasuryRedeemerType.CANCEL_LBE: {
+          return new Constr(data.type, [new Constr(data.reason, [])]);
+        }
+      }
+    }
+  }
+
   export type LbeV2Parameters = {
     baseAsset: Asset;
     reserveBase: bigint;
@@ -388,6 +381,59 @@ export namespace LbeV2Types {
       }
     }
   }
+  export enum FactoryRedeemerType {
+    INITIALIZATION = 0,
+    CREATE_TREASURY = 1,
+    CLOSE_TREASURY = 2,
+    MINT_MANAGER = 3,
+    MINT_SELLER = 4,
+    BURN_SELLER = 5,
+    MINT_ORDER = 6,
+    MINT_REDEEM_ORDERS = 7,
+    MANAGE_ORDER = 8,
+  }
+
+  export type FactoryRedeemer =
+    | {
+        type:
+          | FactoryRedeemerType.INITIALIZATION
+          | FactoryRedeemerType.MINT_MANAGER
+          | FactoryRedeemerType.MINT_SELLER
+          | FactoryRedeemerType.BURN_SELLER
+          | FactoryRedeemerType.MINT_ORDER
+          | FactoryRedeemerType.MINT_REDEEM_ORDERS
+          | FactoryRedeemerType.MANAGE_ORDER;
+      }
+    | {
+        type:
+          | FactoryRedeemerType.CREATE_TREASURY
+          | FactoryRedeemerType.CLOSE_TREASURY;
+        baseAsset: Asset;
+        raiseAsset: Asset;
+      };
+
+  export namespace FactoryRedeemer {
+    export function toPlutusData(data: FactoryRedeemer): Constr<Data> {
+      switch (data.type) {
+        case FactoryRedeemerType.INITIALIZATION:
+        case FactoryRedeemerType.MINT_MANAGER:
+        case FactoryRedeemerType.MINT_SELLER:
+        case FactoryRedeemerType.BURN_SELLER:
+        case FactoryRedeemerType.MINT_ORDER:
+        case FactoryRedeemerType.MINT_REDEEM_ORDERS:
+        case FactoryRedeemerType.MANAGE_ORDER: {
+          return new Constr(data.type, []);
+        }
+        case FactoryRedeemerType.CREATE_TREASURY:
+        case FactoryRedeemerType.CLOSE_TREASURY: {
+          return new Constr(data.type, [
+            Asset.toPlutusData(data.baseAsset),
+            Asset.toPlutusData(data.raiseAsset),
+          ]);
+        }
+      }
+    }
+  }
 
   export type ManagerDatum = {
     factoryPolicyId: string;
@@ -430,6 +476,17 @@ export namespace LbeV2Types {
     }
   }
 
+  export enum ManagerRedeemer {
+    ADD_SELLERS = 0,
+    COLLECT_SELLERS = 1,
+    SPEND_MANAGER = 2,
+  }
+  export namespace ManagerRedeemer {
+    export function toPlutusData(data: ManagerRedeemer): Constr<Data> {
+      return new Constr(data, []);
+    }
+  }
+
   export type SellerDatum = {
     factoryPolicyId: string;
     owner: Address;
@@ -477,6 +534,17 @@ export namespace LbeV2Types {
     }
   }
 
+  export enum SellerRedeemer {
+    USING_SELLER = 0,
+    COUNTING_SELLERS = 1,
+  }
+
+  export namespace SellerRedeemer {
+    export function toPlutusData(data: SellerRedeemer): Constr<Data> {
+      return new Constr(data, []);
+    }
+  }
+
   export type OrderDatum = {
     factoryPolicyId: string;
     baseAsset: Asset;
@@ -526,4 +594,16 @@ export namespace LbeV2Types {
       }
     }
   }
+
+  export enum OrderRedeemer {
+    UPDATE_ORDER = 0,
+    COLLECT_ORDER = 1,
+    REDEEM_ORDER = 2,
+  }
+
+  export namespace OrderRedeemer {
+    export function toPlutusData(data: OrderRedeemer): Constr<Data> {
+      return new Constr(data, []);
+    }
+  }
 }