[DRAFT] Stateful testing setup

Clarinet.toml

@@ -4,7 +4,9 @@ description = ''
 authors = []
 telemetry = true
 cache_dir = './.cache'
-requirements = []
+
+[[project.requirements]]
+contract_id = 'ST27PT00YS01KBAEEETAH45C1H46C3FMJR31SN2S3.TESTNET-BNS-V2'
 [contracts.BNS-V2]
 path = 'contracts/BNS-V2.clar'
 clarity_version = 2

deployments/default.simnet-plan.yaml

@@ -48,6 +48,24 @@ genesis:
 plan:
   batches:
     - id: 0
+      transactions:
+        - emulated-contract-publish:
+            contract-name: commission-trait
+            emulated-sender: ST27PT00YS01KBAEEETAH45C1H46C3FMJR31SN2S3
+            path: "./.cache/requirements/ST27PT00YS01KBAEEETAH45C1H46C3FMJR31SN2S3.commission-trait.clar"
+            clarity-version: 1
+        - emulated-contract-publish:
+            contract-name: sip-09
+            emulated-sender: ST27PT00YS01KBAEEETAH45C1H46C3FMJR31SN2S3
+            path: "./.cache/requirements/ST27PT00YS01KBAEEETAH45C1H46C3FMJR31SN2S3.sip-09.clar"
+            clarity-version: 1
+        - emulated-contract-publish:
+            contract-name: TESTNET-BNS-V2
+            emulated-sender: ST27PT00YS01KBAEEETAH45C1H46C3FMJR31SN2S3
+            path: "./.cache/requirements/ST27PT00YS01KBAEEETAH45C1H46C3FMJR31SN2S3.TESTNET-BNS-V2.clar"
+            clarity-version: 1
+      epoch: "2.1"
+    - id: 1
       transactions:
         - emulated-contract-publish:
             contract-name: commission-trait

package.json

@@ -15,6 +15,7 @@
     "@hirosystems/clarinet-sdk": "^2.5.0",
     "@stacks/transactions": "^6.12.0",
     "chokidar-cli": "^3.0.0",
+    "fast-check": "^3.20.0",
     "typescript": "^5.3.3",
     "vite": "^5.1.4",
     "vitest": "^1.3.1",

tests/BNS-V2.helper.ts

@@ -129,3 +129,20 @@ export const invalidNameBuffSalt = createHash160Name(
   namespaceBuff,
   saltBuff
 );
+
+export const prettyConsoleLog = (...items: (string | undefined)[]) => {
+  // Ensure we only render up to the first 10 items for brevity.
+  const renderItems = items.slice(0, 10);
+  const columnWidth = 30; // Standard width for each column after the first two.
+  const halfColumns = Math.floor(columnWidth / 2);
+
+  // Pad columns to their widths: half for the first two, full for the rest.
+  const prettyPrint = renderItems.map((content, index) =>
+    // Check if the index is less than 2 (i.e., first two items).
+    content
+      ? (index < 2 ? content.padEnd(halfColumns + 2) : content.padEnd(columnWidth))
+      : (index < 2 ? "".padEnd(halfColumns) : "".padEnd(columnWidth))
+  );
+
+  console.log(prettyPrint.join(""));
+};

tests/BNS-V2.stateful.test.ts

