@clarigen/test 1.0.0-next.22 → 1.0.0-next.26

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { CoreNodeEvent, ResultAssets, Contracts, ContractFactory, AllContracts, ContractCall, Response, ContractCalls, ContractInstances } from '@clarigen/core';
-import { Costs, NativeClarityBinProvider, ClarinetAccounts } from '@clarigen/native-bin';
+import { CoreNodeEvent, ResultAssets, Project, AllContracts, DeploymentsForContracts, ProjectFactory, Contracts, ContractFactory, ContractCall, Response, ContractCalls, ContractInstances, ResponseOk, ResponseErr } from '@clarigen/core';
+import { Costs, ClarinetAccount, NativeClarityBinProvider, ClarinetAccounts } from '@clarigen/native-bin';
 export { Allocation, createClarityBin, evalJson, executeJson } from '@clarigen/native-bin';
 import { ClarityValue, ResponseCV } from 'micro-stacks/clarity';
 import { StacksNetworkVersion } from 'micro-stacks/crypto';
@@ -29,7 +29,22 @@ interface PublicResultOk<T> extends PublicResultBase<T> {
     assets: ResultAssets;
     prints: any[];
 }
-declare type PublicResult<Ok, Err> = PublicResultOk<Ok> | PublicResultErr<Err>;
+declare type PublicResult<R> = PublicResultOk<R> | PublicResultErr<R>;
+
+declare type Account = Omit<ClarinetAccount, 'balance'> & {
+    balance: number;
+};
+interface Simnet {
+    accounts: {
+        deployer: Account;
+        [key: string]: Account;
+    };
+    deployment: {
+        identifier: string;
+        file: string;
+    }[];
+}
+declare function testFactory<P extends Project<C, D>, C extends AllContracts, D extends DeploymentsForContracts<C>>(project: P): ProjectFactory<P, 'simnet'>;
 
 declare type Provider = NativeClarityBinProvider | {
     clarityBin: NativeClarityBinProvider;
@@ -47,29 +62,33 @@ interface FromContractsOptions {
     accounts?: ClarinetAccounts;
     clarityBin?: NativeClarityBinProvider;
     coverageFolder?: string;
+    clarinetPath?: string;
 }
 interface FromContracts<T extends Contracts<any>> {
     deployed: ContractInstances<T>;
     provider: TestProvider;
 }
+declare type OkType<T> = T extends ResponseOk<infer Ok, unknown> ? Ok : never;
+declare type ErrType<T> = T extends ResponseErr<unknown, infer Err> ? Err : never;
 declare class TestProvider {
     clarityBin: NativeClarityBinProvider;
     coverageFolder?: string;
     constructor(clarityBin: NativeClarityBinProvider);
     static fromContracts<T extends Contracts<any>>(contracts: T, options?: FromContractsOptions): Promise<FromContracts<T>>;
+    static fromProject(simnet: Simnet, options?: FromContractsOptions): Promise<TestProvider>;
     static fromFactory(contracts: ContractFactory<AllContracts>, options?: FromContractsOptions): Promise<TestProvider>;
     ro<T>(tx: ContractCall<T>): Promise<ReadOnlyResult<T>>;
     rov<T>(tx: ContractCall<T>): Promise<T>;
-    roOk<Ok, Err>(tx: ContractCall<Response<Ok, Err>>): Promise<ReadOnlyResult<Ok>>;
-    roErr<Ok, Err>(tx: ContractCall<Response<Ok, Err>>): Promise<ReadOnlyResult<Err>>;
-    rovOk<Ok, Err>(tx: ContractCall<Response<Ok, Err>>): Promise<Ok>;
-    rovErr<Ok, Err>(tx: ContractCall<Response<Ok, Err>>): Promise<Err>;
-    tx<Ok, Err>(tx: ContractCalls.Public<Ok, Err>, senderAddress: string): Promise<PublicResult<Ok, Err>>;
-    txOk<Ok, Err>(tx: ContractCalls.Public<Ok, Err>, senderAddress: string): Promise<PublicResultOk<Ok>>;
-    txErr<Ok, Err>(tx: ContractCalls.Public<Ok, Err>, senderAddress: string): Promise<PublicResultErr<Err>>;
+    roOk<R extends Response<unknown, unknown>>(tx: ContractCall<R>): Promise<ReadOnlyResult<OkType<R>>>;
+    roErr<R extends Response<unknown, unknown>>(tx: ContractCall<R>): Promise<ReadOnlyResult<ErrType<R>>>;
+    rovOk<R extends Response<unknown, unknown>>(tx: ContractCall<R>): Promise<OkType<R>>;
+    rovErr<R extends Response<unknown, unknown>>(tx: ContractCall<R>): Promise<ErrType<R>>;
+    tx<R extends Response<unknown, unknown>>(tx: ContractCall<R>, senderAddress: string): Promise<PublicResult<R>>;
+    txOk<R extends Response<unknown, unknown>>(tx: ContractCall<R>, senderAddress: string): Promise<PublicResultOk<OkType<R>>>;
+    txErr<R extends Response<unknown, unknown>>(tx: ContractCall<R>, senderAddress: string): Promise<PublicResultErr<ErrType<R>>>;
     evalCode<T>(code: string, contractAddress?: string): Promise<ReadOnlyResult<T>>;
     eval<T>(code: string, contractAddress?: string): Promise<T>;
     mapGet<T extends ContractCalls.Map<any, Val>, Val>(map: T): Promise<Val | null>;
 }
 
-export { PublicResultErr, PublicResultOk, ReadOnlyResult, TestProvider, finishCoverage, getBlockHeight, getStxBalance, makeRandomAddress, mineBlocks, setupCoverage };
+export { PublicResultErr, PublicResultOk, ReadOnlyResult, Simnet, TestProvider, finishCoverage, getBlockHeight, getStxBalance, makeRandomAddress, mineBlocks, setupCoverage, testFactory };

package/dist/index.js

@@ -141,6 +141,8 @@ function makeRandomAddress(version = _crypto.StacksNetworkVersion.testnetP2PKH)
 
 
 
+
+
 function getPrints(events) {
   return _core.filterEvents.call(void 0, events, _core.CoreNodeEventType.ContractEvent).map((e) => {
     const hex = e.contract_event.raw_value;
@@ -213,10 +215,11 @@ async function tx({
   });
   const resultCV = _clarity.hexToCV.call(void 0, result.output_serialized);
   const value = _core.cvToValue.call(void 0, resultCV);
+  const resp = result.success ? _core.ok.call(void 0, value) : _core.err.call(void 0, value);
   const baseReturn = {
-    value,
     logs: getLogs(result.stderr),
-    costs: result.costs
+    costs: result.costs,
+    value: resp
   };
   if (result.success) {
     return __spreadProps(__spreadValues({}, baseReturn), {
@@ -248,6 +251,16 @@ async function mapGet({
 // src/index.ts
 
 
+// src/utils/test-factory.ts
+
+
+
+function testFactory(project) {
+  return _core.projectFactory.call(void 0, project, "simnet");
+}
+
+// src/index.ts
+
 var TestProvider = class {
   constructor(clarityBin) {
     this.clarityBin = clarityBin;
@@ -286,6 +299,34 @@ var TestProvider = class {
       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 _nativebin.createClarityBin.call(void 0, {
+      allocations
+    });
+    let coverageFolder = options.coverageFolder;
+    if (process.env.CLARIGEN_COVERAGE) {
+      coverageFolder = _path.resolve.call(void 0, process.cwd(), "coverage");
+    }
+    await deployUtilContract(clarityBin);
+    for (const contract of simnet.deployment) {
+      let contractFilePath = contract.file;
+      if (options.clarinetPath) {
+        contractFilePath = _path.resolve.call(void 0, process.cwd(), options.clarinetPath, contractFilePath);
+      }
+      await _nativebin.deployContract.call(void 0, {
+        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 _nativebin.createClarityBin.call(void 0, {
       allocations: options.accounts
@@ -298,7 +339,10 @@ var TestProvider = class {
     for (const k in contracts) {
       if (Object.prototype.hasOwnProperty.call(contracts, k)) {
         const contract = contracts[k];
-        const contractFilePath = contract.contractFile;
+        let contractFilePath = contract.contractFile;
+        if (options.clarinetPath) {
+          contractFilePath = _path.resolve.call(void 0, process.cwd(), options.clarinetPath, contractFilePath);
+        }
         if (typeof contractFilePath === "undefined") {
           throw new Error("Cannot setup @clarigen/test - missing contract file.");
         }
@@ -351,15 +395,21 @@ var TestProvider = class {
   }
   async txOk(tx2, senderAddress) {
     const result = await this.tx(tx2, senderAddress);
+    const value = _core.expectOk.call(void 0, result.value);
     if (!result.isOk)
       throw new Error(`Expected OK, received error: ${String(result.value)}`);
-    return result;
+    return __spreadProps(__spreadValues({}, result), {
+      value
+    });
   }
   async txErr(tx2, senderAddress) {
     const result = await this.tx(tx2, senderAddress);
+    const value = _core.expectErr.call(void 0, result.value);
     if (result.isOk)
       throw new Error(`Expected Err, received ok: ${String(result.value)}`);
-    return result;
+    return __spreadProps(__spreadValues({}, result), {
+      value
+    });
   }
   evalCode(code, contractAddress = UTIL_CONTRACT_ID) {
     return evalCode({
@@ -389,4 +439,5 @@ var TestProvider = class {
 
 
 
-exports.Allocation = _nativebin.Allocation; exports.TestProvider = TestProvider; exports.createClarityBin = _nativebin.createClarityBin; exports.evalJson = _nativebin.evalJson; exports.executeJson = _nativebin.executeJson; exports.finishCoverage = finishCoverage; exports.getBlockHeight = getBlockHeight; exports.getStxBalance = getStxBalance; exports.makeRandomAddress = makeRandomAddress; exports.mineBlocks = mineBlocks; exports.setupCoverage = setupCoverage;
+
+exports.Allocation = _nativebin.Allocation; exports.TestProvider = TestProvider; exports.createClarityBin = _nativebin.createClarityBin; exports.evalJson = _nativebin.evalJson; exports.executeJson = _nativebin.executeJson; exports.finishCoverage = finishCoverage; exports.getBlockHeight = getBlockHeight; exports.getStxBalance = getStxBalance; exports.makeRandomAddress = makeRandomAddress; exports.mineBlocks = mineBlocks; exports.setupCoverage = setupCoverage; exports.testFactory = testFactory;

package/dist/index.mjs

@@ -129,7 +129,9 @@ import {
   cvToString,
   cvToValue as cvToValue2,
   filterEvents,
-  CoreNodeEventType
+  CoreNodeEventType,
+  ok,
+  err
 } from "@clarigen/core";
 import {
   evalRaw,
@@ -213,10 +215,11 @@ async function tx({
   });
   const resultCV = hexToCV2(result.output_serialized);
   const value = cvToValue2(resultCV);
+  const resp = result.success ? ok(value) : err(value);
   const baseReturn = {
-    value,
     logs: getLogs(result.stderr),
-    costs: result.costs
+    costs: result.costs,
+    value: resp
   };
   if (result.success) {
     return __spreadProps(__spreadValues({}, baseReturn), {
@@ -247,6 +250,16 @@ async function mapGet({
 
 // 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) {
@@ -286,6 +299,34 @@ var TestProvider = class {
       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
@@ -298,7 +339,10 @@ var TestProvider = class {
     for (const k in contracts) {
       if (Object.prototype.hasOwnProperty.call(contracts, k)) {
         const contract = contracts[k];
-        const contractFilePath = contract.contractFile;
+        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.");
         }
@@ -351,15 +395,21 @@ var TestProvider = class {
   }
   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 result;
+    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 result;
+    return __spreadProps(__spreadValues({}, result), {
+      value
+    });
   }
   evalCode(code, contractAddress = UTIL_CONTRACT_ID) {
     return evalCode({
@@ -388,5 +438,6 @@ export {
   getStxBalance,
   makeRandomAddress,
   mineBlocks,
-  setupCoverage
+  setupCoverage,
+  testFactory
 };

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.0.0-next.22",
+  "version": "1.0.0-next.26",
   "license": "MIT",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
@@ -16,12 +16,11 @@
   "name": "@clarigen/test",
   "author": "Hank Stoever",
   "devDependencies": {
-    "jest-environment-node": "28.1.1",
-    "@clarigen/cli": "1.0.0-next.22"
+    "jest-environment-node": "28.1.1"
   },
   "dependencies": {
-    "@clarigen/core": "1.0.0-next.22",
-    "@clarigen/native-bin": "1.0.0-next.22",
+    "@clarigen/core": "1.0.0-next.29",
+    "@clarigen/native-bin": "1.0.0-next.26",
     "micro-stacks": "^0.5.2"
   },
   "publishConfig": {
@@ -34,7 +33,7 @@
     "test": "pnpm build-test-types && jest",
     "lint": "eslint \"src/**/*.{ts,tsx}\" && prettier  --check src/**/*.ts",
     "typecheck": "tsc --noEmit",
-    "build-test-types": "cd test/clarinet-project && pnpm clarigen && cd ../..",
-    "publish:dev": "yalc publish --push"
+    "build-test-types": "sh build-types.sh",
+    "publish:dev": "pnpm build && yalc publish --push"
   }
 }