@clarigen/test 0.3.3 → 1.0.0-next.10

package/dist/test.esm.js

@@ -1,8 +1,10 @@
-import { deserializeCV, ClarityType, responseOkCV, responseErrorCV } from '@stacks/transactions';
-import { err, ok } from 'neverthrow';
-import { cvToValue, parseToCV, cvToString, getContractNameFromPath, getContractIdentifier } from '@clarigen/core';
-import { getDefaultBinaryFilePath, getTempFilePath, NativeClarityBinProvider, hasStdErr } from '@clarigen/native-bin';
+import { getDefaultBinaryFilePath, getTempFilePath, NativeClarityBinProvider, hasStdErr, createClarityBin as createClarityBin$1 } from '@clarigen/native-bin';
+import { filterEvents, CoreNodeEventType, cvToValue, cvToString, getContractIdentifier } from '@clarigen/core';
+import { publicKeyToStxAddress, StacksNetworkVersion } from 'micro-stacks/crypto';
+import { makeRandomPrivKey, getPublicKeyFromStacksPrivateKey } from 'micro-stacks/transactions';
+import { hexToCV, responseErrorCV, responseOkCV } from 'micro-stacks/clarity';
 import { join } from 'path';
+import { intToBigInt } from 'micro-stacks/common';
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
@@ -40,6 +42,24 @@ function _asyncToGenerator(fn) {
   };
 }
 
+function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
 function createCommonjsModule(fn, module) {
 	return module = { exports: {} }, fn(module, module.exports), module.exports;
 }
@@ -805,7 +825,9 @@ var executeJson = /*#__PURE__*/function () {
             throw new Error("Execution error: " + result.stderr);
 
           case 10:
-            return _context.abrupt("return", response);
+            return _context.abrupt("return", _extends({}, response, {
+              stderr: result.stderr
+            }));
 
           case 11:
           case "end":
@@ -819,22 +841,20 @@ var executeJson = /*#__PURE__*/function () {
     return _ref2.apply(this, arguments);
   };
 }();
