@clarigen/test 1.0.0-next.9 → 1.0.0

package/dist/index.mjs

@@ -0,0 +1,443 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// src/index.ts
+import {
+  deployContract as deployContract2,
+  createClarityBin
+} from "@clarigen/native-bin";
+import {
+  getContractIdentifier,
+  expectOk,
+  expectErr
+} from "@clarigen/core";
+
+// src/utils/index.ts
+import { publicKeyToStxAddress, StacksNetworkVersion } from "micro-stacks/crypto";
+import { getPublicKeyFromStacksPrivateKey, makeRandomPrivKey } from "micro-stacks/transactions";
+
+// src/utils/util-contract.ts
+import { hexToCV } from "micro-stacks/clarity";
+import { join } from "path";
+import { cvToValue } from "@clarigen/core";
+import { deployContract, evalJson, executeJson } from "@clarigen/native-bin";
+import { intToBigInt } from "micro-stacks/common";
+var UTIL_CONTRACT_ID = "ST000000000000000000002AMW42H.clarigen-test-utils";
+async function deployUtilContract(clarityBin) {
+  let contractFilePath = join(__dirname, "..", "..", "contracts", "test-utils.clar");
+  if (__dirname.includes("dist")) {
+    contractFilePath = join(__dirname, "..", "contracts", "test-utils.clar");
+  }
+  await deployContract({
+    contractIdentifier: UTIL_CONTRACT_ID,
+    provider: clarityBin,
+    contractFilePath
+  });
+}
+function getBin(provider) {
+  return "clarityBin" in provider ? provider.clarityBin : provider;
+}
+async function getBlockHeight(provider) {
+  const bin = getBin(provider);
+  const { output_serialized } = await evalJson({
+    contractAddress: UTIL_CONTRACT_ID,
+    functionName: "get-block-height",
+    args: [],
+    provider: bin
+  });
+  const outputCV = hexToCV(output_serialized);
+  const blockHeight = cvToValue(outputCV);
+  return blockHeight;
+}
+async function mineBlock(provider) {
+  const bin = getBin(provider);
+  await executeJson({
+    contractAddress: UTIL_CONTRACT_ID,
+    functionName: "mine-block",
+    args: [],
+    provider: bin,
+    senderAddress: "ST000000000000000000002AMW42H"
+  });
+}
+async function mineBlocks(_blocks, provider) {
+  const blocks = intToBigInt(_blocks);
+  for (let index = 0; index < blocks; index++) {
+    await mineBlock(provider);
+  }
+}
+async function getStxBalance(provider, account) {
+  const bin = getBin(provider);
+  const { output_serialized } = await evalJson({
+    contractAddress: UTIL_CONTRACT_ID,
+    functionName: "get-stx-balance",
+    args: [`'${account}`],
+    provider: bin
+  });
+  const outputCV = hexToCV(output_serialized);
+  const balance = cvToValue(outputCV);
+  return balance;
+}
+
+// src/utils/coverage.ts
+import { mkdir, readdir, unlink } from "fs/promises";
+import { join as join2, resolve } from "path";
+async function setupCoverage(dir) {
+  const dirName = resolve(process.cwd(), "coverage");
+  try {
+    await mkdir(dirName);
+  } catch (error) {
+  }
+  const files = await readdir(dirName);
+  const removals = files.map((file) => {
+    return unlink(join2(dirName, file));
+  });
+  await Promise.all(removals);
+  return dirName;
+}
+async function finishCoverage(provider, dir) {
+  const lcovFile = join2(dir, "clarigen.lcov");
+  await provider.runCommand(["make_lcov", dir, lcovFile]);
+}
+
+// src/utils/index.ts
+function makeRandomAddress(version = StacksNetworkVersion.testnetP2PKH) {
+  const privateKey = makeRandomPrivKey();
+  const publicKey = getPublicKeyFromStacksPrivateKey(privateKey);
+  const address = publicKeyToStxAddress(publicKey.data, version);
+  return address;
+}
+
+// src/utils/pure.ts
+import {
+  cvToString,
+  cvToValue as cvToValue2,
+  filterEvents,
+  CoreNodeEventType,
+  ok,
+  err
+} from "@clarigen/core";
+import {
+  evalRaw,
+  evalJson as evalJson2,
+  executeJson as executeJson2
+} from "@clarigen/native-bin";
+import {
+  hexToCV as hexToCV2,
+  responseErrorCV,
+  responseOkCV
+} from "micro-stacks/clarity";
+function getPrints(events) {
+  return filterEvents(events, CoreNodeEventType.ContractEvent).map((e) => {
+    const hex = e.contract_event.raw_value;
+    const cv = hexToCV2(hex);
+    return cvToValue2(cv);
+  });
+}
+function formatArguments(args) {
+  return args.map((arg) => cvToString(arg));
+}
+function getIdentifier(tx2) {
+  return `${tx2.contractAddress}.${tx2.contractName}`;
+}
+function getLogs(stderr) {
+  if (stderr === "")
+    return [];
+  return stderr.split("\n").map((line) => line.slice(62));
+}
+function makeEvalResult(result) {
+  const resultCV = hexToCV2(result.output_serialized);
+  const value = cvToValue2(resultCV, true);
+  return {
+    value,
+    clarityValue: resultCV,
+    logs: getLogs(result.stderr),
+    costs: result.costs
+  };
+}
+async function ro({
+  tx: tx2,
+  bin,
+  coverageFolder
+}) {
+  const result = await evalJson2({
+    functionName: tx2.function.name,
+    args: formatArguments(tx2.functionArgs),
+    contractAddress: getIdentifier(tx2),
+    provider: bin,
+    coverageFolder
+  });
+  return makeEvalResult(result);
+}
+async function evalCode({
+  contractAddress,
+  code,
+  bin,
+  coverageFolder
+}) {
+  const result = await evalRaw({
+    contractAddress,
+    code,
+    provider: bin,
+    coverageFolder
+  });
+  return makeEvalResult(result);
+}
+async function tx({
+  tx: tx2,
+  senderAddress,
+  bin,
+  coverageFolder
+}) {
+  const result = await executeJson2({
+    contractAddress: getIdentifier(tx2),
+    senderAddress,
+    provider: bin,
+    functionName: tx2.function.name,
+    args: formatArguments(tx2.functionArgs),
+    coverageFolder
+  });
+  const resultCV = hexToCV2(result.output_serialized);
+  const value = cvToValue2(resultCV);
+  const resp = result.success ? ok(value) : err(value);
+  const baseReturn = {
+    logs: getLogs(result.stderr),
+    costs: result.costs,
+    value: resp
+  };
+  if (result.success) {
+    return __spreadProps(__spreadValues({}, baseReturn), {
+      isOk: true,
+      response: responseOkCV(resultCV),
+      assets: result.assets,
+      events: result.events,
+      prints: getPrints(result.events)
+    });
+  }
+  return __spreadProps(__spreadValues({}, baseReturn), {
+    isOk: false,
+    response: responseErrorCV(resultCV)
+  });
+}
+async function mapGet({
+  map,
+  bin
+}) {
+  const code = `(map-get? ${map.map.name} ${cvToString(map.key)})`;
+  const result = await evalCode({
+    contractAddress: getIdentifier(map),
+    code,
+    bin
+  });
+  return result.value;
+}
+
+// src/index.ts
+import { resolve as resolve2 } from "path";
+
+// src/utils/test-factory.ts
+import {
+  projectFactory
+} from "@clarigen/core";
+function testFactory(project) {
+  return projectFactory(project, "simnet");
+}
+
+// src/index.ts
+import { Allocation, createClarityBin as createClarityBin2, executeJson as executeJson3, evalJson as evalJson3 } from "@clarigen/native-bin";
+var TestProvider = class {
+  constructor(clarityBin) {
+    this.clarityBin = clarityBin;
+  }
+  static async fromContracts(contracts, options = {}) {
+    const clarityBin = options.clarityBin || await createClarityBin({
+      allocations: options.accounts
+    });
+    const instances = {};
+    let coverageFolder = options.coverageFolder;
+    if (process.env.CLARIGEN_COVERAGE) {
+      coverageFolder = resolve2(process.cwd(), "coverage");
+    }
+    await deployUtilContract(clarityBin);
+    for (const k in contracts) {
+      if (Object.prototype.hasOwnProperty.call(contracts, k)) {
+        const contract = contracts[k];
+        const identifier = getContractIdentifier(contract);
+        await deployContract2({
+          contractIdentifier: identifier,
+          contractFilePath: contract.contractFile,
+          provider: clarityBin,
+          coverageFolder
+        });
+        const instance = contract.contract(contract.address, contract.name);
+        instances[k] = {
+          identifier: getContractIdentifier(contract),
+          contract: instance
+        };
+      }
+    }
+    const provider = new this(clarityBin);
+    provider.coverageFolder = coverageFolder;
+    return {
+      deployed: instances,
+      provider
+    };
+  }
+  static async fromProject(simnet, options = {}) {
+    const allocations = Object.fromEntries(Object.entries(simnet.accounts).map(([name, account]) => {
+      return [name, __spreadProps(__spreadValues({}, account), { balance: BigInt(account.balance) })];
+    }));
+    const clarityBin = options.clarityBin || await createClarityBin({
+      allocations
+    });
+    let coverageFolder = options.coverageFolder;
+    if (process.env.CLARIGEN_COVERAGE) {
+      coverageFolder = resolve2(process.cwd(), "coverage");
+    }
+    await deployUtilContract(clarityBin);
+    for (const contract of simnet.deployment) {
+      let contractFilePath = contract.file;
+      if (options.clarinetPath) {
+        contractFilePath = resolve2(process.cwd(), options.clarinetPath, contractFilePath);
+      }
+      await deployContract2({
+        contractIdentifier: contract.identifier,
+        contractFilePath,
+        provider: clarityBin,
+        coverageFolder
+      });
+    }
+    const provider = new this(clarityBin);
+    provider.coverageFolder = coverageFolder;
+    return provider;
+  }
+  static async fromFactory(contracts, options = {}) {
+    const clarityBin = options.clarityBin || await createClarityBin({
+      allocations: options.accounts
+    });
+    let coverageFolder = options.coverageFolder;
+    if (process.env.CLARIGEN_COVERAGE) {
+      coverageFolder = resolve2(process.cwd(), "coverage");
+    }
+    await deployUtilContract(clarityBin);
+    for (const k in contracts) {
+      if (Object.prototype.hasOwnProperty.call(contracts, k)) {
+        const contract = contracts[k];
+        let contractFilePath = contract.contractFile;
+        if (options.clarinetPath) {
+          contractFilePath = resolve2(process.cwd(), options.clarinetPath, contractFilePath);
+        }
+        if (typeof contractFilePath === "undefined") {
+          throw new Error("Cannot setup @clarigen/test - missing contract file.");
+        }
+        await deployContract2({
+          contractIdentifier: contract.identifier,
+          contractFilePath,
+          provider: clarityBin,
+          coverageFolder
+        });
+      }
+    }
+    const provider = new this(clarityBin);
+    provider.coverageFolder = coverageFolder;
+    return provider;
+  }
+  ro(tx2) {
+    return ro({ tx: tx2, bin: this.clarityBin, coverageFolder: this.coverageFolder });
+  }
+  async rov(tx2) {
+    const result = await this.ro(tx2);
+    return result.value;
+  }
+  async roOk(tx2) {
+    const result = await this.ro(tx2);
+    const value = expectOk(result.value);
+    return __spreadProps(__spreadValues({}, result), {
+      value
+    });
+  }
+  async roErr(tx2) {
+    const result = await this.ro(tx2);
+    const value = expectErr(result.value);
+    return __spreadProps(__spreadValues({}, result), {
+      value
+    });
+  }
+  async rovOk(tx2) {
+    return (await this.roOk(tx2)).value;
+  }
+  async rovErr(tx2) {
+    return (await this.roErr(tx2)).value;
+  }
+  tx(tx2, senderAddress) {
+    return tx({
+      tx: tx2,
+      senderAddress,
+      bin: this.clarityBin,
+      coverageFolder: this.coverageFolder
+    });
+  }
+  async txOk(tx2, senderAddress) {
+    const result = await this.tx(tx2, senderAddress);
+    const value = expectOk(result.value);
+    if (!result.isOk)
+      throw new Error(`Expected OK, received error: ${String(result.value)}`);
+    return __spreadProps(__spreadValues({}, result), {
+      value
+    });
+  }
+  async txErr(tx2, senderAddress) {
+    const result = await this.tx(tx2, senderAddress);
+    const value = expectErr(result.value);
+    if (result.isOk)
+      throw new Error(`Expected Err, received ok: ${String(result.value)}`);
+    return __spreadProps(__spreadValues({}, result), {
+      value
+    });
+  }
+  evalCode(code, contractAddress = UTIL_CONTRACT_ID) {
+    return evalCode({
+      contractAddress,
+      code,
+      bin: this.clarityBin,
+      coverageFolder: this.coverageFolder
+    });
+  }
+  async eval(code, contractAddress = UTIL_CONTRACT_ID) {
+    const result = await this.evalCode(code, contractAddress);
+    return result.value;
+  }
+  mapGet(map) {
+    return mapGet({ map, bin: this.clarityBin });
+  }
+};
+export {
+  Allocation,
+  TestProvider,
+  createClarityBin2 as createClarityBin,
+  evalJson3 as evalJson,
+  executeJson3 as executeJson,
+  finishCoverage,
+  getBlockHeight,
+  getStxBalance,
+  makeRandomAddress,
+  mineBlocks,
+  setupCoverage,
+  testFactory
+};

