@clarigen/test 0.3.6 → 1.0.0-next.12

package/dist/index.d.ts

@@ -1,28 +1,132 @@
-import { NativeClarityBinProvider } from '@clarigen/native-bin';
-import { ClarityAbiFunction } from '@stacks/transactions';
-import { Transaction, Contract, ContractInstances, Contracts, BaseProvider } from '@clarigen/core';
-import { Allocation, ClarinetAccounts } from './utils';
-export { Allocation, createClarityBin, tx, txOk, txErr, getBlockHeight, mineBlocks, getStxBalance, executeJson, evalJson, } from './utils';
-interface CreateOptions {
-    allocations?: Allocation[];
-    contractIdentifier: string;
-    contractFilePath: string;
-    clarityBin: NativeClarityBinProvider;
-}
-interface FromContractOptions<T> {
-    contract: Contract<T>;
-    clarityBin: NativeClarityBinProvider;
-}
-export declare class TestProvider implements BaseProvider {
-    clarityBin: NativeClarityBinProvider;
-    contractIdentifier: string;
-    contractFile: string;
-    constructor(clarityBin: NativeClarityBinProvider, contractIdentifier: string, contractFile: string);
-    static create({ clarityBin, contractFilePath, contractIdentifier }: CreateOptions): Promise<TestProvider>;
-    static fromContract<T>({ contract, clarityBin }: FromContractOptions<T>): Promise<T>;
-    static fromContracts<T extends Contracts<M>, M>(contracts: T, clarityBin?: NativeClarityBinProvider): Promise<ContractInstances<T, M>>;
-    static fromContracts<T extends Contracts<M>, M>(contracts: T, accounts?: ClarinetAccounts): Promise<ContractInstances<T, M>>;
-    callReadOnly(func: ClarityAbiFunction, args: any[]): Promise<any>;
-    callPublic(func: ClarityAbiFunction, args: any[]): Transaction<any, any>;
-    formatArguments(func: ClarityAbiFunction, args: any[]): string[];
-}
+import { ResultAssets, CoreNodeEvent, Contracts, ContractCall, ClarityTypes, ContractCalls, ContractInstances } from '@clarigen/core';
+import { ClarityValue, ResponseCV } from 'micro-stacks/clarity';
+import { NativeClarityBinProvider } from '@clarigen/native-bin';
+import { StacksNetworkVersion } from 'micro-stacks/crypto';
+import { IntegerType } from 'micro-stacks/common';
+
+interface Allocation {
+    principal: string;
+    amount: bigint;
+}
+interface Costs {
+    read_count: number;
+    read_length: number;
+    runtime: number;
+    write_count: number;
+    write_length: number;
+}
+interface ExecuteOk {
+    success: true;
+    message: string;
+    events: any[];
+    output_serialized: string;
+    costs: Costs;
+    assets: ResultAssets;
+    stderr: string;
+}
+interface ExecuteErr {
+    message: string;
+    error: any;
+    output_serialized: string;
+    costs: Costs;
+    success: false;
+    stderr: string;
+}
+declare type ExecuteResult = ExecuteOk | ExecuteErr;
+declare const executeJson: ({ contractAddress, senderAddress, functionName, provider, args, }: {
+    contractAddress: string;
+    senderAddress: string;
+    provider: NativeClarityBinProvider;
+    functionName: string;
+    args?: string[] | undefined;
+}) => Promise<ExecuteResult>;
+interface EvalOk {
+    success: true;
+    costs: Costs;
+    output_serialized: string;
+}
+interface Eval extends EvalOk {
+    stderr: string;
+}
+declare const evalJson: ({ contractAddress, functionName, provider, args, }: {
+    contractAddress: string;
+    functionName: string;
+    provider: NativeClarityBinProvider;
+    args?: string[] | undefined;
+}) => Promise<Eval>;
+interface ClarinetAccount {
+    balance: bigint;
+    address: string;
+}
+interface ClarinetAccounts {
+    deployer: ClarinetAccount;
+    [key: string]: ClarinetAccount;
+}
+declare type AllocationOrAccounts = ClarinetAccounts | Allocation[];
+declare const createClarityBin: ({ allocations, testnet, }?: {
+    allocations?: AllocationOrAccounts | undefined;
+    testnet?: boolean | undefined;
+}) => Promise<NativeClarityBinProvider>;
+
+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<Ok, Err> = PublicResultOk<Ok> | PublicResultErr<Err>;
+
+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 makeRandomAddress(version?: StacksNetworkVersion): string;
+
+interface FromContractsOptions {
+    accounts?: ClarinetAccounts;
+    clarityBin?: NativeClarityBinProvider;
+}
+interface FromContracts<T extends Contracts<any>> {
+    deployed: ContractInstances<T>;
+    provider: TestProvider;
+}
+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<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>;
+}
+
+export { Allocation, PublicResultErr, PublicResultOk, ReadOnlyResult, TestProvider, createClarityBin, evalJson, executeJson, getBlockHeight, getStxBalance, makeRandomAddress, mineBlocks };

