@clarigen/test 1.0.0-next.9 → 1.0.0

package/dist/index.d.ts

@@ -1,31 +1,94 @@
-import { NativeClarityBinProvider } from '@clarigen/native-bin';
-import { ContractInstances, Contracts, ContractCall, ContractCalls, ClarityTypes } from '@clarigen/core';
-import { ClarinetAccounts } from './utils';
-import { PublicResultErr, PublicResultOk, ReadOnlyResult } from './utils/pure';
-export type { PublicResultErr, PublicResultOk, ReadOnlyResult } from './utils/pure';
-export { Allocation, createClarityBin, getBlockHeight, mineBlocks, getStxBalance, executeJson, evalJson, makeRandomAddress, } from './utils';
-interface FromContractsOptions {
-    accounts?: ClarinetAccounts;
-    clarityBin?: NativeClarityBinProvider;
-}
-interface FromContracts<T extends Contracts<any>> {
-    deployed: ContractInstances<T>;
-    provider: TestProvider;
-}
-export declare class TestProvider {
-    clarityBin: NativeClarityBinProvider;
-    constructor(clarityBin: NativeClarityBinProvider);
-    static fromContracts<T extends Contracts<any>>(contracts: T, options?: FromContractsOptions): Promise<FromContracts<T>>;
-    ro<T>(tx: ContractCall<T>): Promise<ReadOnlyResult<T>>;
-    rov<T>(tx: ContractCall<T>): Promise<T>;
-    roOk<Ok, Err>(tx: ContractCall<ClarityTypes.Response<Ok, Err>>): Promise<ReadOnlyResult<Ok>>;
-    roErr<Ok, Err>(tx: ContractCall<ClarityTypes.Response<Ok, Err>>): Promise<ReadOnlyResult<Err>>;
-    rovOk<Ok, Err>(tx: ContractCall<ClarityTypes.Response<Ok, Err>>): Promise<Ok>;
-    rovErr<Ok, Err>(tx: ContractCall<ClarityTypes.Response<Ok, Err>>): Promise<Err>;
-    tx<Ok, Err>(tx: ContractCalls.Public<Ok, Err>, senderAddress: string): Promise<import("./utils/pure").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>>;
-    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>;
-}
+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';
+import { IntegerType } from 'micro-stacks/common';
+
+interface ReadOnlyResult<T> {
+    value: T;
+    clarityValue: ClarityValue;
+    logs: string[];
+    costs: Costs;
+}
+interface PublicResultBase<T> {
+    value: T;
+    response: ResponseCV;
+    isOk: boolean;
+    logs: string[];
+    costs: Costs;
+}
+interface PublicResultErr<T> extends PublicResultBase<T> {
+    value: T;
+    isOk: false;
+}
+interface PublicResultOk<T> extends PublicResultBase<T> {
+    value: T;
+    isOk: true;
+    events: CoreNodeEvent[];
+    assets: ResultAssets;
+    prints: any[];
+}
+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;
+};
+declare function getBlockHeight(provider: Provider): Promise<bigint>;
+declare function mineBlocks(_blocks: IntegerType, provider: Provider): Promise<void>;
+declare function getStxBalance(provider: Provider, account: string): Promise<bigint>;
+
+declare function setupCoverage(dir: string): Promise<string>;
+declare function finishCoverage(provider: NativeClarityBinProvider, dir: string): Promise<void>;
+
+declare function makeRandomAddress(version?: StacksNetworkVersion): string;
+
+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<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, Simnet, TestProvider, finishCoverage, getBlockHeight, getStxBalance, makeRandomAddress, mineBlocks, setupCoverage, testFactory };

package/dist/index.js

@@ -1,8 +1,443 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});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));
 
