@clarigen/test 1.0.0-next.16 → 1.0.0-next.19
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.d.ts +4 -69
- package/dist/index.js +364 -17
- package/dist/index.mjs +364 -17
- package/package.json +4 -4
package/dist/index.d.ts
CHANGED
|
@@ -1,75 +1,10 @@
|
|
|
1
|
-
import {
|
|
1
|
+
import { CoreNodeEvent, ResultAssets, Contracts, ContractCall, Response, ContractCalls, ContractInstances } from '@clarigen/core';
|
|
2
|
+
import { Costs, NativeClarityBinProvider, ClarinetAccounts } from '@clarigen/native-bin';
|
|
3
|
+
export { Allocation, createClarityBin, evalJson, executeJson } from '@clarigen/native-bin';
|
|
2
4
|
import { ClarityValue, ResponseCV } from 'micro-stacks/clarity';
|
|
3
|
-
import { NativeClarityBinProvider } from '@clarigen/native-bin';
|
|
4
5
|
import { StacksNetworkVersion } from 'micro-stacks/crypto';
|
|
5
6
|
import { IntegerType } from 'micro-stacks/common';
|
|
6
7
|
|
|
7
|
-
interface Allocation {
|
|
8
|
-
principal: string;
|
|
9
|
-
amount: bigint;
|
|
10
|
-
}
|
|
11
|
-
interface Costs {
|
|
12
|
-
read_count: number;
|
|
13
|
-
read_length: number;
|
|
14
|
-
runtime: number;
|
|
15
|
-
write_count: number;
|
|
16
|
-
write_length: number;
|
|
17
|
-
}
|
|
18
|
-
interface ExecuteOk {
|
|
19
|
-
success: true;
|
|
20
|
-
message: string;
|
|
21
|
-
events: any[];
|
|
22
|
-
output_serialized: string;
|
|
23
|
-
costs: Costs;
|
|
24
|
-
assets: ResultAssets;
|
|
25
|
-
stderr: string;
|
|
26
|
-
}
|
|
27
|
-
interface ExecuteErr {
|
|
28
|
-
message: string;
|
|
29
|
-
error: any;
|
|
30
|
-
output_serialized: string;
|
|
31
|
-
costs: Costs;
|
|
32
|
-
success: false;
|
|
33
|
-
stderr: string;
|
|
34
|
-
}
|
|
35
|
-
declare type ExecuteResult = ExecuteOk | ExecuteErr;
|
|
36
|
-
declare const executeJson: ({ contractAddress, senderAddress, functionName, provider, args, coverageFolder, }: {
|
|
37
|
-
contractAddress: string;
|
|
38
|
-
senderAddress: string;
|
|
39
|
-
provider: NativeClarityBinProvider;
|
|
40
|
-
functionName: string;
|
|
41
|
-
args?: string[] | undefined;
|
|
42
|
-
coverageFolder?: string | undefined;
|
|
43
|
-
}) => Promise<ExecuteResult>;
|
|
44
|
-
interface EvalOk {
|
|
45
|
-
success: true;
|
|
46
|
-
costs: Costs;
|
|
47
|
-
output_serialized: string;
|
|
48
|
-
}
|
|
49
|
-
interface Eval extends EvalOk {
|
|
50
|
-
stderr: string;
|
|
51
|
-
}
|
|
52
|
-
declare const evalJson: ({ contractAddress, functionName, provider, args, coverageFolder, }: {
|
|
53
|
-
contractAddress: string;
|
|
54
|
-
functionName: string;
|
|
55
|
-
provider: NativeClarityBinProvider;
|
|
56
|
-
args?: string[] | undefined;
|
|
57
|
-
coverageFolder?: string | undefined;
|
|
58
|
-
}) => Promise<Eval>;
|
|
59
|
-
interface ClarinetAccount {
|
|
60
|
-
balance: bigint;
|
|
61
|
-
address: string;
|
|
62
|
-
}
|
|
63
|
-
interface ClarinetAccounts {
|
|
64
|
-
deployer: ClarinetAccount;
|
|
65
|
-
[key: string]: ClarinetAccount;
|
|
66
|
-
}
|
|
67
|
-
declare type AllocationOrAccounts = ClarinetAccounts | Allocation[];
|
|
68
|
-
declare const createClarityBin: ({ allocations, testnet, }?: {
|
|
69
|
-
allocations?: AllocationOrAccounts | undefined;
|
|
70
|
-
testnet?: boolean | undefined;
|
|
71
|
-
}) => Promise<NativeClarityBinProvider>;
|
|
72
|
-
|
|
73
8
|
interface ReadOnlyResult<T> {
|
|
74
9
|
value: T;
|
|
75
10
|
clarityValue: ClarityValue;
|
|
@@ -136,4 +71,4 @@ declare class TestProvider {
|
|
|
136
71
|
mapGet<T extends ContractCalls.Map<any, Val>, Val>(map: T): Promise<Val | null>;
|
|
137
72
|
}
|
|
138
73
|
|
|
139
|
-
export {
|
|
74
|
+
export { PublicResultErr, PublicResultOk, ReadOnlyResult, TestProvider, finishCoverage, getBlockHeight, getStxBalance, makeRandomAddress, mineBlocks, setupCoverage };
|
package/dist/index.js
CHANGED
|
@@ -1,17 +1,364 @@
|
|
|
1
|
-
"use strict";Object.defineProperty(exports, "__esModule", {value: true});var
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
1
|
+
"use strict";Object.defineProperty(exports, "__esModule", {value: true});var __defProp = Object.defineProperty;
|
|
2
|
+
var __defProps = Object.defineProperties;
|
|
3
|
+
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
|
|
4
|
+
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
|
|
5
|
+
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
6
|
+
var __propIsEnum = Object.prototype.propertyIsEnumerable;
|
|
7
|
+
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
8
|
+
var __spreadValues = (a, b) => {
|
|
9
|
+
for (var prop in b || (b = {}))
|
|
10
|
+
if (__hasOwnProp.call(b, prop))
|
|
11
|
+
__defNormalProp(a, prop, b[prop]);
|
|
12
|
+
if (__getOwnPropSymbols)
|
|
13
|
+
for (var prop of __getOwnPropSymbols(b)) {
|
|
14
|
+
if (__propIsEnum.call(b, prop))
|
|
15
|
+
__defNormalProp(a, prop, b[prop]);
|
|
16
|
+
}
|
|
17
|
+
return a;
|
|
18
|
+
};
|
|
19
|
+
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
|
|
20
|
+
|
|
21
|
+
// src/index.ts
|
|
22
|
+
|
|
23
|
+
|
|
24
|
+
|
|
25
|
+
var _nativebin = require('@clarigen/native-bin');
|
|
26
|
+
|
|
27
|
+
|
|
28
|
+
|
|
29
|
+
|
|
30
|
+
var _core = require('@clarigen/core');
|
|
31
|
+
|
|
32
|
+
// src/utils/index.ts
|
|
33
|
+
var _crypto = require('micro-stacks/crypto');
|
|
34
|
+
var _transactions = require('micro-stacks/transactions');
|
|
35
|
+
|
|
36
|
+
// src/utils/util-contract.ts
|
|
37
|
+
var _clarity = require('micro-stacks/clarity');
|
|
38
|
+
var _path = require('path');
|
|
39
|
+
|
|
40
|
+
|
|
41
|
+
var _common = require('micro-stacks/common');
|
|
42
|
+
var UTIL_CONTRACT_ID = "ST000000000000000000002AMW42H.clarigen-test-utils";
|
|
43
|
+
async function deployUtilContract(clarityBin) {
|
|
44
|
+
let contractFilePath = _path.join.call(void 0, __dirname, "..", "..", "contracts", "test-utils.clar");
|
|
45
|
+
if (__dirname.includes("dist")) {
|
|
46
|
+
contractFilePath = _path.join.call(void 0, __dirname, "..", "contracts", "test-utils.clar");
|
|
47
|
+
}
|
|
48
|
+
await _nativebin.deployContract.call(void 0, {
|
|
49
|
+
contractIdentifier: UTIL_CONTRACT_ID,
|
|
50
|
+
provider: clarityBin,
|
|
51
|
+
contractFilePath
|
|
52
|
+
});
|
|
53
|
+
}
|
|
54
|
+
function getBin(provider) {
|
|
55
|
+
return "clarityBin" in provider ? provider.clarityBin : provider;
|
|
56
|
+
}
|
|
57
|
+
async function getBlockHeight(provider) {
|
|
58
|
+
const bin = getBin(provider);
|
|
59
|
+
const { output_serialized } = await _nativebin.evalJson.call(void 0, {
|
|
60
|
+
contractAddress: UTIL_CONTRACT_ID,
|
|
61
|
+
functionName: "get-block-height",
|
|
62
|
+
args: [],
|
|
63
|
+
provider: bin
|
|
64
|
+
});
|
|
65
|
+
const outputCV = _clarity.hexToCV.call(void 0, output_serialized);
|
|
66
|
+
const blockHeight = _core.cvToValue.call(void 0, outputCV);
|
|
67
|
+
return blockHeight;
|
|
68
|
+
}
|
|
69
|
+
async function mineBlock(provider) {
|
|
70
|
+
const bin = getBin(provider);
|
|
71
|
+
await _nativebin.executeJson.call(void 0, {
|
|
72
|
+
contractAddress: UTIL_CONTRACT_ID,
|
|
73
|
+
functionName: "mine-block",
|
|
74
|
+
args: [],
|
|
75
|
+
provider: bin,
|
|
76
|
+
senderAddress: "ST000000000000000000002AMW42H"
|
|
77
|
+
});
|
|
78
|
+
}
|
|
79
|
+
async function mineBlocks(_blocks, provider) {
|
|
80
|
+
const blocks = _common.intToBigInt.call(void 0, _blocks);
|
|
81
|
+
for (let index = 0; index < blocks; index++) {
|
|
82
|
+
await mineBlock(provider);
|
|
83
|
+
}
|
|
84
|
+
}
|
|
85
|
+
async function getStxBalance(provider, account) {
|
|
86
|
+
const bin = getBin(provider);
|
|
87
|
+
const { output_serialized } = await _nativebin.evalJson.call(void 0, {
|
|
88
|
+
contractAddress: UTIL_CONTRACT_ID,
|
|
89
|
+
functionName: "get-stx-balance",
|
|
90
|
+
args: [`'${account}`],
|
|
91
|
+
provider: bin
|
|
92
|
+
});
|
|
93
|
+
const outputCV = _clarity.hexToCV.call(void 0, output_serialized);
|
|
94
|
+
const balance = _core.cvToValue.call(void 0, outputCV);
|
|
95
|
+
return balance;
|
|
96
|
+
}
|
|
97
|
+
|
|
98
|
+
// src/utils/coverage.ts
|
|
99
|
+
var _promises = require('fs/promises');
|
|
100
|
+
|
|
101
|
+
async function setupCoverage(dir) {
|
|
102
|
+
const dirName = _path.resolve.call(void 0, process.cwd(), "coverage");
|
|
103
|
+
try {
|
|
104
|
+
await _promises.mkdir.call(void 0, dirName);
|
|
105
|
+
} catch (error) {
|
|
106
|
+
}
|
|
107
|
+
const files = await _promises.readdir.call(void 0, dirName);
|
|
108
|
+
const removals = files.map((file) => {
|
|
109
|
+
return _promises.unlink.call(void 0, _path.join.call(void 0, dirName, file));
|
|
110
|
+
});
|
|
111
|
+
await Promise.all(removals);
|
|
112
|
+
return dirName;
|
|
113
|
+
}
|
|
114
|
+
async function finishCoverage(provider, dir) {
|
|
115
|
+
const lcovFile = _path.join.call(void 0, dir, "clarigen.lcov");
|
|
116
|
+
await provider.runCommand(["make_lcov", dir, lcovFile]);
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
// src/utils/index.ts
|
|
120
|
+
function makeRandomAddress(version = _crypto.StacksNetworkVersion.testnetP2PKH) {
|
|
121
|
+
const privateKey = _transactions.makeRandomPrivKey.call(void 0, );
|
|
122
|
+
const publicKey = _transactions.getPublicKeyFromStacksPrivateKey.call(void 0, privateKey);
|
|
123
|
+
const address = _crypto.publicKeyToStxAddress.call(void 0, publicKey.data, version);
|
|
124
|
+
return address;
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
// src/utils/pure.ts
|
|
128
|
+
|
|
129
|
+
|
|
130
|
+
|
|
131
|
+
|
|
132
|
+
|
|
133
|
+
|
|
134
|
+
|
|
135
|
+
|
|
136
|
+
|
|
137
|
+
|
|
138
|
+
|
|
139
|
+
|
|
140
|
+
|
|
141
|
+
|
|
142
|
+
|
|
143
|
+
|
|
144
|
+
function getPrints(events) {
|
|
145
|
+
return _core.filterEvents.call(void 0, events, _core.CoreNodeEventType.ContractEvent).map((e) => {
|
|
146
|
+
const hex = e.contract_event.raw_value;
|
|
147
|
+
const cv = _clarity.hexToCV.call(void 0, hex);
|
|
148
|
+
return _core.cvToValue.call(void 0, cv);
|
|
149
|
+
});
|
|
150
|
+
}
|
|
151
|
+
function formatArguments(args) {
|
|
152
|
+
return args.map((arg) => _core.cvToString.call(void 0, arg));
|
|
153
|
+
}
|
|
154
|
+
function getIdentifier(tx2) {
|
|
155
|
+
return `${tx2.contractAddress}.${tx2.contractName}`;
|
|
156
|
+
}
|
|
157
|
+
function getLogs(stderr) {
|
|
158
|
+
if (stderr === "")
|
|
159
|
+
return [];
|
|
160
|
+
return stderr.split("\n").map((line) => line.slice(62));
|
|
161
|
+
}
|
|
162
|
+
function makeEvalResult(result) {
|
|
163
|
+
const resultCV = _clarity.hexToCV.call(void 0, result.output_serialized);
|
|
164
|
+
const value = _core.cvToValue.call(void 0, resultCV, true);
|
|
165
|
+
return {
|
|
166
|
+
value,
|
|
167
|
+
clarityValue: resultCV,
|
|
168
|
+
logs: getLogs(result.stderr),
|
|
169
|
+
costs: result.costs
|
|
170
|
+
};
|
|
171
|
+
}
|
|
172
|
+
async function ro({
|
|
173
|
+
tx: tx2,
|
|
174
|
+
bin,
|
|
175
|
+
coverageFolder
|
|
176
|
+
}) {
|
|
177
|
+
const result = await _nativebin.evalJson.call(void 0, {
|
|
178
|
+
functionName: tx2.function.name,
|
|
179
|
+
args: formatArguments(tx2.functionArgs),
|
|
180
|
+
contractAddress: getIdentifier(tx2),
|
|
181
|
+
provider: bin,
|
|
182
|
+
coverageFolder
|
|
183
|
+
});
|
|
184
|
+
return makeEvalResult(result);
|
|
185
|
+
}
|
|
186
|
+
async function evalCode({
|
|
187
|
+
contractAddress,
|
|
188
|
+
code,
|
|
189
|
+
bin,
|
|
190
|
+
coverageFolder
|
|
191
|
+
}) {
|
|
192
|
+
const result = await _nativebin.evalRaw.call(void 0, {
|
|
193
|
+
contractAddress,
|
|
194
|
+
code,
|
|
195
|
+
provider: bin,
|
|
196
|
+
coverageFolder
|
|
197
|
+
});
|
|
198
|
+
return makeEvalResult(result);
|
|
199
|
+
}
|
|
200
|
+
async function tx({
|
|
201
|
+
tx: tx2,
|
|
202
|
+
senderAddress,
|
|
203
|
+
bin,
|
|
204
|
+
coverageFolder
|
|
205
|
+
}) {
|
|
206
|
+
const result = await _nativebin.executeJson.call(void 0, {
|
|
207
|
+
contractAddress: getIdentifier(tx2),
|
|
208
|
+
senderAddress,
|
|
209
|
+
provider: bin,
|
|
210
|
+
functionName: tx2.function.name,
|
|
211
|
+
args: formatArguments(tx2.functionArgs),
|
|
212
|
+
coverageFolder
|
|
213
|
+
});
|
|
214
|
+
const resultCV = _clarity.hexToCV.call(void 0, result.output_serialized);
|
|
215
|
+
const value = _core.cvToValue.call(void 0, resultCV);
|
|
216
|
+
const baseReturn = {
|
|
217
|
+
value,
|
|
218
|
+
logs: getLogs(result.stderr),
|
|
219
|
+
costs: result.costs
|
|
220
|
+
};
|
|
221
|
+
if (result.success) {
|
|
222
|
+
return __spreadProps(__spreadValues({}, baseReturn), {
|
|
223
|
+
isOk: true,
|
|
224
|
+
response: _clarity.responseOkCV.call(void 0, resultCV),
|
|
225
|
+
assets: result.assets,
|
|
226
|
+
events: result.events,
|
|
227
|
+
prints: getPrints(result.events)
|
|
228
|
+
});
|
|
229
|
+
}
|
|
230
|
+
return __spreadProps(__spreadValues({}, baseReturn), {
|
|
231
|
+
isOk: false,
|
|
232
|
+
response: _clarity.responseErrorCV.call(void 0, resultCV)
|
|
233
|
+
});
|
|
234
|
+
}
|
|
235
|
+
async function mapGet({
|
|
236
|
+
map,
|
|
237
|
+
bin
|
|
238
|
+
}) {
|
|
239
|
+
const code = `(map-get? ${map.map.name} ${_core.cvToString.call(void 0, map.key)})`;
|
|
240
|
+
const result = await evalCode({
|
|
241
|
+
contractAddress: getIdentifier(map),
|
|
242
|
+
code,
|
|
243
|
+
bin
|
|
244
|
+
});
|
|
245
|
+
return result.value;
|
|
246
|
+
}
|
|
247
|
+
|
|
248
|
+
// src/index.ts
|
|
249
|
+
|
|
250
|
+
|
|
251
|
+
var TestProvider = class {
|
|
252
|
+
constructor(clarityBin) {
|
|
253
|
+
this.clarityBin = clarityBin;
|
|
254
|
+
}
|
|
255
|
+
static async fromContracts(contracts, options = {}) {
|
|
256
|
+
const clarityBin = options.clarityBin || await _nativebin.createClarityBin.call(void 0, {
|
|
257
|
+
allocations: options.accounts
|
|
258
|
+
});
|
|
259
|
+
const instances = {};
|
|
260
|
+
let coverageFolder = options.coverageFolder;
|
|
261
|
+
if (process.env.CLARIGEN_COVERAGE) {
|
|
262
|
+
coverageFolder = _path.resolve.call(void 0, process.cwd(), "coverage");
|
|
263
|
+
}
|
|
264
|
+
await deployUtilContract(clarityBin);
|
|
265
|
+
for (const k in contracts) {
|
|
266
|
+
if (Object.prototype.hasOwnProperty.call(contracts, k)) {
|
|
267
|
+
const contract = contracts[k];
|
|
268
|
+
const identifier = _core.getContractIdentifier.call(void 0, contract);
|
|
269
|
+
await _nativebin.deployContract.call(void 0, {
|
|
270
|
+
contractIdentifier: identifier,
|
|
271
|
+
contractFilePath: contract.contractFile,
|
|
272
|
+
provider: clarityBin,
|
|
273
|
+
coverageFolder
|
|
274
|
+
});
|
|
275
|
+
const instance = contract.contract(contract.address, contract.name);
|
|
276
|
+
instances[k] = {
|
|
277
|
+
identifier: _core.getContractIdentifier.call(void 0, contract),
|
|
278
|
+
contract: instance
|
|
279
|
+
};
|
|
280
|
+
}
|
|
281
|
+
}
|
|
282
|
+
const provider = new this(clarityBin);
|
|
283
|
+
provider.coverageFolder = coverageFolder;
|
|
284
|
+
return {
|
|
285
|
+
deployed: instances,
|
|
286
|
+
provider
|
|
287
|
+
};
|
|
288
|
+
}
|
|
289
|
+
ro(tx2) {
|
|
290
|
+
return ro({ tx: tx2, bin: this.clarityBin, coverageFolder: this.coverageFolder });
|
|
291
|
+
}
|
|
292
|
+
async rov(tx2) {
|
|
293
|
+
const result = await this.ro(tx2);
|
|
294
|
+
return result.value;
|
|
295
|
+
}
|
|
296
|
+
async roOk(tx2) {
|
|
297
|
+
const result = await this.ro(tx2);
|
|
298
|
+
const value = _core.expectOk.call(void 0, result.value);
|
|
299
|
+
return __spreadProps(__spreadValues({}, result), {
|
|
300
|
+
value
|
|
301
|
+
});
|
|
302
|
+
}
|
|
303
|
+
async roErr(tx2) {
|
|
304
|
+
const result = await this.ro(tx2);
|
|
305
|
+
const value = _core.expectErr.call(void 0, result.value);
|
|
306
|
+
return __spreadProps(__spreadValues({}, result), {
|
|
307
|
+
value
|
|
308
|
+
});
|
|
309
|
+
}
|
|
310
|
+
async rovOk(tx2) {
|
|
311
|
+
return (await this.roOk(tx2)).value;
|
|
312
|
+
}
|
|
313
|
+
async rovErr(tx2) {
|
|
314
|
+
return (await this.roErr(tx2)).value;
|
|
315
|
+
}
|
|
316
|
+
tx(tx2, senderAddress) {
|
|
317
|
+
return tx({
|
|
318
|
+
tx: tx2,
|
|
319
|
+
senderAddress,
|
|
320
|
+
bin: this.clarityBin,
|
|
321
|
+
coverageFolder: this.coverageFolder
|
|
322
|
+
});
|
|
323
|
+
}
|
|
324
|
+
async txOk(tx2, senderAddress) {
|
|
325
|
+
const result = await this.tx(tx2, senderAddress);
|
|
326
|
+
if (!result.isOk)
|
|
327
|
+
throw new Error(`Expected OK, received error: ${result.value}`);
|
|
328
|
+
return result;
|
|
329
|
+
}
|
|
330
|
+
async txErr(tx2, senderAddress) {
|
|
331
|
+
const result = await this.tx(tx2, senderAddress);
|
|
332
|
+
if (result.isOk)
|
|
333
|
+
throw new Error(`Expected Err, received ok: ${result.value}`);
|
|
334
|
+
return result;
|
|
335
|
+
}
|
|
336
|
+
evalCode(code, contractAddress = UTIL_CONTRACT_ID) {
|
|
337
|
+
return evalCode({
|
|
338
|
+
contractAddress,
|
|
339
|
+
code,
|
|
340
|
+
bin: this.clarityBin,
|
|
341
|
+
coverageFolder: this.coverageFolder
|
|
342
|
+
});
|
|
343
|
+
}
|
|
344
|
+
async eval(code, contractAddress = UTIL_CONTRACT_ID) {
|
|
345
|
+
const result = await this.evalCode(code, contractAddress);
|
|
346
|
+
return result.value;
|
|
347
|
+
}
|
|
348
|
+
mapGet(map) {
|
|
349
|
+
return mapGet({ map, bin: this.clarityBin });
|
|
350
|
+
}
|
|
351
|
+
};
|
|
352
|
+
|
|
353
|
+
|
|
354
|
+
|
|
355
|
+
|
|
356
|
+
|
|
357
|
+
|
|
358
|
+
|
|
359
|
+
|
|
360
|
+
|
|
361
|
+
|
|
362
|
+
|
|
363
|
+
|
|
364
|
+
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;
|
package/dist/index.mjs
CHANGED
|
@@ -1,17 +1,364 @@
|
|
|
1
|
-
var
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
1
|
+
var __defProp = Object.defineProperty;
|
|
2
|
+
var __defProps = Object.defineProperties;
|
|
3
|
+
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
|
|
4
|
+
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
|
|
5
|
+
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
6
|
+
var __propIsEnum = Object.prototype.propertyIsEnumerable;
|
|
7
|
+
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
8
|
+
var __spreadValues = (a, b) => {
|
|
9
|
+
for (var prop in b || (b = {}))
|
|
10
|
+
if (__hasOwnProp.call(b, prop))
|
|
11
|
+
__defNormalProp(a, prop, b[prop]);
|
|
12
|
+
if (__getOwnPropSymbols)
|
|
13
|
+
for (var prop of __getOwnPropSymbols(b)) {
|
|
14
|
+
if (__propIsEnum.call(b, prop))
|
|
15
|
+
__defNormalProp(a, prop, b[prop]);
|
|
16
|
+
}
|
|
17
|
+
return a;
|
|
18
|
+
};
|
|
19
|
+
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
|
|
20
|
+
|
|
21
|
+
// src/index.ts
|
|
22
|
+
import {
|
|
23
|
+
deployContract as deployContract2,
|
|
24
|
+
createClarityBin
|
|
25
|
+
} from "@clarigen/native-bin";
|
|
26
|
+
import {
|
|
27
|
+
getContractIdentifier,
|
|
28
|
+
expectOk,
|
|
29
|
+
expectErr
|
|
30
|
+
} from "@clarigen/core";
|
|
31
|
+
|
|
32
|
+
// src/utils/index.ts
|
|
33
|
+
import { publicKeyToStxAddress, StacksNetworkVersion } from "micro-stacks/crypto";
|
|
34
|
+
import { getPublicKeyFromStacksPrivateKey, makeRandomPrivKey } from "micro-stacks/transactions";
|
|
35
|
+
|
|
36
|
+
// src/utils/util-contract.ts
|
|
37
|
+
import { hexToCV } from "micro-stacks/clarity";
|
|
38
|
+
import { join } from "path";
|
|
39
|
+
import { cvToValue } from "@clarigen/core";
|
|
40
|
+
import { deployContract, evalJson, executeJson } from "@clarigen/native-bin";
|
|
41
|
+
import { intToBigInt } from "micro-stacks/common";
|
|
42
|
+
var UTIL_CONTRACT_ID = "ST000000000000000000002AMW42H.clarigen-test-utils";
|
|
43
|
+
async function deployUtilContract(clarityBin) {
|
|
44
|
+
let contractFilePath = join(__dirname, "..", "..", "contracts", "test-utils.clar");
|
|
45
|
+
if (__dirname.includes("dist")) {
|
|
46
|
+
contractFilePath = join(__dirname, "..", "contracts", "test-utils.clar");
|
|
47
|
+
}
|
|
48
|
+
await deployContract({
|
|
49
|
+
contractIdentifier: UTIL_CONTRACT_ID,
|
|
50
|
+
provider: clarityBin,
|
|
51
|
+
contractFilePath
|
|
52
|
+
});
|
|
53
|
+
}
|
|
54
|
+
function getBin(provider) {
|
|
55
|
+
return "clarityBin" in provider ? provider.clarityBin : provider;
|
|
56
|
+
}
|
|
57
|
+
async function getBlockHeight(provider) {
|
|
58
|
+
const bin = getBin(provider);
|
|
59
|
+
const { output_serialized } = await evalJson({
|
|
60
|
+
contractAddress: UTIL_CONTRACT_ID,
|
|
61
|
+
functionName: "get-block-height",
|
|
62
|
+
args: [],
|
|
63
|
+
provider: bin
|
|
64
|
+
});
|
|
65
|
+
const outputCV = hexToCV(output_serialized);
|
|
66
|
+
const blockHeight = cvToValue(outputCV);
|
|
67
|
+
return blockHeight;
|
|
68
|
+
}
|
|
69
|
+
async function mineBlock(provider) {
|
|
70
|
+
const bin = getBin(provider);
|
|
71
|
+
await executeJson({
|
|
72
|
+
contractAddress: UTIL_CONTRACT_ID,
|
|
73
|
+
functionName: "mine-block",
|
|
74
|
+
args: [],
|
|
75
|
+
provider: bin,
|
|
76
|
+
senderAddress: "ST000000000000000000002AMW42H"
|
|
77
|
+
});
|
|
78
|
+
}
|
|
79
|
+
async function mineBlocks(_blocks, provider) {
|
|
80
|
+
const blocks = intToBigInt(_blocks);
|
|
81
|
+
for (let index = 0; index < blocks; index++) {
|
|
82
|
+
await mineBlock(provider);
|
|
83
|
+
}
|
|
84
|
+
}
|
|
85
|
+
async function getStxBalance(provider, account) {
|
|
86
|
+
const bin = getBin(provider);
|
|
87
|
+
const { output_serialized } = await evalJson({
|
|
88
|
+
contractAddress: UTIL_CONTRACT_ID,
|
|
89
|
+
functionName: "get-stx-balance",
|
|
90
|
+
args: [`'${account}`],
|
|
91
|
+
provider: bin
|
|
92
|
+
});
|
|
93
|
+
const outputCV = hexToCV(output_serialized);
|
|
94
|
+
const balance = cvToValue(outputCV);
|
|
95
|
+
return balance;
|
|
96
|
+
}
|
|
97
|
+
|
|
98
|
+
// src/utils/coverage.ts
|
|
99
|
+
import { mkdir, readdir, unlink } from "fs/promises";
|
|
100
|
+
import { join as join2, resolve } from "path";
|
|
101
|
+
async function setupCoverage(dir) {
|
|
102
|
+
const dirName = resolve(process.cwd(), "coverage");
|
|
103
|
+
try {
|
|
104
|
+
await mkdir(dirName);
|
|
105
|
+
} catch (error) {
|
|
106
|
+
}
|
|
107
|
+
const files = await readdir(dirName);
|
|
108
|
+
const removals = files.map((file) => {
|
|
109
|
+
return unlink(join2(dirName, file));
|
|
110
|
+
});
|
|
111
|
+
await Promise.all(removals);
|
|
112
|
+
return dirName;
|
|
113
|
+
}
|
|
114
|
+
async function finishCoverage(provider, dir) {
|
|
115
|
+
const lcovFile = join2(dir, "clarigen.lcov");
|
|
116
|
+
await provider.runCommand(["make_lcov", dir, lcovFile]);
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
// src/utils/index.ts
|
|
120
|
+
function makeRandomAddress(version = StacksNetworkVersion.testnetP2PKH) {
|
|
121
|
+
const privateKey = makeRandomPrivKey();
|
|
122
|
+
const publicKey = getPublicKeyFromStacksPrivateKey(privateKey);
|
|
123
|
+
const address = publicKeyToStxAddress(publicKey.data, version);
|
|
124
|
+
return address;
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
// src/utils/pure.ts
|
|
128
|
+
import {
|
|
129
|
+
cvToString,
|
|
130
|
+
cvToValue as cvToValue2,
|
|
131
|
+
filterEvents,
|
|
132
|
+
CoreNodeEventType
|
|
133
|
+
} from "@clarigen/core";
|
|
134
|
+
import {
|
|
135
|
+
evalRaw,
|
|
136
|
+
evalJson as evalJson2,
|
|
137
|
+
executeJson as executeJson2
|
|
138
|
+
} from "@clarigen/native-bin";
|
|
139
|
+
import {
|
|
140
|
+
hexToCV as hexToCV2,
|
|
141
|
+
responseErrorCV,
|
|
142
|
+
responseOkCV
|
|
143
|
+
} from "micro-stacks/clarity";
|
|
144
|
+
function getPrints(events) {
|
|
145
|
+
return filterEvents(events, CoreNodeEventType.ContractEvent).map((e) => {
|
|
146
|
+
const hex = e.contract_event.raw_value;
|
|
147
|
+
const cv = hexToCV2(hex);
|
|
148
|
+
return cvToValue2(cv);
|
|
149
|
+
});
|
|
150
|
+
}
|
|
151
|
+
function formatArguments(args) {
|
|
152
|
+
return args.map((arg) => cvToString(arg));
|
|
153
|
+
}
|
|
154
|
+
function getIdentifier(tx2) {
|
|
155
|
+
return `${tx2.contractAddress}.${tx2.contractName}`;
|
|
156
|
+
}
|
|
157
|
+
function getLogs(stderr) {
|
|
158
|
+
if (stderr === "")
|
|
159
|
+
return [];
|
|
160
|
+
return stderr.split("\n").map((line) => line.slice(62));
|
|
161
|
+
}
|
|
162
|
+
function makeEvalResult(result) {
|
|
163
|
+
const resultCV = hexToCV2(result.output_serialized);
|
|
164
|
+
const value = cvToValue2(resultCV, true);
|
|
165
|
+
return {
|
|
166
|
+
value,
|
|
167
|
+
clarityValue: resultCV,
|
|
168
|
+
logs: getLogs(result.stderr),
|
|
169
|
+
costs: result.costs
|
|
170
|
+
};
|
|
171
|
+
}
|
|
172
|
+
async function ro({
|
|
173
|
+
tx: tx2,
|
|
174
|
+
bin,
|
|
175
|
+
coverageFolder
|
|
176
|
+
}) {
|
|
177
|
+
const result = await evalJson2({
|
|
178
|
+
functionName: tx2.function.name,
|
|
179
|
+
args: formatArguments(tx2.functionArgs),
|
|
180
|
+
contractAddress: getIdentifier(tx2),
|
|
181
|
+
provider: bin,
|
|
182
|
+
coverageFolder
|
|
183
|
+
});
|
|
184
|
+
return makeEvalResult(result);
|
|
185
|
+
}
|
|
186
|
+
async function evalCode({
|
|
187
|
+
contractAddress,
|
|
188
|
+
code,
|
|
189
|
+
bin,
|
|
190
|
+
coverageFolder
|
|
191
|
+
}) {
|
|
192
|
+
const result = await evalRaw({
|
|
193
|
+
contractAddress,
|
|
194
|
+
code,
|
|
195
|
+
provider: bin,
|
|
196
|
+
coverageFolder
|
|
197
|
+
});
|
|
198
|
+
return makeEvalResult(result);
|
|
199
|
+
}
|
|
200
|
+
async function tx({
|
|
201
|
+
tx: tx2,
|
|
202
|
+
senderAddress,
|
|
203
|
+
bin,
|
|
204
|
+
coverageFolder
|
|
205
|
+
}) {
|
|
206
|
+
const result = await executeJson2({
|
|
207
|
+
contractAddress: getIdentifier(tx2),
|
|
208
|
+
senderAddress,
|
|
209
|
+
provider: bin,
|
|
210
|
+
functionName: tx2.function.name,
|
|
211
|
+
args: formatArguments(tx2.functionArgs),
|
|
212
|
+
coverageFolder
|
|
213
|
+
});
|
|
214
|
+
const resultCV = hexToCV2(result.output_serialized);
|
|
215
|
+
const value = cvToValue2(resultCV);
|
|
216
|
+
const baseReturn = {
|
|
217
|
+
value,
|
|
218
|
+
logs: getLogs(result.stderr),
|
|
219
|
+
costs: result.costs
|
|
220
|
+
};
|
|
221
|
+
if (result.success) {
|
|
222
|
+
return __spreadProps(__spreadValues({}, baseReturn), {
|
|
223
|
+
isOk: true,
|
|
224
|
+
response: responseOkCV(resultCV),
|
|
225
|
+
assets: result.assets,
|
|
226
|
+
events: result.events,
|
|
227
|
+
prints: getPrints(result.events)
|
|
228
|
+
});
|
|
229
|
+
}
|
|
230
|
+
return __spreadProps(__spreadValues({}, baseReturn), {
|
|
231
|
+
isOk: false,
|
|
232
|
+
response: responseErrorCV(resultCV)
|
|
233
|
+
});
|
|
234
|
+
}
|
|
235
|
+
async function mapGet({
|
|
236
|
+
map,
|
|
237
|
+
bin
|
|
238
|
+
}) {
|
|
239
|
+
const code = `(map-get? ${map.map.name} ${cvToString(map.key)})`;
|
|
240
|
+
const result = await evalCode({
|
|
241
|
+
contractAddress: getIdentifier(map),
|
|
242
|
+
code,
|
|
243
|
+
bin
|
|
244
|
+
});
|
|
245
|
+
return result.value;
|
|
246
|
+
}
|
|
247
|
+
|
|
248
|
+
// src/index.ts
|
|
249
|
+
import { resolve as resolve2 } from "path";
|
|
250
|
+
import { Allocation, createClarityBin as createClarityBin2, executeJson as executeJson3, evalJson as evalJson3 } from "@clarigen/native-bin";
|
|
251
|
+
var TestProvider = class {
|
|
252
|
+
constructor(clarityBin) {
|
|
253
|
+
this.clarityBin = clarityBin;
|
|
254
|
+
}
|
|
255
|
+
static async fromContracts(contracts, options = {}) {
|
|
256
|
+
const clarityBin = options.clarityBin || await createClarityBin({
|
|
257
|
+
allocations: options.accounts
|
|
258
|
+
});
|
|
259
|
+
const instances = {};
|
|
260
|
+
let coverageFolder = options.coverageFolder;
|
|
261
|
+
if (process.env.CLARIGEN_COVERAGE) {
|
|
262
|
+
coverageFolder = resolve2(process.cwd(), "coverage");
|
|
263
|
+
}
|
|
264
|
+
await deployUtilContract(clarityBin);
|
|
265
|
+
for (const k in contracts) {
|
|
266
|
+
if (Object.prototype.hasOwnProperty.call(contracts, k)) {
|
|
267
|
+
const contract = contracts[k];
|
|
268
|
+
const identifier = getContractIdentifier(contract);
|
|
269
|
+
await deployContract2({
|
|
270
|
+
contractIdentifier: identifier,
|
|
271
|
+
contractFilePath: contract.contractFile,
|
|
272
|
+
provider: clarityBin,
|
|
273
|
+
coverageFolder
|
|
274
|
+
});
|
|
275
|
+
const instance = contract.contract(contract.address, contract.name);
|
|
276
|
+
instances[k] = {
|
|
277
|
+
identifier: getContractIdentifier(contract),
|
|
278
|
+
contract: instance
|
|
279
|
+
};
|
|
280
|
+
}
|
|
281
|
+
}
|
|
282
|
+
const provider = new this(clarityBin);
|
|
283
|
+
provider.coverageFolder = coverageFolder;
|
|
284
|
+
return {
|
|
285
|
+
deployed: instances,
|
|
286
|
+
provider
|
|
287
|
+
};
|
|
288
|
+
}
|
|
289
|
+
ro(tx2) {
|
|
290
|
+
return ro({ tx: tx2, bin: this.clarityBin, coverageFolder: this.coverageFolder });
|
|
291
|
+
}
|
|
292
|
+
async rov(tx2) {
|
|
293
|
+
const result = await this.ro(tx2);
|
|
294
|
+
return result.value;
|
|
295
|
+
}
|
|
296
|
+
async roOk(tx2) {
|
|
297
|
+
const result = await this.ro(tx2);
|
|
298
|
+
const value = expectOk(result.value);
|
|
299
|
+
return __spreadProps(__spreadValues({}, result), {
|
|
300
|
+
value
|
|
301
|
+
});
|
|
302
|
+
}
|
|
303
|
+
async roErr(tx2) {
|
|
304
|
+
const result = await this.ro(tx2);
|
|
305
|
+
const value = expectErr(result.value);
|
|
306
|
+
return __spreadProps(__spreadValues({}, result), {
|
|
307
|
+
value
|
|
308
|
+
});
|
|
309
|
+
}
|
|
310
|
+
async rovOk(tx2) {
|
|
311
|
+
return (await this.roOk(tx2)).value;
|
|
312
|
+
}
|
|
313
|
+
async rovErr(tx2) {
|
|
314
|
+
return (await this.roErr(tx2)).value;
|
|
315
|
+
}
|
|
316
|
+
tx(tx2, senderAddress) {
|
|
317
|
+
return tx({
|
|
318
|
+
tx: tx2,
|
|
319
|
+
senderAddress,
|
|
320
|
+
bin: this.clarityBin,
|
|
321
|
+
coverageFolder: this.coverageFolder
|
|
322
|
+
});
|
|
323
|
+
}
|
|
324
|
+
async txOk(tx2, senderAddress) {
|
|
325
|
+
const result = await this.tx(tx2, senderAddress);
|
|
326
|
+
if (!result.isOk)
|
|
327
|
+
throw new Error(`Expected OK, received error: ${result.value}`);
|
|
328
|
+
return result;
|
|
329
|
+
}
|
|
330
|
+
async txErr(tx2, senderAddress) {
|
|
331
|
+
const result = await this.tx(tx2, senderAddress);
|
|
332
|
+
if (result.isOk)
|
|
333
|
+
throw new Error(`Expected Err, received ok: ${result.value}`);
|
|
334
|
+
return result;
|
|
335
|
+
}
|
|
336
|
+
evalCode(code, contractAddress = UTIL_CONTRACT_ID) {
|
|
337
|
+
return evalCode({
|
|
338
|
+
contractAddress,
|
|
339
|
+
code,
|
|
340
|
+
bin: this.clarityBin,
|
|
341
|
+
coverageFolder: this.coverageFolder
|
|
342
|
+
});
|
|
343
|
+
}
|
|
344
|
+
async eval(code, contractAddress = UTIL_CONTRACT_ID) {
|
|
345
|
+
const result = await this.evalCode(code, contractAddress);
|
|
346
|
+
return result.value;
|
|
347
|
+
}
|
|
348
|
+
mapGet(map) {
|
|
349
|
+
return mapGet({ map, bin: this.clarityBin });
|
|
350
|
+
}
|
|
351
|
+
};
|
|
352
|
+
export {
|
|
353
|
+
Allocation,
|
|
354
|
+
TestProvider,
|
|
355
|
+
createClarityBin2 as createClarityBin,
|
|
356
|
+
evalJson3 as evalJson,
|
|
357
|
+
executeJson3 as executeJson,
|
|
358
|
+
finishCoverage,
|
|
359
|
+
getBlockHeight,
|
|
360
|
+
getStxBalance,
|
|
361
|
+
makeRandomAddress,
|
|
362
|
+
mineBlocks,
|
|
363
|
+
setupCoverage
|
|
364
|
+
};
|
package/package.json
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
{
|
|
2
|
-
"version": "1.0.0-next.
|
|
2
|
+
"version": "1.0.0-next.19",
|
|
3
3
|
"license": "MIT",
|
|
4
4
|
"types": "./dist/index.d.ts",
|
|
5
5
|
"main": "./dist/index.js",
|
|
@@ -27,12 +27,12 @@
|
|
|
27
27
|
"name": "@clarigen/test",
|
|
28
28
|
"author": "Hank Stoever",
|
|
29
29
|
"dependencies": {
|
|
30
|
-
"@clarigen/core": "1.0.0-next.
|
|
31
|
-
"@clarigen/native-bin": "1.0.0-next.
|
|
30
|
+
"@clarigen/core": "1.0.0-next.19",
|
|
31
|
+
"@clarigen/native-bin": "1.0.0-next.19",
|
|
32
32
|
"micro-stacks": "^0.2.0"
|
|
33
33
|
},
|
|
34
34
|
"publishConfig": {
|
|
35
35
|
"access": "public"
|
|
36
36
|
},
|
|
37
|
-
"gitHead": "
|
|
37
|
+
"gitHead": "d6b6fc199e367698d566f38ee3343b04a418c829"
|
|
38
38
|
}
|