package/dist/index.js

@@ -1,8 +1,15 @@
-
-'use strict'
-
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./test.cjs.production.min.js')
-} else {
-  module.exports = require('./test.cjs.development.js')
-}
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var z=Object.defineProperty,H=Object.defineProperties;var j=Object.getOwnPropertyDescriptors;var x=Object.getOwnPropertySymbols;var D=Object.prototype.hasOwnProperty,L=Object.prototype.propertyIsEnumerable;var R=(r,t,e)=>t in r?z(r,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):r[t]=e,c=(r,t)=>{for(var e in t||(t={}))D.call(t,e)&&R(r,e,t[e]);if(x)for(var e of x(t))L.call(t,e)&&R(r,e,t[e]);return r},l=(r,t)=>H(r,j(t));var _nativebin = require('@clarigen/native-bin');var _core = require('@clarigen/core');var _crypto = require('micro-stacks/crypto');var _transactions = require('micro-stacks/transactions');var _clarity = require('micro-stacks/clarity');var v=async({contractAddress:r,senderAddress:t,functionName:e,provider:n,args:s=[]})=>{let i=await n.runCommand(["execute","--costs","--assets",n.dbFilePath,r,e,t,...s]);process.env.PRINT_CLARIGEN_STDERR&&i.stderr&&console.log(i.stderr);let o=JSON.parse(i.stdout);if(o&&"error"in o)throw new Error(`Transaction error: ${JSON.stringify(o.error,null,2)}`);if(i.exitCode!==0)throw new Error(`Execution error: ${i.stderr}`);return l(c({},o),{stderr:i.stderr})},y=async({contractAddress:r,code:t,provider:e})=>{let n=await e.runCommand(["eval_at_chaintip","--costs",r,e.dbFilePath],{stdin:t});process.env.PRINT_CLARIGEN_STDERR&&n.stderr&&console.log(n.stderr);let s=JSON.parse(n.stdout);if(!s.success)throw new Error(JSON.stringify(s.error,null,2));return l(c({},s),{stderr:n.stderr})},d= exports.evalJson =({contractAddress:r,functionName:t,provider:e,args:n=[]})=>{let s=`(${t} ${n.join(" ")})`;return y({contractAddress:r,provider:e,code:s})};function Z(r){return r?"deployer"in r?Object.values(r).map(t=>({amount:t.balance,principal:t.address})):Array.isArray(r)?r:[]:[]}function tt(r,t){return typeof t=="bigint"?`${t}n`:t}function rt(r){return JSON.stringify(r,tt).replace(/"(-?\d+)n"/g,(e,n)=>n)}var et=async({allocations:r,testnet:t=!0}={})=>{let e=_nativebin.getDefaultBinaryFilePath.call(void 0, ),n=_nativebin.getTempFilePath.call(void 0, ),s=Z(r),i=new (0, _nativebin.NativeClarityBinProvider)(n,e),o=["initialize","-",n];return t&&o.push("--testnet"),await i.runCommand(o,{stdin:rt(s)}),i};async function m({contractIdentifier:r,contractFilePath:t,provider:e}){let n=await e.runCommand(["launch",r,t,e.dbFilePath,"--costs","--assets"]);if(_nativebin.hasStdErr.call(void 0, n.stderr))throw new Error(`Error on ${t}:
+  ${n.stderr}
+    `);let s=JSON.parse(n.stdout);if(s.error){let{initialization:i}=s.error;if(i!=null&&i.includes(`
+Near:
+`)){let[o,a]=i.split(`
+Near:
+`),p="",b=/start_line: (\d+),/.exec(a);throw b&&(p=b[1]),new Error(`Error on ${t}:
+    ${o}
+    ${p?`Near line ${p}`:""}
+    Raw trace:
+    ${a}
+      `)}throw new Error(`Error on ${t}:
+  ${JSON.stringify(s.error,null,2)}
+    `)}}function T(r){return _core.filterEvents.call(void 0, r,_core.CoreNodeEventType.ContractEvent).map(t=>{let e=t.contract_event.raw_value,n=_clarity.hexToCV.call(void 0, e);return _core.cvToValue.call(void 0, n)})}var _path = require('path');var _common = require('micro-stacks/common');var u="ST000000000000000000002AMW42H.clarigen-test-utils";async function h(r){let t=_path.join.call(void 0, __dirname,"..","..","contracts","test-utils.clar");__dirname.includes("dist")&&(t=_path.join.call(void 0, __dirname,"..","contracts","test-utils.clar")),await m({contractIdentifier:u,provider:r,contractFilePath:t})}function f(r){return"clarityBin"in r?r.clarityBin:r}async function st(r){let t=f(r),{output_serialized:e}=await d({contractAddress:u,functionName:"get-block-height",args:[],provider:t}),n=_clarity.hexToCV.call(void 0, e);return _core.cvToValue.call(void 0, n)}async function it(r){let t=f(r);await v({contractAddress:u,functionName:"mine-block",args:[],provider:t,senderAddress:"ST000000000000000000002AMW42H"})}async function ot(r,t){let e=_common.intToBigInt.call(void 0, r);for(let n=0;n<e;n++)await it(t)}async function at(r,t){let e=f(r),{output_serialized:n}=await d({contractAddress:u,functionName:"get-stx-balance",args:[`'${t}`],provider:e}),s=_clarity.hexToCV.call(void 0, n);return _core.cvToValue.call(void 0, s)}function pt(r=_crypto.StacksNetworkVersion.testnetP2PKH){let t=_transactions.makeRandomPrivKey.call(void 0, ),e=_transactions.getPublicKeyFromStacksPrivateKey.call(void 0, t);return _crypto.publicKeyToStxAddress.call(void 0, e.data,r)}function _(r){return r.map(t=>_core.cvToString.call(void 0, t))}function g(r){return`${r.contractAddress}.${r.contractName}`}function V(r){return r===""?[]:r.split(`
+`).map(t=>t.slice(62))}function $(r){let t=_clarity.hexToCV.call(void 0, r.output_serialized);return{value:_core.cvToValue.call(void 0, t,!0),clarityValue:t,logs:V(r.stderr),costs:r.costs}}async function S(r,t){let e=await d({functionName:r.function.name,args:_(r.functionArgs),contractAddress:g(r),provider:t});return $(e)}async function E({contractAddress:r,code:t,bin:e}){let n=await y({contractAddress:r,code:t,provider:e});return $(n)}async function I({tx:r,senderAddress:t,bin:e}){let n=await v({contractAddress:g(r),senderAddress:t,provider:e,functionName:r.function.name,args:_(r.functionArgs)}),s=_clarity.hexToCV.call(void 0, n.output_serialized),o={value:_core.cvToValue.call(void 0, s),logs:V(n.stderr),costs:n.costs};return n.success?l(c({},o),{isOk:!0,response:_clarity.responseOkCV.call(void 0, s),assets:n.assets,events:n.events,prints:T(n.events)}):l(c({},o),{isOk:!1,response:_clarity.responseErrorCV.call(void 0, s)})}async function J({map:r,bin:t}){let e=`(map-get? ${r.map.name} ${_core.cvToString.call(void 0, r.key)})`;return(await E({contractAddress:g(r),code:e,bin:t})).value}var K=class{constructor(t){this.clarityBin=t}static async fromContracts(t,e={}){let n=e.clarityBin||await _nativebin.createClarityBin.call(void 0, ),s={};await h(n);for(let o in t)if(Object.prototype.hasOwnProperty.call(t,o)){let a=t[o],p=_core.getContractIdentifier.call(void 0, a);await m({contractIdentifier:p,contractFilePath:a.contractFile,provider:n});let P=a.contract(a.address,a.name);s[o]={identifier:_core.getContractIdentifier.call(void 0, a),contract:P}}let i=new this(n);return{deployed:s,provider:i}}ro(t){return S(t,this.clarityBin)}async rov(t){return(await this.ro(t)).value}async roOk(t){let e=await this.ro(t);return e.value.match(n=>l(c({},e),{value:n}),n=>{throw new Error(`Expected OK, received error: ${n}`)})}async roErr(t){let e=await this.ro(t);return e.value.match(n=>{throw new Error(`Expected err, received ok: ${n}`)},n=>l(c({},e),{value:n}))}async rovOk(t){return(await this.roOk(t)).value}async rovErr(t){return(await this.roErr(t)).value}tx(t,e){return I({tx:t,senderAddress:e,bin:this.clarityBin})}async txOk(t,e){let n=await this.tx(t,e);if(!n.isOk)throw new Error(`Expected OK, received error: ${n.value}`);return n}async txErr(t,e){let n=await this.tx(t,e);if(n.isOk)throw new Error(`Expected Err, received ok: ${n.value}`);return n}evalCode(t,e=u){return E({contractAddress:e,code:t,bin:this.clarityBin})}async eval(t,e=u){return(await this.evalCode(t,e)).value}mapGet(t){return J({map:t,bin:this.clarityBin})}};exports.TestProvider = K; exports.createClarityBin = et; exports.evalJson = d; exports.executeJson = v; exports.getBlockHeight = st; exports.getStxBalance = at; exports.makeRandomAddress = pt; exports.mineBlocks = ot;