@@ -0,0 +1,63 @@
+import fc from "fast-check";
+import { it } from "vitest";
+
+import { GetLastTokenId } from "./state/GetLastTokenId.ts";
+import { GetOwnerNone } from "./state/GetOwnerNone.ts";
+import { GetBnsFromIdNone } from "./state/GetBnsFromIdNone.ts";
+import { GetPrimaryNameNone } from "./state/GetPrimaryNameNone.ts";
+import { GetNamespacePropertiesErr } from "./state/GetNamespacePropertiesErr.ts";
+import { GetNamespacePrice } from "./state/GetNamespacePrice.ts";
+import { CanNamespaceBeRegisteredTrue } from "./state/CanNamespaceBeRegistered.ts";
+import { NamespacePreorder } from "./state/NamespacePreorder.ts";
+import { NamespaceReveal } from "./state/NamespaceReveal.ts";
+import { GetBnsInfoNone } from "./state/GetBnsInfoNone.ts";
+import { MngNamePreorder } from "./state/MngNamePreorder.ts";
+
+it("executes BNS-V2 state interactions", async () => {
+  const excludedAccounts = ["faucet", "deployer"];
+  const filteredAccounts = new Map(
+    [...simnet.getAccounts()].filter(([key]) =>
+      !excludedAccounts.includes(key)
+    ),
+  );
+
+  const model = {
+    burnBlockHeight: 0,
+    lastTokenId: 0,
+    owners: new Map(),
+    indexToName: new Map(),
+    nameToIndex: new Map(),
+    nameProperties: new Map(),
+    namespaces: new Map(),
+    namespaceProperties: new Map(),
+    namespaceSinglePreorder: new Map(),
+    nameSinglePreorder: new Map(),
+    namespacePreorders: new Map(),
+    namePreorders: new Map(),
+  };
+
+  const invariants = [
+    GetLastTokenId(filteredAccounts),
+    GetOwnerNone(filteredAccounts),
+    GetBnsFromIdNone(filteredAccounts),
+    GetPrimaryNameNone(filteredAccounts),
+    GetNamespacePropertiesErr(filteredAccounts),
+    GetNamespacePrice(filteredAccounts),
+    GetBnsInfoNone(filteredAccounts),
+    CanNamespaceBeRegisteredTrue(filteredAccounts),
+    NamespacePreorder(filteredAccounts),
+    { arbitrary: MngNamePreorder(filteredAccounts), weight: 3 },
+    NamespaceReveal(filteredAccounts, model),
+  ];
+
+  fc.assert(
+    fc.property(
+      fc.array(fc.oneof(...invariants), { size: "medium" }),
+      (cmds) => {
+        const state = () => ({ model, real: simnet });
+        fc.modelRun(state, cmds);
+      },
+    ),
+    { numRuns: 100, verbose: fc.VerbosityLevel.VeryVerbose },
+  );
+});

tests/state/CanNamespaceBeRegistered.ts

@@ -0,0 +1,57 @@
+import fc from "fast-check";
+import { Model } from "./types";
+import { Simnet } from "@hirosystems/clarinet-sdk";
+import { expect } from "vitest";
+import { Cl } from "@stacks/transactions";
+import { encoder, prettyConsoleLog } from "../BNS-V2.helper";
+
+const NAMESPACE_LAUNCHABILITY_TTL = 52595;
+
+export const CanNamespaceBeRegisteredTrue = (accounts: Map<string, string>) =>
+  fc
+    .record({
+      sender: fc.constantFrom(...accounts),
+      namespace: fc.string({ maxLength: 20 }),
+    })
+    .map((r) => ({
+      check: (model: Readonly<Model>) => {
+        const namespace = model.namespaces.get(r.namespace);
+
+        if (
+          !namespace ||
+          (!namespace.launchedAt &&
+            model.burnBlockHeight + 1 >
+              (namespace?.revealedAt || 0) + NAMESPACE_LAUNCHABILITY_TTL) ||
+          !namespace.revealedAt
+        ) {
+          return true;
+        }
+
+        return false;
+      },
+      run: (_model: Model, real: Simnet) => {
+        const [wallet, address] = r.sender;
+        const namespaceBuff = encoder.encode(r.namespace);
+        // Act
+        const { result: canRegisterNamespaceResponse } = real.callReadOnlyFn(
+          "ST27PT00YS01KBAEEETAH45C1H46C3FMJR31SN2S3.TESTNET-BNS-V2",
+          "can-namespace-be-registered",
+          [Cl.buffer(namespaceBuff)],
+          address,
+        );
+
+        // Assert
+        expect(canRegisterNamespaceResponse).toBeOk(Cl.bool(true));
+
+        prettyConsoleLog(
+          "Ӿ tx-sender",
+          wallet,
+          "✓",
+          "can-namespace-be-registered",
+          `namespace: "${r.namespace}"`,
+          "response: (ok true)",
+        );
+      },
+      toString: () =>
+        `can-namespace-be-registered namespace "${r.namespace}" response (ok true)`,
+    }));

tests/state/GetBnsFromIdNone.ts

@@ -0,0 +1,44 @@
+import fc from "fast-check";
+import { Model } from "./types";
+import { Simnet } from "@hirosystems/clarinet-sdk";
+import { expect } from "vitest";
+import { Cl } from "@stacks/transactions";
+import { prettyConsoleLog } from "../BNS-V2.helper";
+
+export const GetBnsFromIdNone = (accounts: Map<string, string>) =>
+  fc
+    .record({
+      sender: fc.constantFrom(...accounts),
+      tokenId: fc.integer({ min: 1 }),
+    })
+    .map((r) => ({
+      check: (model: Readonly<Model>) => {
+        return (
+          !(model.lastTokenId >= r.tokenId) ||
+          !(model.indexToName.has(r.tokenId))
+        );
+      },
+      run: (_model: Model, real: Simnet) => {
+        const [wallet, address] = r.sender;
+        // Act
+        const { result: bnsOptional } = real.callReadOnlyFn(
+          "ST27PT00YS01KBAEEETAH45C1H46C3FMJR31SN2S3.TESTNET-BNS-V2",
+          "get-bns-from-id",
+          [Cl.uint(r.tokenId)],
+          address,
+        );
+
+        // Assert
+        expect(bnsOptional).toBeNone();
+
+        prettyConsoleLog(
+          "Ӿ tx-sender",
+          wallet,
+          "✓",
+          "get-bns-from-id",
+          `token-id: ${r.tokenId}`,
+          "bns: none",
+        );
+      },
+      toString: () => `get-bns-from-id token-id ${r.tokenId} bns none`,
+    }));