package/package.json

@@ -1,8 +1,10 @@
 {
-  "version": "1.0.0-next.9",
+  "version": "1.0.0",
   "license": "MIT",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "types": "./dist/index.d.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "import": "./dist/index.mjs",
   "files": [
     "dist",
     "contracts"
@@ -10,27 +12,28 @@
   "engines": {
     "node": ">=10"
   },
-  "scripts": {
-    "start": "tsdx watch",
-    "dev": "tsdx watch",
-    "build": "tsdx build",
-    "test": "yarn build-test-types && jest",
-    "lint": "tsdx lint",
-    "prepublishOnly": "tsdx build",
-    "typecheck": "tsc --noEmit",
-    "build-test-types": "cd test && yarn clarigen && cd .."
-  },
   "prettier": "@stacks/prettier-config",
   "name": "@clarigen/test",
   "author": "Hank Stoever",
-  "module": "dist/test.esm.js",
+  "devDependencies": {
+    "jest-environment-node": "28.1.1"
+  },
   "dependencies": {
-    "@clarigen/core": "1.0.0-next.9",
-    "@clarigen/native-bin": "1.0.0-next.9",
-    "micro-stacks": "^0.2.0"
+    "@clarigen/core": "1.0.0",
+    "@clarigen/native-bin": "1.0.0",
+    "micro-stacks": "^1.1.4"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "15e3f96201ddd9f95ce361a0559e3b15df679f59"
-}
+  "scripts": {
+    "start": "tsup-node --watch",
+    "dev": "tsup-node --watch",
+    "build": "shx rm -rf ./dist && tsup-node",
+    "test": "pnpm build-test-types && jest",
+    "lint": "eslint \"src/**/*.{ts,tsx}\" && prettier  --check src/**/*.ts",
+    "typecheck": "tsc --noEmit",
+    "build-test-types": "sh build-types.sh",
+    "publish:dev": "pnpm build && yalc publish --push"
+  }
+}