package/dist/index.mjs

@@ -0,0 +1,15 @@
+var D=Object.defineProperty,H=Object.defineProperties;var L=Object.getOwnPropertyDescriptors;var R=Object.getOwnPropertySymbols;var j=Object.prototype.hasOwnProperty,G=Object.prototype.propertyIsEnumerable;var T=(r,t,e)=>t in r?D(r,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):r[t]=e,c=(r,t)=>{for(var e in t||(t={}))j.call(t,e)&&T(r,e,t[e]);if(R)for(var e of R(t))G.call(t,e)&&T(r,e,t[e]);return r},l=(r,t)=>H(r,L(t));import{fileURLToPath as U}from"url";import M from"path";var W=()=>U(import.meta.url),q=()=>M.dirname(W()),u=q();import{createClarityBin as Pt}from"@clarigen/native-bin";import{getContractIdentifier as K}from"@clarigen/core";import{publicKeyToStxAddress as mt,StacksNetworkVersion as vt}from"micro-stacks/crypto";import{getPublicKeyFromStacksPrivateKey as Ct,makeRandomPrivKey as yt}from"micro-stacks/transactions";import{getTempFilePath as Q,NativeClarityBinProvider as X,getDefaultBinaryFilePath as Y,hasStdErr as Z}from"@clarigen/native-bin";import{CoreNodeEventType as tt,cvToValue as rt,filterEvents as et}from"@clarigen/core";import{hexToCV as nt}from"micro-stacks/clarity";var v=async({contractAddress:r,senderAddress:t,functionName:e,provider:n,args:s=[]})=>{let i=await n.runCommand(["execute","--costs","--assets",n.dbFilePath,r,e,t,...s]);process.env.PRINT_CLARIGEN_STDERR&&i.stderr&&console.log(i.stderr);let o=JSON.parse(i.stdout);if(o&&"error"in o)throw new Error(`Transaction error: ${JSON.stringify(o.error,null,2)}`);if(i.exitCode!==0)throw new Error(`Execution error: ${i.stderr}`);return l(c({},o),{stderr:i.stderr})},f=async({contractAddress:r,code:t,provider:e})=>{let n=await e.runCommand(["eval_at_chaintip","--costs",r,e.dbFilePath],{stdin:t});process.env.PRINT_CLARIGEN_STDERR&&n.stderr&&console.log(n.stderr);let s=JSON.parse(n.stdout);if(!s.success)throw new Error(JSON.stringify(s.error,null,2));return l(c({},s),{stderr:n.stderr})},p=({contractAddress:r,functionName:t,provider:e,args:n=[]})=>{let s=`(${t} ${n.join(" ")})`;return f({contractAddress:r,provider:e,code:s})};function st(r){return r?"deployer"in r?Object.values(r).map(t=>({amount:t.balance,principal:t.address})):Array.isArray(r)?r:[]:[]}function it(r,t){return typeof t=="bigint"?`${t}n`:t}function ot(r){return JSON.stringify(r,it).replace(/"(-?\d+)n"/g,(e,n)=>n)}var at=async({allocations:r,testnet:t=!0}={})=>{let e=Y(),n=Q(),s=st(r),i=new X(n,e),o=["initialize","-",n];return t&&o.push("--testnet"),await i.runCommand(o,{stdin:ot(s)}),i};async function y({contractIdentifier:r,contractFilePath:t,provider:e}){let n=await e.runCommand(["launch",r,t,e.dbFilePath,"--costs","--assets"]);if(Z(n.stderr))throw new Error(`Error on ${t}:
+  ${n.stderr}
+    `);let s=JSON.parse(n.stdout);if(s.error){let{initialization:i}=s.error;if(i!=null&&i.includes(`
+Near:
+`)){let[o,a]=i.split(`
+Near:
+`),m="",x=/start_line: (\d+),/.exec(a);throw x&&(m=x[1]),new Error(`Error on ${t}:
+    ${o}
+    ${m?`Near line ${m}`:""}
+    Raw trace:
+    ${a}
+      `)}throw new Error(`Error on ${t}:
+  ${JSON.stringify(s.error,null,2)}
+    `)}}function k(r){return et(r,tt.ContractEvent).map(t=>{let e=t.contract_event.raw_value,n=nt(e);return rt(n)})}import{hexToCV as w}from"micro-stacks/clarity";import{join as O}from"path";import{cvToValue as h}from"@clarigen/core";import{intToBigInt as ct}from"micro-stacks/common";var d="ST000000000000000000002AMW42H.clarigen-test-utils";async function N(r){let t=O(u,"..","..","contracts","test-utils.clar");u.includes("dist")&&(t=O(u,"..","contracts","test-utils.clar")),await y({contractIdentifier:d,provider:r,contractFilePath:t})}function g(r){return"clarityBin"in r?r.clarityBin:r}async function lt(r){let t=g(r),{output_serialized:e}=await p({contractAddress:d,functionName:"get-block-height",args:[],provider:t}),n=w(e);return h(n)}async function ut(r){let t=g(r);await v({contractAddress:d,functionName:"mine-block",args:[],provider:t,senderAddress:"ST000000000000000000002AMW42H"})}async function dt(r,t){let e=ct(r);for(let n=0;n<e;n++)await ut(t)}async function pt(r,t){let e=g(r),{output_serialized:n}=await p({contractAddress:d,functionName:"get-stx-balance",args:[`'${t}`],provider:e}),s=w(n);return h(s)}function ft(r=vt.testnetP2PKH){let t=yt(),e=Ct(t);return mt(e.data,r)}import{cvToString as A,cvToValue as B}from"@clarigen/core";import{hexToCV as _,responseErrorCV as gt,responseOkCV as Et}from"micro-stacks/clarity";function V(r){return r.map(t=>A(t))}function E(r){return`${r.contractAddress}.${r.contractName}`}function $(r){return r===""?[]:r.split(`
+`).map(t=>t.slice(62))}function S(r){let t=_(r.output_serialized);return{value:B(t,!0),clarityValue:t,logs:$(r.stderr),costs:r.costs}}async function I(r,t){let e=await p({functionName:r.function.name,args:V(r.functionArgs),contractAddress:E(r),provider:t});return S(e)}async function P({contractAddress:r,code:t,bin:e}){let n=await f({contractAddress:r,code:t,provider:e});return S(n)}async function J({tx:r,senderAddress:t,bin:e}){let n=await v({contractAddress:E(r),senderAddress:t,provider:e,functionName:r.function.name,args:V(r.functionArgs)}),s=_(n.output_serialized),o={value:B(s),logs:$(n.stderr),costs:n.costs};return n.success?l(c({},o),{isOk:!0,response:Et(s),assets:n.assets,events:n.events,prints:k(n.events)}):l(c({},o),{isOk:!1,response:gt(s)})}async function F({map:r,bin:t}){let e=`(map-get? ${r.map.name} ${A(r.key)})`;return(await P({contractAddress:E(r),code:e,bin:t})).value}var z=class{constructor(t){this.clarityBin=t}static async fromContracts(t,e={}){let n=e.clarityBin||await Pt(),s={};await N(n);for(let o in t)if(Object.prototype.hasOwnProperty.call(t,o)){let a=t[o],m=K(a);await y({contractIdentifier:m,contractFilePath:a.contractFile,provider:n});let b=a.contract(a.address,a.name);s[o]={identifier:K(a),contract:b}}let i=new this(n);return{deployed:s,provider:i}}ro(t){return I(t,this.clarityBin)}async rov(t){return(await this.ro(t)).value}async roOk(t){let e=await this.ro(t);return e.value.match(n=>l(c({},e),{value:n}),n=>{throw new Error(`Expected OK, received error: ${n}`)})}async roErr(t){let e=await this.ro(t);return e.value.match(n=>{throw new Error(`Expected err, received ok: ${n}`)},n=>l(c({},e),{value:n}))}async rovOk(t){return(await this.roOk(t)).value}async rovErr(t){return(await this.roErr(t)).value}tx(t,e){return J({tx:t,senderAddress:e,bin:this.clarityBin})}async txOk(t,e){let n=await this.tx(t,e);if(!n.isOk)throw new Error(`Expected OK, received error: ${n.value}`);return n}async txErr(t,e){let n=await this.tx(t,e);if(n.isOk)throw new Error(`Expected Err, received ok: ${n.value}`);return n}evalCode(t,e=d){return P({contractAddress:e,code:t,bin:this.clarityBin})}async eval(t,e=d){return(await this.evalCode(t,e)).value}mapGet(t){return F({map:t,bin:this.clarityBin})}};export{z as TestProvider,at as createClarityBin,p as evalJson,v as executeJson,lt as getBlockHeight,pt as getStxBalance,ft as makeRandomAddress,dt as mineBlocks};