tests/state/GetBnsInfoNone.ts

@@ -0,0 +1,55 @@
+import fc from "fast-check";
+import { Model } from "./types";
+import { Simnet } from "@hirosystems/clarinet-sdk";
+import { expect } from "vitest";
+import { Cl } from "@stacks/transactions";
+import { encoder, prettyConsoleLog } from "../BNS-V2.helper";
+
+export const GetBnsInfoNone = (accounts: Map<string, string>) =>
+  fc
+    .record({
+      sender: fc.constantFrom(...accounts),
+      namespace: fc.string({ maxLength: 20 }),
+      name: fc.string({ maxLength: 48 }),
+    })
+    .map((r) => ({
+      check: (model: Readonly<Model>) => {
+        return !model.nameProperties.has(
+          JSON.stringify({
+            name: r.name,
+            namespace: r.namespace,
+          })
+        );
+      },
+      run: (_model: Readonly<Model>, real: Simnet) => {
+        const [wallet, address] = r.sender;
+        const nameBuff = encoder.encode(r.name);
+        const namespaceBuff = encoder.encode(r.namespace);
+
+        // Act
+        const { result: getBnsInfoResponse } = real.callReadOnlyFn(
+          "ST27PT00YS01KBAEEETAH45C1H46C3FMJR31SN2S3.TESTNET-BNS-V2",
+          "get-bns-info",
+          [
+            // (name (buff 48))
+            Cl.buffer(nameBuff),
+            // (namespace (buff 20))
+            Cl.buffer(namespaceBuff),
+          ],
+          address
+        );
+
+        expect(getBnsInfoResponse).toBeNone();
+
+        prettyConsoleLog(
+          "Ӿ tx-sender",
+          wallet,
+          "✓",
+          "get-bns-info",
+          `name: "${r.name}"`,
+          `namespace: "${r.namespace}"`,
+          `bns info: none`
+        );
+      },
+      toString: () => `get-bns-info name ${r.name} namespace ${r.namespace}`,
+    }));

tests/state/GetIdFromBnsNone.ts

@@ -0,0 +1,52 @@
+import fc from "fast-check";
+import { Model } from "./types";
+import { Simnet } from "@hirosystems/clarinet-sdk";
+import { expect } from "vitest";
+import { Cl } from "@stacks/transactions";
+import { encoder, prettyConsoleLog } from "../BNS-V2.helper";
+
+export const getIdFromBnsNone = (accounts: Map<string, string>) =>
+  fc
+    .record({
+      sender: fc.constantFrom(...accounts),
+      namespace: fc.string({ maxLength: 20 }),
+      name: fc.string({ maxLength: 48 }),
+    })
+    .map((r) => ({
+      check: (model: Readonly<Model>) => {
+        return !model.nameToIndex.has(
+          JSON.stringify({ name: r.name, namespace: r.namespace })
+        );
+      },
+      run: (_model: Readonly<Model>, real: Simnet) => {
+        const [wallet, address] = r.sender;
+        const nameBuff = encoder.encode(r.name);
+        const namespaceBuff = encoder.encode(r.namespace);
+
+        // Act
+        const { result: getIdFromBnsResponse } = real.callReadOnlyFn(
+          "ST27PT00YS01KBAEEETAH45C1H46C3FMJR31SN2S3.TESTNET-BNS-V2",
+          "get-bns-info",
+          [
+            // (name (buff 48))
+            Cl.buffer(nameBuff),
+            // (namespace (buff 20))
+            Cl.buffer(namespaceBuff),
+          ],
+          address
+        );
+
+        expect(getIdFromBnsResponse).toBeNone();
+
+        prettyConsoleLog(
+          "Ӿ tx-sender",
+          wallet,
+          "✓",
+          "get-id-from-bns",
+          `name: "${r.name}"`,
+          `namespace: "${r.namespace}"`,
+          `id: none`
+        );
+      },
+      toString: () => `get-id-from-bns name ${r.name} namespace ${r.namespace}`,
+    }));