-var evalJson = /*#__PURE__*/function () {
+var evalRaw = /*#__PURE__*/function () {
   var _ref4 = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(_ref3) {
-    var contractAddress, functionName, provider, _ref3$args, args, evalCode, receipt, response;
-
+    var contractAddress, code, provider, receipt, response;
     return runtime_1.wrap(function _callee2$(_context2) {
       while (1) {
         switch (_context2.prev = _context2.next) {
           case 0:
-            contractAddress = _ref3.contractAddress, functionName = _ref3.functionName, provider = _ref3.provider, _ref3$args = _ref3.args, args = _ref3$args === void 0 ? [] : _ref3$args;
-            evalCode = "(" + functionName + " " + args.join(' ') + ")";
-            _context2.next = 4;
+            contractAddress = _ref3.contractAddress, code = _ref3.code, provider = _ref3.provider;
+            _context2.next = 3;
             return provider.runCommand(['eval_at_chaintip', '--costs', contractAddress, provider.dbFilePath], {
-              stdin: evalCode
+              stdin: code
             });
 
-          case 4:
+          case 3:
             receipt = _context2.sent;
 
             if (process.env.PRINT_CLARIGEN_STDERR && receipt.stderr) {
@@ -844,16 +864,18 @@ var evalJson = /*#__PURE__*/function () {
             response = JSON.parse(receipt.stdout);
 
             if (response.success) {
-              _context2.next = 9;
+              _context2.next = 8;
               break;
             }
 
             throw new Error(JSON.stringify(response.error, null, 2));
 
-          case 9:
-            return _context2.abrupt("return", response);
+          case 8:
+            return _context2.abrupt("return", _extends({}, response, {
+              stderr: receipt.stderr
+            }));
 
-          case 10:
+          case 9:
           case "end":
             return _context2.stop();
         }
@@ -861,10 +883,23 @@ var evalJson = /*#__PURE__*/function () {
     }, _callee2);
   }));
 
-  return function evalJson(_x2) {
+  return function evalRaw(_x2) {
     return _ref4.apply(this, arguments);
   };
 }();
+var evalJson = function evalJson(_ref5) {
+  var contractAddress = _ref5.contractAddress,
+      functionName = _ref5.functionName,
+      provider = _ref5.provider,
+      _ref5$args = _ref5.args,
+      args = _ref5$args === void 0 ? [] : _ref5$args;
+  var code = "(" + functionName + " " + args.join(' ') + ")";
+  return evalRaw({
+    contractAddress: contractAddress,
+    provider: provider,
+    code: code
+  });
+};
 function getAllocations(allocations) {
   if (!allocations) return [];
 
@@ -895,14 +930,14 @@ function stringifyAllocations(allocations) {
 }
 
 var createClarityBin = /*#__PURE__*/function () {
-  var _ref5 = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(_temp) {
-    var _ref6, allocations, _ref6$testnet, testnet, binFile, dbFileName, _allocations, provider, args;
+  var _ref6 = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(_temp) {
+    var _ref7, allocations, _ref7$testnet, testnet, binFile, dbFileName, _allocations, provider, args;
 
     return runtime_1.wrap(function _callee3$(_context3) {
       while (1) {
         switch (_context3.prev = _context3.next) {
           case 0:
-            _ref6 = _temp === void 0 ? {} : _temp, allocations = _ref6.allocations, _ref6$testnet = _ref6.testnet, testnet = _ref6$testnet === void 0 ? true : _ref6$testnet;
+            _ref7 = _temp === void 0 ? {} : _temp, allocations = _ref7.allocations, _ref7$testnet = _ref7.testnet, testnet = _ref7$testnet === void 0 ? true : _ref7$testnet;
             binFile = getDefaultBinaryFilePath();
             dbFileName = getTempFilePath();
             _allocations = getAllocations(allocations);
@@ -926,88 +961,23 @@ var createClarityBin = /*#__PURE__*/function () {
   }));
 
   return function createClarityBin(_x3) {
-    return _ref5.apply(this, arguments);
+    return _ref6.apply(this, arguments);
   };
 }();
-function getDefaultClarityBin(_x4) {
-  return _getDefaultClarityBin.apply(this, arguments);
-}
-
-function _getDefaultClarityBin() {
-  _getDefaultClarityBin = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(clarityBinOrAccounts) {
-    var clarityBin;
-    return runtime_1.wrap(function _callee4$(_context4) {
-      while (1) {
-        switch (_context4.prev = _context4.next) {
-          case 0:
-            if (clarityBinOrAccounts) {
-              _context4.next = 6;
-              break;
-            }
-
-            _context4.next = 3;
-            return createClarityBin();
-
-          case 3:
-            clarityBin = _context4.sent;
-            _context4.next = 17;
-            break;
-
-          case 6:
-            if (!('deployer' in clarityBinOrAccounts)) {
-              _context4.next = 12;
-              break;
-            }
-
-            _context4.next = 9;
-            return createClarityBin({
-              allocations: clarityBinOrAccounts
-            });
-
-          case 9:
-            clarityBin = _context4.sent;
-            _context4.next = 17;
-            break;
-
-          case 12:
-            if (!(clarityBinOrAccounts instanceof NativeClarityBinProvider)) {
-              _context4.next = 16;
-              break;
-            }
-
-            clarityBin = clarityBinOrAccounts;
-            _context4.next = 17;
-            break;
-
-          case 16:
-            throw new Error('Should never get here');
-
-          case 17:
-            return _context4.abrupt("return", clarityBin);
-
-          case 18:
-          case "end":
-            return _context4.stop();
-        }
-      }
-    }, _callee4);
-  }));
-  return _getDefaultClarityBin.apply(this, arguments);
-}
 
 function deployContract(_x5) {
   return _deployContract.apply(this, arguments);
 }
 
 function _deployContract() {
-  _deployContract = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(_ref7) {
+  _deployContract = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(_ref8) {
     var contractIdentifier, contractFilePath, provider, receipt, output, initialization, _initialization$split, error, trace, startLine, matcher, matches;
 
     return runtime_1.wrap(function _callee5$(_context5) {
       while (1) {
         switch (_context5.prev = _context5.next) {
           case 0:
-            contractIdentifier = _ref7.contractIdentifier, contractFilePath = _ref7.contractFilePath, provider = _ref7.provider;
+            contractIdentifier = _ref8.contractIdentifier, contractFilePath = _ref8.contractFilePath, provider = _ref8.provider;
             _context5.next = 3;
             return provider.runCommand(['launch', contractIdentifier, contractFilePath, provider.dbFilePath, '--costs', '--assets']);
 
@@ -1056,6 +1026,14 @@ function _deployContract() {
   return _deployContract.apply(this, arguments);
 }
 
+function getPrints(events) {
+  return filterEvents(events, CoreNodeEventType.ContractEvent).map(function (e) {
+    var hex = e.contract_event.raw_value;
+    var cv = hexToCV(hex);
+    return cvToValue(cv);
+  });
+}
+
 var UTIL_CONTRACT_ID = 'ST000000000000000000002AMW42H.clarigen-test-utils';
 function deployUtilContract(_x) {
   return _deployUtilContract.apply(this, arguments);
@@ -1091,34 +1069,39 @@ function _deployUtilContract() {
   return _deployUtilContract.apply(this, arguments);
 }
 
+function getBin(provider) {
+  return 'clarityBin' in provider ? provider.clarityBin : provider;
+}
+
 function getBlockHeight(_x2) {
   return _getBlockHeight.apply(this, arguments);
 }
 
 function _getBlockHeight() {
   _getBlockHeight = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(provider) {
-    var _yield$evalJson, output_serialized, outputCV, blockHeight;
+    var bin, _yield$evalJson, output_serialized, outputCV, blockHeight;
 
     return runtime_1.wrap(function _callee2$(_context2) {
       while (1) {
         switch (_context2.prev = _context2.next) {
           case 0:
-            _context2.next = 2;
+            bin = getBin(provider);
+            _context2.next = 3;
             return evalJson({
               contractAddress: UTIL_CONTRACT_ID,
               functionName: 'get-block-height',
               args: [],
-              provider: provider
+              provider: bin
             });
 
-          case 2:
+          case 3:
             _yield$evalJson = _context2.sent;
             output_serialized = _yield$evalJson.output_serialized;
-            outputCV = deserializeCV(Buffer.from(output_serialized, 'hex'));
+            outputCV = hexToCV(output_serialized);
             blockHeight = cvToValue(outputCV);
             return _context2.abrupt("return", blockHeight);
 
-          case 7:
+          case 8:
           case "end":
             return _context2.stop();
         }
@@ -1134,20 +1117,22 @@ function mineBlock(_x3) {
 
 function _mineBlock() {
   _mineBlock = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(provider) {
+    var bin;
     return runtime_1.wrap(function _callee3$(_context3) {
       while (1) {
         switch (_context3.prev = _context3.next) {
           case 0:
-            _context3.next = 2;
+            bin = getBin(provider);
+            _context3.next = 3;
             return executeJson({
               contractAddress: UTIL_CONTRACT_ID,
               functionName: 'mine-block',
               args: [],
-              provider: provider,
+              provider: bin,
               senderAddress: 'ST000000000000000000002AMW42H'
             });
 
-          case 2:
+          case 3:
           case "end":
             return _context3.stop();
         }
@@ -1162,29 +1147,30 @@ function mineBlocks(_x4, _x5) {
 }
 
 function _mineBlocks() {
-  _mineBlocks = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(blocks, provider) {
-    var index;
+  _mineBlocks = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(_blocks, provider) {
+    var blocks, index;
     return runtime_1.wrap(function _callee4$(_context4) {
       while (1) {
         switch (_context4.prev = _context4.next) {
           case 0:
+            blocks = intToBigInt(_blocks);
             index = 0;
 
-          case 1:
+          case 2:
             if (!(index < blocks)) {
-              _context4.next = 7;
+              _context4.next = 8;
               break;
             }
 
-            _context4.next = 4;
+            _context4.next = 5;
             return mineBlock(provider);
 
-          case 4:
+          case 5:
             index++;
-            _context4.next = 1;
+            _context4.next = 2;
             break;
 
-          case 7:
+          case 8:
           case "end":
             return _context4.stop();
         }
@@ -1200,28 +1186,29 @@ function getStxBalance(_x6, _x7) {
 
 function _getStxBalance() {
   _getStxBalance = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(provider, account) {
-    var _yield$evalJson2, output_serialized, outputCV, balance;
+    var bin, _yield$evalJson2, output_serialized, outputCV, balance;
 
     return runtime_1.wrap(function _callee5$(_context5) {
       while (1) {
         switch (_context5.prev = _context5.next) {
           case 0:
-            _context5.next = 2;
+            bin = getBin(provider);
+            _context5.next = 3;
             return evalJson({
               contractAddress: UTIL_CONTRACT_ID,
               functionName: 'get-stx-balance',
               args: ["'" + account],
-              provider: provider
+              provider: bin
             });
 
-          case 2:
+          case 3:
             _yield$evalJson2 = _context5.sent;
             output_serialized = _yield$evalJson2.output_serialized;
-            outputCV = deserializeCV(Buffer.from(output_serialized, 'hex'));
+            outputCV = hexToCV(output_serialized);
             balance = cvToValue(outputCV);
             return _context5.abrupt("return", balance);
 
-          case 7:
+          case 8:
           case "end":
             return _context5.stop();
         }
@@ -1231,141 +1218,284 @@ function _getStxBalance() {
   return _getStxBalance.apply(this, arguments);
 }
 
-function tx(_x, _x2) {
-  return _tx2.apply(this, arguments);
+function makeRandomAddress(version) {
+  if (version === void 0) {
+    version = StacksNetworkVersion.testnetP2PKH;
+  }
+
+  var privateKey = makeRandomPrivKey();
+  var publicKey = getPublicKeyFromStacksPrivateKey(privateKey);
+  var address = publicKeyToStxAddress(publicKey.data, version);
+  return address;
+}
+
+function formatArguments(args) {
+  return args.map(function (arg) {
+    return cvToString(arg);
+  });
+}
+
+function getIdentifier(tx) {
+  return tx.contractAddress + "." + tx.contractName;
 }
 
-function _tx2() {
-  _tx2 = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(tx, sender) {
-    var receipt, result;
+function getLogs(stderr) {
+  if (stderr === '') return [];
+  return stderr.split('\n').map(function (line) {
+    return line.slice(62);
+  });
+}
+
+function makeEvalResult(result) {
+  var resultCV = hexToCV(result.output_serialized);
+  var value = cvToValue(resultCV, true);
+  return {
+    value: value,
+    clarityValue: resultCV,
+    logs: getLogs(result.stderr),
+    costs: result.costs
+  };
+}
+
+function ro(_x, _x2) {
+  return _ro.apply(this, arguments);
+}
+
+function _ro() {
+  _ro = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(tx, bin) {
+    var result;
     return runtime_1.wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
             _context.next = 2;
-            return tx.submit({
-              sender: sender
+            return evalJson({
+              functionName: tx["function"].name,
+              args: formatArguments(tx.functionArgs),
+              contractAddress: getIdentifier(tx),
+              provider: bin
             });
 
           case 2:
-            receipt = _context.sent;
-            _context.next = 5;
-            return receipt.getResult();
-
-          case 5:
             result = _context.sent;
-            return _context.abrupt("return", result);
+            return _context.abrupt("return", makeEvalResult(result));
 
-          case 7:
+          case 4:
           case "end":
             return _context.stop();
         }
       }
     }, _callee);
   }));
-  return _tx2.apply(this, arguments);
+  return _ro.apply(this, arguments);
 }
 
-function txOk(_x3, _x4) {
-  return _txOk.apply(this, arguments);
+function evalCode(_x3) {
+  return _evalCode.apply(this, arguments);
 }
 
-function _txOk() {
-  _txOk = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(_tx, sender) {
-    var result;
+function _evalCode() {
+  _evalCode = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(_ref) {
+    var contractAddress, code, bin, result;
     return runtime_1.wrap(function _callee2$(_context2) {
       while (1) {
         switch (_context2.prev = _context2.next) {
           case 0:
-            _context2.next = 2;
-            return tx(_tx, sender);
+            contractAddress = _ref.contractAddress, code = _ref.code, bin = _ref.bin;
+            _context2.next = 3;
+            return evalRaw({
+              contractAddress: contractAddress,
+              code: code,
+              provider: bin
+            });
 
-          case 2:
+          case 3:
             result = _context2.sent;
-
-            if (result.isOk) {
-              _context2.next = 5;
-              break;
-            }
-
-            throw new Error("Expected transaction ok, got error: " + result.value);
+            return _context2.abrupt("return", makeEvalResult(result));
 
           case 5:
-            return _context2.abrupt("return", result);
-
-          case 6:
           case "end":
             return _context2.stop();
         }
       }
     }, _callee2);
   }));
-  return _txOk.apply(this, arguments);
+  return _evalCode.apply(this, arguments);
 }
 
-function txErr(_x5, _x6) {
-  return _txErr.apply(this, arguments);
+function tx(_x4) {
+  return _tx.apply(this, arguments);
 }
 
-function _txErr() {
-  _txErr = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(_tx, sender) {
-    var result;
+function _tx() {
+  _tx = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(_ref2) {
+    var tx, senderAddress, bin, result, resultCV, value, baseReturn;
     return runtime_1.wrap(function _callee3$(_context3) {
       while (1) {
         switch (_context3.prev = _context3.next) {
           case 0:
-            _context3.next = 2;
-            return tx(_tx, sender);
+            tx = _ref2.tx, senderAddress = _ref2.senderAddress, bin = _ref2.bin;
+            _context3.next = 3;
+            return executeJson({
+              contractAddress: getIdentifier(tx),
+              senderAddress: senderAddress,
+              provider: bin,
+              functionName: tx["function"].name,
+              args: formatArguments(tx.functionArgs)
+            });
 
-          case 2:
+          case 3:
             result = _context3.sent;
+            resultCV = hexToCV(result.output_serialized);
+            value = cvToValue(resultCV);
+            baseReturn = {
+              value: value,
+              logs: getLogs(result.stderr),
+              costs: result.costs
+            };
 
-            if (!result.isOk) {
-              _context3.next = 5;
+            if (!result.success) {
+              _context3.next = 9;
               break;
             }
 
-            throw new Error("Expected transaction error, got ok: " + result.value);
+            return _context3.abrupt("return", _extends({}, baseReturn, {
+              isOk: true,
+              response: responseOkCV(resultCV),
+              assets: result.assets,
+              events: result.events,
+              prints: getPrints(result.events)
+            }));
 
-          case 5:
-            return _context3.abrupt("return", result);
+          case 9:
+            return _context3.abrupt("return", _extends({}, baseReturn, {
+              isOk: false,
+              response: responseErrorCV(resultCV)
+            }));
 
-          case 6:
+          case 10:
           case "end":
             return _context3.stop();
         }
       }
     }, _callee3);
   }));
-  return _txErr.apply(this, arguments);
+  return _tx.apply(this, arguments);
+}
+
+function mapGet(_x5) {
+  return _mapGet.apply(this, arguments);
+}
+
+function _mapGet() {
+  _mapGet = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(_ref3) {
+    var map, bin, code, result;
+    return runtime_1.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            map = _ref3.map, bin = _ref3.bin;
+            code = "(map-get? " + map.map.name + " " + cvToString(map.key) + ")";
+            _context4.next = 4;
+            return evalCode({
+              contractAddress: getIdentifier(map),
+              code: code,
+              bin: bin
+            });
+
+          case 4:
+            result = _context4.sent;
+            return _context4.abrupt("return", result.value);
+
+          case 6:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+  return _mapGet.apply(this, arguments);
 }
 
 var TestProvider = /*#__PURE__*/function () {
-  function TestProvider(clarityBin, contractIdentifier, contractFile) {
+  function TestProvider(clarityBin) {
     this.clarityBin = clarityBin;
-    this.contractIdentifier = contractIdentifier;
-    this.contractFile = contractFile;
   }
 
-  TestProvider.create = /*#__PURE__*/function () {
-    var _create = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(_ref) {
-      var clarityBin, contractFilePath, contractIdentifier;
+  TestProvider.fromContracts = /*#__PURE__*/function () {
+    var _fromContracts = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(contracts, options) {
+      var clarityBin, instances, k, contract, identifier, instance, provider;
       return runtime_1.wrap(function _callee$(_context) {
         while (1) {
           switch (_context.prev = _context.next) {
             case 0:
-              clarityBin = _ref.clarityBin, contractFilePath = _ref.contractFilePath, contractIdentifier = _ref.contractIdentifier;
-              _context.next = 3;
+              if (options === void 0) {
+                options = {};
+              }
+
+              _context.t0 = options.clarityBin;
+
+              if (_context.t0) {
+                _context.next = 6;
+                break;
+              }
+
+              _context.next = 5;
+              return createClarityBin$1();
+
+            case 5:
+              _context.t0 = _context.sent;
+
+            case 6:
+              clarityBin = _context.t0;
+              instances = {};
+              _context.next = 10;
+              return deployUtilContract(clarityBin);
+
+            case 10:
+              _context.t1 = runtime_1.keys(contracts);
+
+            case 11:
+              if ((_context.t2 = _context.t1()).done) {
+                _context.next = 22;
+                break;
+              }
+
+              k = _context.t2.value;
+
+              if (!Object.prototype.hasOwnProperty.call(contracts, k)) {
+                _context.next = 20;
+                break;
+              }
+
+              contract = contracts[k];
+              identifier = getContractIdentifier(contract);
+              _context.next = 18;
               return deployContract({
-                contractIdentifier: contractIdentifier,
-                contractFilePath: contractFilePath,
+                contractIdentifier: identifier,
+                contractFilePath: contract.contractFile,
                 provider: clarityBin
               });
 
-            case 3:
-              return _context.abrupt("return", new this(clarityBin, contractIdentifier, contractFilePath));
+            case 18:
+              instance = contract.contract(contract.address, contract.name);
+              instances[k] = {
+                identifier: getContractIdentifier(contract),
+                contract: instance
+              };
 
-            case 4:
+            case 20:
+              _context.next = 11;
+              break;
+
+            case 22:
+              provider = new this(clarityBin);
+              return _context.abrupt("return", {
+                deployed: instances,
+                provider: provider
+              });
+
+            case 24:
             case "end":
               return _context.stop();
           }
@@ -1373,44 +1503,34 @@ var TestProvider = /*#__PURE__*/function () {
       }, _callee, this);
     }));
 
-    function create(_x) {
-      return _create.apply(this, arguments);
+    function fromContracts(_x, _x2) {
+      return _fromContracts.apply(this, arguments);
     }
 
-    return create;
+    return fromContracts;
   }();
 
-  TestProvider.fromContract = /*#__PURE__*/function () {
-    var _fromContract = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(_ref2) {
-      var contract, clarityBin, address, contractName, provider;
+  var _proto = TestProvider.prototype;
+
+  _proto.ro = function ro$1(tx) {
+    return ro(tx, this.clarityBin);
+  };
+
+  _proto.rov = /*#__PURE__*/function () {
+    var _rov = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(tx) {
+      var result;
       return runtime_1.wrap(function _callee2$(_context2) {
         while (1) {
           switch (_context2.prev = _context2.next) {
             case 0:
-              contract = _ref2.contract, clarityBin = _ref2.clarityBin;
-              address = contract.address;
+              _context2.next = 2;
+              return this.ro(tx);
 
-              if (address) {
-                _context2.next = 4;
-                break;
-              }
-
-              throw new Error('TestProvider must have an address');
+            case 2:
+              result = _context2.sent;
+              return _context2.abrupt("return", result.value);
 
             case 4:
-              contractName = contract.name || getContractNameFromPath(contract.contractFile);
-              _context2.next = 7;
-              return this.create({
-                clarityBin: clarityBin,
-                contractFilePath: contract.contractFile,
-                contractIdentifier: address + "." + contractName
-              });
-
-            case 7:
-              provider = _context2.sent;
-              return _context2.abrupt("return", contract.contract(provider));
-
-            case 9:
             case "end":
               return _context2.stop();
           }
@@ -1418,216 +1538,275 @@ var TestProvider = /*#__PURE__*/function () {
       }, _callee2, this);
     }));
 
-    function fromContract(_x2) {
-      return _fromContract.apply(this, arguments);
+    function rov(_x3) {
+      return _rov.apply(this, arguments);
     }
 
-    return fromContract;
+    return rov;
   }();
 
-  TestProvider.fromContracts = /*#__PURE__*/function () {
-    var _fromContracts = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(contracts, clarityBinOrAccounts) {
-      var clarityBin, instances, k, contract, instance;
+  _proto.roOk = /*#__PURE__*/function () {
+    var _roOk = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(tx) {
+      var result;
       return runtime_1.wrap(function _callee3$(_context3) {
         while (1) {
           switch (_context3.prev = _context3.next) {
             case 0:
               _context3.next = 2;
-              return getDefaultClarityBin(clarityBinOrAccounts);
+              return this.ro(tx);
 
             case 2:
-              clarityBin = _context3.sent;
-              instances = {};
-              _context3.next = 6;
-              return deployUtilContract(clarityBin);
+              result = _context3.sent;
+              return _context3.abrupt("return", result.value.match(function (ok) {
+                return _extends({}, result, {
+                  value: ok
+                });
+              }, function (err) {
+                throw new Error("Expected OK, received error: " + err);
+              }));
 
-            case 6:
-              _context3.t0 = runtime_1.keys(contracts);
+            case 4:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3, this);
+    }));
 
-            case 7:
-              if ((_context3.t1 = _context3.t0()).done) {
-                _context3.next = 16;
-                break;
-              }
+    function roOk(_x4) {
+      return _roOk.apply(this, arguments);
+    }
 
-              k = _context3.t1.value;
-              contract = contracts[k];
-              _context3.next = 12;
-              return this.fromContract({
-                contract: contract,
-                clarityBin: clarityBin
-              });
+    return roOk;
+  }();
 
-            case 12:
-              instance = _context3.sent;
-              instances[k] = {
-                identifier: getContractIdentifier(contract),
-                contract: instance
-              };
-              _context3.next = 7;
-              break;
+  _proto.roErr = /*#__PURE__*/function () {
+    var _roErr = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(tx) {
+      var result;
+      return runtime_1.wrap(function _callee4$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
+            case 0:
+              _context4.next = 2;
+              return this.ro(tx);
 
-            case 16:
-              return _context3.abrupt("return", instances);
+            case 2:
+              result = _context4.sent;
+              return _context4.abrupt("return", result.value.match(function (ok) {
+                throw new Error("Expected err, received ok: " + ok);
+              }, function (err) {
+                return _extends({}, result, {
+                  value: err
+                });
+              }));
 
-            case 17:
+            case 4:
             case "end":
-              return _context3.stop();
+              return _context4.stop();
           }
         }
-      }, _callee3, this);
+      }, _callee4, this);
     }));
 
-    function fromContracts(_x3, _x4) {
-      return _fromContracts.apply(this, arguments);
+    function roErr(_x5) {
+      return _roErr.apply(this, arguments);
     }
 
-    return fromContracts;
+    return roErr;
   }();
 
-  var _proto = TestProvider.prototype;
+  _proto.rovOk = /*#__PURE__*/function () {
+    var _rovOk = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(tx) {
+      return runtime_1.wrap(function _callee5$(_context5) {
+        while (1) {
+          switch (_context5.prev = _context5.next) {
+            case 0:
+              _context5.next = 2;
+              return this.roOk(tx);
 
-  _proto.callReadOnly = /*#__PURE__*/function () {
-    var _callReadOnly = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(func, args) {
-      var argsFormatted, result, resultCV, value;
-      return runtime_1.wrap(function _callee4$(_context4) {
+            case 2:
+              return _context5.abrupt("return", _context5.sent.value);
+
+            case 3:
+            case "end":
+              return _context5.stop();
+          }
+        }
+      }, _callee5, this);
+    }));
+
+    function rovOk(_x6) {
+      return _rovOk.apply(this, arguments);
+    }
+
+    return rovOk;
+  }();
+
+  _proto.rovErr = /*#__PURE__*/function () {
+    var _rovErr = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6(tx) {
+      return runtime_1.wrap(function _callee6$(_context6) {
         while (1) {
-          switch (_context4.prev = _context4.next) {
+          switch (_context6.prev = _context6.next) {
             case 0:
-              argsFormatted = this.formatArguments(func, args);
-              _context4.next = 3;
-              return evalJson({
-                contractAddress: this.contractIdentifier,
-                functionName: func.name,
-                args: argsFormatted,
-                provider: this.clarityBin
-              });
+              _context6.next = 2;
+              return this.roErr(tx);
+
+            case 2:
+              return _context6.abrupt("return", _context6.sent.value);
 
             case 3:
-              result = _context4.sent;
-              resultCV = deserializeCV(Buffer.from(result.output_serialized, 'hex'));
-              value = cvToValue(resultCV);
-              _context4.t0 = resultCV.type;
-              _context4.next = _context4.t0 === ClarityType.ResponseOk ? 9 : _context4.t0 === ClarityType.ResponseErr ? 10 : 11;
-              break;
+            case "end":
+              return _context6.stop();
+          }
+        }
+      }, _callee6, this);
+    }));
 
-            case 9:
-              return _context4.abrupt("return", ok(value));
+    function rovErr(_x7) {
+      return _rovErr.apply(this, arguments);
+    }
 
-            case 10:
-              return _context4.abrupt("return", err(value));
+    return rovErr;
+  }();
 
-            case 11:
-              return _context4.abrupt("return", value);
+  _proto.tx = function tx$1(_tx2, senderAddress) {
+    return tx({
+      tx: _tx2,
+      senderAddress: senderAddress,
+      bin: this.clarityBin
+    });
+  };
 
-            case 12:
+  _proto.txOk = /*#__PURE__*/function () {
+    var _txOk = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee7(tx, senderAddress) {
+      var result;
+      return runtime_1.wrap(function _callee7$(_context7) {
+        while (1) {
+          switch (_context7.prev = _context7.next) {
+            case 0:
+              _context7.next = 2;
+              return this.tx(tx, senderAddress);
+
+            case 2:
+              result = _context7.sent;
+
+              if (result.isOk) {
+                _context7.next = 5;
+                break;
+              }
+
+              throw new Error("Expected OK, received error: " + result.value);
+
+            case 5:
+              return _context7.abrupt("return", result);
+
+            case 6:
             case "end":
-              return _context4.stop();
+              return _context7.stop();
           }
         }
-      }, _callee4, this);
+      }, _callee7, this);
     }));
 
-    function callReadOnly(_x5, _x6) {
-      return _callReadOnly.apply(this, arguments);
+    function txOk(_x8, _x9) {
+      return _txOk.apply(this, arguments);
     }
 
-    return callReadOnly;
+    return txOk;
   }();
 
-  _proto.callPublic = function callPublic(func, args) {
-    var _this = this;
-
-    var argsFormatted = this.formatArguments(func, args);
-
-    var submit = /*#__PURE__*/function () {
-      var _ref3 = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(options) {
-        var receipt, getResult;
-        return runtime_1.wrap(function _callee5$(_context5) {
-          while (1) {
-            switch (_context5.prev = _context5.next) {
-              case 0:
-                if ('sender' in options) {
-                  _context5.next = 2;
-                  break;
-                }
-
-                throw new Error('Passing `sender` is required.');
-
-              case 2:
-                _context5.next = 4;
-                return executeJson({
-                  provider: _this.clarityBin,
-                  contractAddress: _this.contractIdentifier,
-                  senderAddress: options.sender,
-                  functionName: func.name,
-                  args: argsFormatted
-                });
+  _proto.txErr = /*#__PURE__*/function () {
+    var _txErr = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee8(tx, senderAddress) {
+      var result;
+      return runtime_1.wrap(function _callee8$(_context8) {
+        while (1) {
+          switch (_context8.prev = _context8.next) {
+            case 0:
+              _context8.next = 2;
+              return this.tx(tx, senderAddress);
 
-              case 4:
-                receipt = _context5.sent;
-
-                getResult = function getResult() {
-                  var resultCV = deserializeCV(Buffer.from(receipt.output_serialized, 'hex'));
-                  var result = cvToValue(resultCV);
-
-                  if (receipt.success) {
-                    return Promise.resolve({
-                      isOk: true,
-                      response: responseOkCV(resultCV),
-                      value: result,
-                      events: receipt.events,
-                      costs: receipt.costs,
-                      assets: receipt.assets
-                    });
-                  } else {
-                    return Promise.resolve({
-                      isOk: false,
-                      response: responseErrorCV(resultCV),
-                      value: result,
-                      costs: receipt.costs
-                    });
-                  }
-                };
-
-                return _context5.abrupt("return", {
-                  getResult: getResult
-                });
+            case 2:
+              result = _context8.sent;
 
-              case 7:
-              case "end":
-                return _context5.stop();
-            }
+              if (!result.isOk) {
+                _context8.next = 5;
+                break;
+              }
+
+              throw new Error("Expected Err, received ok: " + result.value);
+
+            case 5:
+              return _context8.abrupt("return", result);
+
+            case 6:
+            case "end":
+              return _context8.stop();
           }
-        }, _callee5);
-      }));
+        }
+      }, _callee8, this);
+    }));
 
-      return function submit(_x7) {
-        return _ref3.apply(this, arguments);
-      };
-    }();
+    function txErr(_x10, _x11) {
+      return _txErr.apply(this, arguments);
+    }
 
-    return {
-      submit: submit
-    };
+    return txErr;
+  }();
+
+  _proto.evalCode = function evalCode$1(code, contractAddress) {
+    if (contractAddress === void 0) {
+      contractAddress = UTIL_CONTRACT_ID;
+    }
+
+    return evalCode({
+      contractAddress: contractAddress,
+      code: code,
+      bin: this.clarityBin
+    });
   };
 
-  _proto.formatArguments = function formatArguments(func, args) {
-    return args.map(function (arg, index) {
-      var type = func.args[index].type;
+  _proto.eval = /*#__PURE__*/function () {
+    var _eval2 = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee9(code, contractAddress) {
+      var result;
+      return runtime_1.wrap(function _callee9$(_context9) {
+        while (1) {
+          switch (_context9.prev = _context9.next) {
+            case 0:
+              if (contractAddress === void 0) {
+                contractAddress = UTIL_CONTRACT_ID;
+              }
+
+              _context9.next = 3;
+              return this.evalCode(code, contractAddress);
 
-      if (type === 'trait_reference') {
-        return "'" + arg;
-      }
+            case 3:
+              result = _context9.sent;
+              return _context9.abrupt("return", result.value);
+
+            case 5:
+            case "end":
+              return _context9.stop();
+          }
+        }
+      }, _callee9, this);
+    }));
+
+    function _eval(_x12, _x13) {
+      return _eval2.apply(this, arguments);
+    }
+
+    return _eval;
+  }();
 
-      var argCV = parseToCV(arg, type);
-      var cvString = cvToString(argCV);
-      return cvString;
+  _proto.mapGet = function mapGet$1(map) {
+    return mapGet({
+      map: map,
+      bin: this.clarityBin
     });
   };
 
   return TestProvider;
 }();
 
-export { TestProvider, createClarityBin, evalJson, executeJson, getBlockHeight, getStxBalance, mineBlocks, tx, txErr, txOk };
+export { TestProvider, createClarityBin, evalJson, executeJson, getBlockHeight, getStxBalance, makeRandomAddress, mineBlocks };
 //# sourceMappingURL=test.esm.js.map