package/package.json

@@ -1,8 +1,10 @@
 {
-  "version": "0.3.6",
+  "version": "1.0.0-next.12",
   "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"
@@ -11,25 +13,25 @@
     "node": ">=10"
   },
   "scripts": {
-    "start": "tsdx watch",
-    "dev": "tsdx watch",
-    "build": "tsdx build",
-    "test": "tsdx test",
-    "lint": "tsdx lint",
-    "prepublishOnly": "tsdx build",
-    "typecheck": "tsc --noEmit"
+    "start": "tsup --watch",
+    "dev": "tsup --watch",
+    "build": "shx rm -rf ./dist && tsup-node",
+    "test": "yarn build-test-types && jest",
+    "lint": "eslint \"src/**/*.{ts,tsx}\" && prettier  --check src/**/*.ts",
+    "prepublishOnly": "yarn build",
+    "typecheck": "tsc --noEmit",
+    "build-test-types": "cd test && yarn clarigen && cd .."
   },
-  "prettier": "@blockstack/prettier-config",
+  "prettier": "@stacks/prettier-config",
   "name": "@clarigen/test",
   "author": "Hank Stoever",
-  "module": "dist/test.esm.js",
   "dependencies": {
-    "@clarigen/core": "0.3.4",
-    "@clarigen/native-bin": "0.3.4",
-    "@stacks/transactions": "^2.0.1"
+    "@clarigen/core": "1.0.0-next.11",
+    "@clarigen/native-bin": "1.0.0-next.12",
+    "micro-stacks": "^0.2.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "b438736c231e6d6adf20a8e384f03bf522be6a64"
+  "gitHead": "85b9deb9bd3ce9ecf700d1ae8c3ce74c86c34721"
 }