-'use strict'
+// src/index.ts
 
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./test.cjs.production.min.js')
-} else {
-  module.exports = require('./test.cjs.development.js')
+
+
+var _nativebin = require('@clarigen/native-bin');
+
+
+
+
+var _core = require('@clarigen/core');
+
+// src/utils/index.ts
+var _crypto = require('micro-stacks/crypto');
+var _transactions = require('micro-stacks/transactions');
+
+// src/utils/util-contract.ts
+var _clarity = require('micro-stacks/clarity');
+var _path = require('path');
+
+
+var _common = require('micro-stacks/common');
+var UTIL_CONTRACT_ID = "ST000000000000000000002AMW42H.clarigen-test-utils";
+async function deployUtilContract(clarityBin) {
+  let contractFilePath = _path.join.call(void 0, __dirname, "..", "..", "contracts", "test-utils.clar");
+  if (__dirname.includes("dist")) {
+    contractFilePath = _path.join.call(void 0, __dirname, "..", "contracts", "test-utils.clar");
+  }
+  await _nativebin.deployContract.call(void 0, {
+    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 _nativebin.evalJson.call(void 0, {
+    contractAddress: UTIL_CONTRACT_ID,
+    functionName: "get-block-height",
+    args: [],
+    provider: bin
+  });
+  const outputCV = _clarity.hexToCV.call(void 0, output_serialized);
+  const blockHeight = _core.cvToValue.call(void 0, outputCV);
+  return blockHeight;
+}
+async function mineBlock(provider) {
+  const bin = getBin(provider);
+  await _nativebin.executeJson.call(void 0, {
+    contractAddress: UTIL_CONTRACT_ID,
+    functionName: "mine-block",
+    args: [],
+    provider: bin,
+    senderAddress: "ST000000000000000000002AMW42H"
+  });
+}
+async function mineBlocks(_blocks, provider) {
+  const blocks = _common.intToBigInt.call(void 0, _blocks);
+  for (let index = 0; index < blocks; index++) {
+    await mineBlock(provider);
+  }
+}
+async function getStxBalance(provider, account) {
+  const bin = getBin(provider);
+  const { output_serialized } = await _nativebin.evalJson.call(void 0, {
+    contractAddress: UTIL_CONTRACT_ID,
+    functionName: "get-stx-balance",
+    args: [`'${account}`],
+    provider: bin
+  });
+  const outputCV = _clarity.hexToCV.call(void 0, output_serialized);
+  const balance = _core.cvToValue.call(void 0, outputCV);
+  return balance;
+}
+
+// src/utils/coverage.ts
+var _promises = require('fs/promises');
+
+async function setupCoverage(dir) {
+  const dirName = _path.resolve.call(void 0, process.cwd(), "coverage");
+  try {
+    await _promises.mkdir.call(void 0, dirName);
+  } catch (error) {
+  }
+  const files = await _promises.readdir.call(void 0, dirName);
+  const removals = files.map((file) => {
+    return _promises.unlink.call(void 0, _path.join.call(void 0, dirName, file));
+  });
+  await Promise.all(removals);
+  return dirName;
 }
+async function finishCoverage(provider, dir) {
+  const lcovFile = _path.join.call(void 0, dir, "clarigen.lcov");
+  await provider.runCommand(["make_lcov", dir, lcovFile]);
+}
+
+// src/utils/index.ts
+function makeRandomAddress(version = _crypto.StacksNetworkVersion.testnetP2PKH) {
+  const privateKey = _transactions.makeRandomPrivKey.call(void 0, );
+  const publicKey = _transactions.getPublicKeyFromStacksPrivateKey.call(void 0, privateKey);
+  const address = _crypto.publicKeyToStxAddress.call(void 0, publicKey.data, version);
+  return address;
+}
+
+// src/utils/pure.ts
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+function getPrints(events) {
+  return _core.filterEvents.call(void 0, events, _core.CoreNodeEventType.ContractEvent).map((e) => {
+    const hex = e.contract_event.raw_value;
+    const cv = _clarity.hexToCV.call(void 0, hex);
+    return _core.cvToValue.call(void 0, cv);
+  });
+}
+function formatArguments(args) {
+  return args.map((arg) => _core.cvToString.call(void 0, 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 = _clarity.hexToCV.call(void 0, result.output_serialized);
+  const value = _core.cvToValue.call(void 0, resultCV, true);
+  return {
+    value,
+    clarityValue: resultCV,
+    logs: getLogs(result.stderr),
+    costs: result.costs
+  };
+}
+async function ro({
+  tx: tx2,
+  bin,
+  coverageFolder
+}) {
+  const result = await _nativebin.evalJson.call(void 0, {
+    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 _nativebin.evalRaw.call(void 0, {
+    contractAddress,
+    code,
+    provider: bin,
+    coverageFolder
+  });
+  return makeEvalResult(result);
+}
+async function tx({
+  tx: tx2,
+  senderAddress,
+  bin,
+  coverageFolder
+}) {
+  const result = await _nativebin.executeJson.call(void 0, {
+    contractAddress: getIdentifier(tx2),
+    senderAddress,
+    provider: bin,
+    functionName: tx2.function.name,
+    args: formatArguments(tx2.functionArgs),
+    coverageFolder
+  });
+  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 = {
+    logs: getLogs(result.stderr),
+    costs: result.costs,
+    value: resp
+  };
+  if (result.success) {
+    return __spreadProps(__spreadValues({}, baseReturn), {
+      isOk: true,
+      response: _clarity.responseOkCV.call(void 0, resultCV),
+      assets: result.assets,
+      events: result.events,
+      prints: getPrints(result.events)
+    });
+  }
+  return __spreadProps(__spreadValues({}, baseReturn), {
+    isOk: false,
+    response: _clarity.responseErrorCV.call(void 0, resultCV)
+  });
+}
+async function mapGet({
+  map,
+  bin
+}) {
+  const code = `(map-get? ${map.map.name} ${_core.cvToString.call(void 0, map.key)})`;
+  const result = await evalCode({
+    contractAddress: getIdentifier(map),
+    code,
+    bin
+  });
+  return result.value;
+}
+
+// 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;
+  }
+  static async fromContracts(contracts, options = {}) {
+    const clarityBin = options.clarityBin || await _nativebin.createClarityBin.call(void 0, {
+      allocations: options.accounts
+    });
+    const instances = {};
+    let coverageFolder = options.coverageFolder;
+    if (process.env.CLARIGEN_COVERAGE) {
+      coverageFolder = _path.resolve.call(void 0, process.cwd(), "coverage");
+    }
+    await deployUtilContract(clarityBin);
+    for (const k in contracts) {
+      if (Object.prototype.hasOwnProperty.call(contracts, k)) {
+        const contract = contracts[k];
+        const identifier = _core.getContractIdentifier.call(void 0, contract);
+        await _nativebin.deployContract.call(void 0, {
+          contractIdentifier: identifier,
+          contractFilePath: contract.contractFile,
+          provider: clarityBin,
+          coverageFolder
+        });
+        const instance = contract.contract(contract.address, contract.name);
+        instances[k] = {
+          identifier: _core.getContractIdentifier.call(void 0, 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 _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
+    });
+    let coverageFolder = options.coverageFolder;
+    if (process.env.CLARIGEN_COVERAGE) {
+      coverageFolder = _path.resolve.call(void 0, 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 = _path.resolve.call(void 0, process.cwd(), options.clarinetPath, contractFilePath);
+        }
+        if (typeof contractFilePath === "undefined") {
+          throw new Error("Cannot setup @clarigen/test - missing contract file.");
+        }
+        await _nativebin.deployContract.call(void 0, {
+          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 = _core.expectOk.call(void 0, result.value);
+    return __spreadProps(__spreadValues({}, result), {
+      value
+    });
+  }
+  async roErr(tx2) {
+    const result = await this.ro(tx2);
+    const value = _core.expectErr.call(void 0, 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 = _core.expectOk.call(void 0, 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 = _core.expectErr.call(void 0, 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 });
+  }
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+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;