@helios-lang/contract-utils 0.2.62 → 0.2.64
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/package.json +6 -3
- package/src/cast/Cast.js +122 -20
- package/src/cast/UserFunc.js +15 -7
- package/src/codegen/TypeSchema.js +1 -0
- package/src/compiler/CompilerLib_v0_16.js +6 -1
- package/types/cast/Cast.d.ts +8 -1
- package/types/cast/Cast.d.ts.map +1 -1
- package/types/cast/UserFunc.d.ts +8 -3
- package/types/cast/UserFunc.d.ts.map +1 -1
- package/types/codegen/TypeSchema.d.ts.map +1 -1
- package/types/compiler/CompilerLib_v0_16.d.ts.map +1 -1
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@helios-lang/contract-utils",
|
|
3
|
-
"version": "0.2.
|
|
3
|
+
"version": "0.2.64",
|
|
4
4
|
"description": "Convenience and type-safety utilities for using Helios validators from within Typescript",
|
|
5
5
|
"main": "src/index.js",
|
|
6
6
|
"types": "types/index.d.ts",
|
|
@@ -28,17 +28,20 @@
|
|
|
28
28
|
"@helios-lang/cli-utils": "^0.1.6",
|
|
29
29
|
"@helios-lang/codec-utils": "^0.1.35",
|
|
30
30
|
"@helios-lang/compiler-utils": "^0.1.25",
|
|
31
|
-
"@helios-lang/ledger": "^0.
|
|
31
|
+
"@helios-lang/ledger": "^0.5.1",
|
|
32
32
|
"@helios-lang/type-utils": "^0.1.21",
|
|
33
|
-
"@helios-lang/uplc": "^0.3.
|
|
33
|
+
"@helios-lang/uplc": "^0.3.8"
|
|
34
34
|
},
|
|
35
35
|
"scripts": {
|
|
36
36
|
"build": "pnpm run prettify && pnpm run build:types && pnpm run test:suite",
|
|
37
37
|
"build:types": "tsc -p jsconfig.json --noEmit false --emitDeclarationOnly",
|
|
38
|
+
"lockfile:sync": "pnpm install --ignore-workspace",
|
|
38
39
|
"prettify": "prettier . --write",
|
|
39
40
|
"test": "pnpm run test:pretty && pnpm run test:types && pnpm run test:suite",
|
|
40
41
|
"test:pretty": "prettier . --check",
|
|
41
42
|
"test:suite": "node --test",
|
|
43
|
+
"testing": "node --test --watch",
|
|
44
|
+
"testing:debug": "node --inspect-brk --test --watch",
|
|
42
45
|
"test:types": "pnpm run build:types"
|
|
43
46
|
}
|
|
44
47
|
}
|
package/src/cast/Cast.js
CHANGED
|
@@ -94,11 +94,20 @@ export class Cast {
|
|
|
94
94
|
}
|
|
95
95
|
|
|
96
96
|
/**
|
|
97
|
+
* converts javascript object to UPLC data, according to the schema.
|
|
98
|
+
* @remarks
|
|
99
|
+
* The optional `dataPath` parameter can provide a contextual cue for the
|
|
100
|
+
* data-conversion process, and will be displayed as part of any error messages
|
|
101
|
+
* thrown during the data transformation
|
|
102
|
+
*
|
|
97
103
|
* @param {TPermissive} x
|
|
104
|
+
* @param {string} dataPath
|
|
98
105
|
* @returns {UplcData}
|
|
99
106
|
*/
|
|
100
|
-
toUplcData(x) {
|
|
101
|
-
|
|
107
|
+
toUplcData(x, dataPath = "") {
|
|
108
|
+
const t = schemaToUplcWithDataPath(this.schema, x, {}, dataPath)
|
|
109
|
+
t.rawData = x
|
|
110
|
+
return t
|
|
102
111
|
}
|
|
103
112
|
}
|
|
104
113
|
|
|
@@ -106,15 +115,42 @@ export class Cast {
|
|
|
106
115
|
* @param {TypeSchema} schema
|
|
107
116
|
* @param {any} x
|
|
108
117
|
* @param {Record<string, TypeSchema>} defs
|
|
118
|
+
* @param {string} dataPath
|
|
109
119
|
* @returns {UplcData}
|
|
110
120
|
*/
|
|
111
|
-
function
|
|
112
|
-
|
|
121
|
+
function schemaToUplcWithDataPath(schema, x, defs = {}, dataPath = "") {
|
|
122
|
+
try {
|
|
123
|
+
const t = schemaToUplc(schema, x, defs, dataPath)
|
|
124
|
+
t.dataPath = dataPath
|
|
125
|
+
return t
|
|
126
|
+
} catch (e) {
|
|
127
|
+
if (!e.uplcDataPath) {
|
|
128
|
+
e.message = `${e.message}\n ... at ${dataPath}`
|
|
129
|
+
e.uplcDataPath = dataPath
|
|
130
|
+
}
|
|
131
|
+
debugger
|
|
132
|
+
throw e
|
|
133
|
+
}
|
|
134
|
+
}
|
|
113
135
|
|
|
136
|
+
/**
|
|
137
|
+
* @param {TypeSchema} schema
|
|
138
|
+
* @param {any} x
|
|
139
|
+
* @param {Record<string, TypeSchema>} defs
|
|
140
|
+
* @param {string} dataPath
|
|
141
|
+
* @returns {UplcData}
|
|
142
|
+
*/
|
|
143
|
+
function schemaToUplc(schema, x, defs = {}, dataPath = "") {
|
|
144
|
+
const kind = schema.kind
|
|
114
145
|
switch (kind) {
|
|
115
146
|
case "reference": {
|
|
116
147
|
const def = expectSome(defs[schema.id])
|
|
117
|
-
return
|
|
148
|
+
return schemaToUplcWithDataPath(
|
|
149
|
+
def,
|
|
150
|
+
x,
|
|
151
|
+
defs,
|
|
152
|
+
`${dataPath}::ref{${schema.id}}`
|
|
153
|
+
)
|
|
118
154
|
}
|
|
119
155
|
case "internal": {
|
|
120
156
|
const name = schema.name
|
|
@@ -184,43 +220,88 @@ function schemaToUplc(schema, x, defs = {}) {
|
|
|
184
220
|
case "Value":
|
|
185
221
|
return Value.new(x).toUplcData()
|
|
186
222
|
default:
|
|
187
|
-
throw new Error(
|
|
223
|
+
throw new Error(
|
|
224
|
+
`schemaToUplc not yet implemented for ${name}`
|
|
225
|
+
)
|
|
188
226
|
}
|
|
189
227
|
}
|
|
190
228
|
case "list":
|
|
191
229
|
return new ListData(
|
|
192
|
-
x.map((x) =>
|
|
230
|
+
x.map((x, i) =>
|
|
231
|
+
schemaToUplcWithDataPath(
|
|
232
|
+
schema.itemType,
|
|
233
|
+
x,
|
|
234
|
+
defs,
|
|
235
|
+
`${dataPath}.list[${i}]`
|
|
236
|
+
)
|
|
237
|
+
)
|
|
193
238
|
)
|
|
194
239
|
case "map": {
|
|
195
|
-
const entries =
|
|
240
|
+
const entries =
|
|
241
|
+
x instanceof Map
|
|
242
|
+
? [...x.entries()]
|
|
243
|
+
: Array.isArray(x)
|
|
244
|
+
? x
|
|
245
|
+
: Object.entries(x)
|
|
196
246
|
return new MapData(
|
|
197
247
|
entries.map(([k, v]) => [
|
|
198
|
-
|
|
199
|
-
|
|
248
|
+
schemaToUplcWithDataPath(
|
|
249
|
+
schema.keyType,
|
|
250
|
+
k,
|
|
251
|
+
defs,
|
|
252
|
+
`${dataPath}[mapKey '${k}']`
|
|
253
|
+
),
|
|
254
|
+
schemaToUplcWithDataPath(
|
|
255
|
+
schema.valueType,
|
|
256
|
+
v,
|
|
257
|
+
defs,
|
|
258
|
+
`${dataPath}[map].${k}`
|
|
259
|
+
)
|
|
200
260
|
])
|
|
201
261
|
)
|
|
202
262
|
}
|
|
203
263
|
case "tuple":
|
|
204
264
|
return new ListData(
|
|
205
|
-
x.map((x, i) =>
|
|
265
|
+
x.map((x, i) =>
|
|
266
|
+
schemaToUplcWithDataPath(
|
|
267
|
+
schema.itemTypes[i],
|
|
268
|
+
x,
|
|
269
|
+
defs,
|
|
270
|
+
`${dataPath}[tuple@${i}]`
|
|
271
|
+
)
|
|
272
|
+
)
|
|
206
273
|
)
|
|
207
274
|
case "option":
|
|
208
275
|
return encodeOptionData(
|
|
209
|
-
x
|
|
276
|
+
x
|
|
277
|
+
? schemaToUplcWithDataPath(
|
|
278
|
+
schema.someType,
|
|
279
|
+
x,
|
|
280
|
+
defs,
|
|
281
|
+
`${dataPath}::Some`
|
|
282
|
+
)
|
|
283
|
+
: None
|
|
210
284
|
)
|
|
211
285
|
case "struct": {
|
|
212
286
|
defs[schema.id] = schema
|
|
213
287
|
switch (schema.format) {
|
|
214
288
|
case "singleton":
|
|
215
|
-
|
|
289
|
+
const singleFieldName = schema.fieldTypes[0].name
|
|
290
|
+
return schemaToUplcWithDataPath(
|
|
216
291
|
schema.fieldTypes[0].type,
|
|
217
|
-
x[
|
|
218
|
-
defs
|
|
292
|
+
x[singleFieldName],
|
|
293
|
+
defs,
|
|
294
|
+
`${dataPath}[sStruct.${singleFieldName}]`
|
|
219
295
|
)
|
|
220
296
|
case "list":
|
|
221
297
|
return new ListData(
|
|
222
298
|
schema.fieldTypes.map(({ name, type }) =>
|
|
223
|
-
|
|
299
|
+
schemaToUplcWithDataPath(
|
|
300
|
+
type,
|
|
301
|
+
x[name],
|
|
302
|
+
{},
|
|
303
|
+
`${dataPath}[fStruct].${name}`
|
|
304
|
+
)
|
|
224
305
|
)
|
|
225
306
|
)
|
|
226
307
|
case "map": {
|
|
@@ -243,8 +324,18 @@ function schemaToUplc(schema, x, defs = {}) {
|
|
|
243
324
|
)
|
|
244
325
|
|
|
245
326
|
if (ft) {
|
|
246
|
-
|
|
247
|
-
const
|
|
327
|
+
debugger
|
|
328
|
+
// const rawKey = ft.key || ft.name
|
|
329
|
+
const rawKey = ft.name
|
|
330
|
+
const keyData = new ByteArrayData(
|
|
331
|
+
encodeUtf8(rawKey)
|
|
332
|
+
)
|
|
333
|
+
const valueData = schemaToUplcWithDataPath(
|
|
334
|
+
ft.type,
|
|
335
|
+
value,
|
|
336
|
+
defs,
|
|
337
|
+
`${dataPath}[mStruct][${key}]`
|
|
338
|
+
)
|
|
248
339
|
|
|
249
340
|
pairs.push([keyData, valueData])
|
|
250
341
|
}
|
|
@@ -276,16 +367,27 @@ function schemaToUplc(schema, x, defs = {}) {
|
|
|
276
367
|
return new ConstrData(
|
|
277
368
|
tag,
|
|
278
369
|
schema.variantTypes[tag].fieldTypes.map((f) =>
|
|
279
|
-
|
|
370
|
+
schemaToUplcWithDataPath(
|
|
371
|
+
f.type,
|
|
372
|
+
variantFields[f.name],
|
|
373
|
+
defs,
|
|
374
|
+
`${dataPath}[${schema.name}::${variantName}].${f.name}`
|
|
375
|
+
)
|
|
280
376
|
)
|
|
281
377
|
)
|
|
282
378
|
}
|
|
283
379
|
case "variant":
|
|
284
380
|
defs[schema.id] = schema
|
|
381
|
+
|
|
285
382
|
return new ConstrData(
|
|
286
383
|
schema.tag,
|
|
287
384
|
schema.fieldTypes.map(({ name, type }) =>
|
|
288
|
-
|
|
385
|
+
schemaToUplcWithDataPath(
|
|
386
|
+
type,
|
|
387
|
+
x[name],
|
|
388
|
+
{},
|
|
389
|
+
`${dataPath}.${name}`
|
|
390
|
+
)
|
|
289
391
|
)
|
|
290
392
|
)
|
|
291
393
|
default:
|
package/src/cast/UserFunc.js
CHANGED
|
@@ -2,11 +2,13 @@ import { bytesToHex } from "@helios-lang/codec-utils"
|
|
|
2
2
|
import { expectSome, isLeft, isString } from "@helios-lang/type-utils"
|
|
3
3
|
import { ConstrData, IntData, UplcDataValue } from "@helios-lang/uplc"
|
|
4
4
|
import { Cast } from "./Cast.js"
|
|
5
|
+
import { BasicUplcLogger } from "@helios-lang/uplc"
|
|
5
6
|
|
|
6
7
|
/**
|
|
7
8
|
* @typedef {import("@helios-lang/type-utils").TypeSchema} TypeSchema
|
|
8
9
|
* @typedef {import("@helios-lang/uplc").CekResult} CekResult
|
|
9
10
|
* @typedef {import("@helios-lang/uplc").UplcData} UplcData
|
|
11
|
+
* @typedef {import("@helios-lang/uplc").UplcLoggingI} UplcLoggingI
|
|
10
12
|
* @typedef {import("@helios-lang/uplc").UplcProgram} UplcProgram
|
|
11
13
|
* @typedef {import("@helios-lang/uplc").UplcValue} UplcValue
|
|
12
14
|
* @typedef {import("./Cast.js").CastConfig} CastConfig
|
|
@@ -70,9 +72,10 @@ export class UserFunc {
|
|
|
70
72
|
|
|
71
73
|
/**
|
|
72
74
|
* @param {ArgsT} namedArgs
|
|
75
|
+
* @param {UplcLoggingI} [logOptions]
|
|
73
76
|
* @returns {RetT}
|
|
74
77
|
*/
|
|
75
|
-
eval(namedArgs) {
|
|
78
|
+
eval(namedArgs, logOptions) {
|
|
76
79
|
/**
|
|
77
80
|
* @type {{[argName: string]: any}}
|
|
78
81
|
*/
|
|
@@ -100,7 +103,8 @@ export class UserFunc {
|
|
|
100
103
|
})
|
|
101
104
|
|
|
102
105
|
const result = this.evalUnsafe(
|
|
103
|
-
/** @type {UnsafeArgsT<ArgsT>} */ (unsafeNamedArgs)
|
|
106
|
+
/** @type {UnsafeArgsT<ArgsT>} */ (unsafeNamedArgs),
|
|
107
|
+
logOptions
|
|
104
108
|
)
|
|
105
109
|
|
|
106
110
|
if (this.props.returns) {
|
|
@@ -115,10 +119,11 @@ export class UserFunc {
|
|
|
115
119
|
|
|
116
120
|
/**
|
|
117
121
|
* @param {UnsafeArgsT<ArgsT>} namedArgs
|
|
122
|
+
* @param {UplcLoggingI} [logOptions]
|
|
118
123
|
* @returns {RetT extends void ? void : UplcData}
|
|
119
124
|
*/
|
|
120
|
-
evalUnsafe(namedArgs) {
|
|
121
|
-
const result = this.profile(namedArgs).result
|
|
125
|
+
evalUnsafe(namedArgs, logOptions) {
|
|
126
|
+
const result = this.profile(namedArgs, logOptions).result
|
|
122
127
|
|
|
123
128
|
if (isLeft(result)) {
|
|
124
129
|
throw new Error(result.left.error)
|
|
@@ -133,9 +138,10 @@ export class UserFunc {
|
|
|
133
138
|
|
|
134
139
|
/**
|
|
135
140
|
* @param {UnsafeArgsT<ArgsT>} namedArgs
|
|
141
|
+
* @param {UplcLoggingI} [logOptions] - optional, passed to UplcProgram.eval if provided
|
|
136
142
|
* @returns {CekResult}
|
|
137
143
|
*/
|
|
138
|
-
profile(namedArgs) {
|
|
144
|
+
profile(namedArgs, logOptions) {
|
|
139
145
|
const isMain = this.name == "main"
|
|
140
146
|
|
|
141
147
|
/**
|
|
@@ -184,10 +190,12 @@ export class UserFunc {
|
|
|
184
190
|
|
|
185
191
|
const argValues = args.map((a) => new UplcDataValue(a))
|
|
186
192
|
|
|
187
|
-
const cekResult = this.uplc.eval(argValues)
|
|
193
|
+
const cekResult = this.uplc.eval(argValues, { logOptions })
|
|
188
194
|
|
|
189
195
|
if (this.uplc.alt?.plutusVersion == "PlutusScriptV2") {
|
|
190
|
-
const cekResultUnoptim = this.uplc.alt.eval(argValues
|
|
196
|
+
const cekResultUnoptim = this.uplc.alt.eval(argValues, {
|
|
197
|
+
logOptions
|
|
198
|
+
})
|
|
191
199
|
const resultUnoptim = cekResultUnoptim.result
|
|
192
200
|
const resultUnoptimStr = evalResultToString(resultUnoptim)
|
|
193
201
|
const resultStr = evalResultToString(cekResult.result)
|
|
@@ -390,7 +390,12 @@ export class CompilerLib_v0_16 {
|
|
|
390
390
|
// inject hashes of other validators
|
|
391
391
|
Object.entries(options.hashDependencies ?? {}).forEach(
|
|
392
392
|
([depName, dep]) => {
|
|
393
|
-
|
|
393
|
+
const key = `__helios__scripts__${depName}`
|
|
394
|
+
|
|
395
|
+
// don't overwrite if set above!
|
|
396
|
+
if (!extra.has(key)) {
|
|
397
|
+
extra.set(key, new IR(`#${dep}`))
|
|
398
|
+
}
|
|
394
399
|
}
|
|
395
400
|
)
|
|
396
401
|
|
package/types/cast/Cast.d.ts
CHANGED
|
@@ -52,10 +52,17 @@ export class Cast<TStrict, TPermissive> {
|
|
|
52
52
|
*/
|
|
53
53
|
fromUplcData(data: UplcData): TStrict;
|
|
54
54
|
/**
|
|
55
|
+
* converts javascript object to UPLC data, according to the schema.
|
|
56
|
+
* @remarks
|
|
57
|
+
* The optional `dataPath` parameter can provide a contextual cue for the
|
|
58
|
+
* data-conversion process, and will be displayed as part of any error messages
|
|
59
|
+
* thrown during the data transformation
|
|
60
|
+
*
|
|
55
61
|
* @param {TPermissive} x
|
|
62
|
+
* @param {string} dataPath
|
|
56
63
|
* @returns {UplcData}
|
|
57
64
|
*/
|
|
58
|
-
toUplcData(x: TPermissive): UplcData;
|
|
65
|
+
toUplcData(x: TPermissive, dataPath?: string): UplcData;
|
|
59
66
|
}
|
|
60
67
|
export type UplcData = import("@helios-lang/uplc").UplcData;
|
|
61
68
|
export type TypeSchema = import("../codegen/index.js").TypeSchema;
|
package/types/cast/Cast.d.ts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"Cast.d.ts","sourceRoot":"","sources":["../../src/cast/Cast.js"],"names":[],"mappings":"
|
|
1
|
+
{"version":3,"file":"Cast.d.ts","sourceRoot":"","sources":["../../src/cast/Cast.js"],"names":[],"mappings":"AAynBA;;;;;;GAMG;AACH,8BANa,OAAO,EACP,WAAW,QACb,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,UAC9B,UAAU,GACR,IAAI,CAAC,OAAO,EAAE,WAAW,CAAC,CAQtC;AAjmBD;;;GAGG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;;GAKG;AAEH;;;GAGG;AACH,kBAHa,OAAO,EACP,WAAW;IAepB;;;OAGG;IACH,oBAHW,UAAU,UACV,UAAU,EAKpB;IAnBD;;;OAGG;IACH,iBAFU,UAAU,CAEd;IAEN;;;OAGG;IACH,iBAFU,UAAU,CAEd;IAWN;;;OAGG;IACH,mBAHW,QAAQ,GACN,OAAO,CAInB;IAED;;;;;;;;;;OAUG;IACH,cAJW,WAAW,aACX,MAAM,GACJ,QAAQ,CAMpB;CACJ;uBAzEY,OAAO,mBAAmB,EAAE,QAAQ;yBACpC,OAAO,qBAAqB,EAAE,UAAU;yBAIxC;IACZ,SAAa,EAAE,OAAO,CAAA;CACnB;6BAIS,OAAO,EACP,WAAW,IACX,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,CAAC,OAAO,EAAE,WAAW,CAAC;;;;qBAKlD,OAAO,EACP,WAAW,IACX,IAAI,CAAC,OAAO,EAAE,WAAW,CAAC,GAAG,gBAAgB,CAAC,OAAO,EAAE,WAAW,CAAC"}
|
package/types/cast/UserFunc.d.ts
CHANGED
|
@@ -2,6 +2,7 @@
|
|
|
2
2
|
* @typedef {import("@helios-lang/type-utils").TypeSchema} TypeSchema
|
|
3
3
|
* @typedef {import("@helios-lang/uplc").CekResult} CekResult
|
|
4
4
|
* @typedef {import("@helios-lang/uplc").UplcData} UplcData
|
|
5
|
+
* @typedef {import("@helios-lang/uplc").UplcLoggingI} UplcLoggingI
|
|
5
6
|
* @typedef {import("@helios-lang/uplc").UplcProgram} UplcProgram
|
|
6
7
|
* @typedef {import("@helios-lang/uplc").UplcValue} UplcValue
|
|
7
8
|
* @typedef {import("./Cast.js").CastConfig} CastConfig
|
|
@@ -55,23 +56,27 @@ export class UserFunc<ArgsT extends {
|
|
|
55
56
|
get name(): string;
|
|
56
57
|
/**
|
|
57
58
|
* @param {ArgsT} namedArgs
|
|
59
|
+
* @param {UplcLoggingI} [logOptions]
|
|
58
60
|
* @returns {RetT}
|
|
59
61
|
*/
|
|
60
|
-
eval(namedArgs: ArgsT): RetT;
|
|
62
|
+
eval(namedArgs: ArgsT, logOptions?: import("@helios-lang/uplc/types/logging/UplcLoggingI.js").UplcLoggingI | undefined): RetT;
|
|
61
63
|
/**
|
|
62
64
|
* @param {UnsafeArgsT<ArgsT>} namedArgs
|
|
65
|
+
* @param {UplcLoggingI} [logOptions]
|
|
63
66
|
* @returns {RetT extends void ? void : UplcData}
|
|
64
67
|
*/
|
|
65
|
-
evalUnsafe(namedArgs: UnsafeArgsT<ArgsT
|
|
68
|
+
evalUnsafe(namedArgs: UnsafeArgsT<ArgsT>, logOptions?: import("@helios-lang/uplc/types/logging/UplcLoggingI.js").UplcLoggingI | undefined): RetT extends void ? void : UplcData;
|
|
66
69
|
/**
|
|
67
70
|
* @param {UnsafeArgsT<ArgsT>} namedArgs
|
|
71
|
+
* @param {UplcLoggingI} [logOptions] - optional, passed to UplcProgram.eval if provided
|
|
68
72
|
* @returns {CekResult}
|
|
69
73
|
*/
|
|
70
|
-
profile(namedArgs: UnsafeArgsT<ArgsT
|
|
74
|
+
profile(namedArgs: UnsafeArgsT<ArgsT>, logOptions?: import("@helios-lang/uplc/types/logging/UplcLoggingI.js").UplcLoggingI | undefined): CekResult;
|
|
71
75
|
}
|
|
72
76
|
export type TypeSchema = import("@helios-lang/type-utils").TypeSchema;
|
|
73
77
|
export type CekResult = import("@helios-lang/uplc").CekResult;
|
|
74
78
|
export type UplcData = import("@helios-lang/uplc").UplcData;
|
|
79
|
+
export type UplcLoggingI = import("@helios-lang/uplc").UplcLoggingI;
|
|
75
80
|
export type UplcProgram = import("@helios-lang/uplc").UplcProgram;
|
|
76
81
|
export type UplcValue = import("@helios-lang/uplc").UplcValue;
|
|
77
82
|
export type CastConfig = import("./Cast.js").CastConfig;
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"UserFunc.d.ts","sourceRoot":"","sources":["../../src/cast/UserFunc.js"],"names":[],"mappings":"
|
|
1
|
+
{"version":3,"file":"UserFunc.d.ts","sourceRoot":"","sources":["../../src/cast/UserFunc.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;GAeG;AAEH;;;GAGG;AAEH;;;GAGG;AACH,sBAHwC,KAAK,SAAhC;IAAE,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAC1B,IAAI;IAgBb;;;OAGG;IACH,kBAHW,WAAW,SACX,aAAa,EAKvB;IApBD;;;OAGG;IACH,eAFU,WAAW,CAEjB;IAEJ;;;;OAIG;IACH,uBAAK;IAWL;;OAEG;IACH,mBAEC;IAED;;;;OAIG;IACH,gBAJW,KAAK,oGAEH,IAAI,CA0ChB;IAED;;;;OAIG;IACH,sBAJW,WAAW,CAAC,KAAK,CAAC,oGAEhB,IAAI,SAAS,IAAI,GAAG,IAAI,GAAG,QAAQ,CAc/C;IAED;;;;OAIG;IACH,mBAJW,WAAW,CAAC,KAAK,CAAC,oGAEhB,SAAS,CAmGrB;CACJ;yBA1OY,OAAO,yBAAyB,EAAE,UAAU;wBAC5C,OAAO,mBAAmB,EAAE,SAAS;uBACrC,OAAO,mBAAmB,EAAE,QAAQ;2BACpC,OAAO,mBAAmB,EAAE,YAAY;0BACxC,OAAO,mBAAmB,EAAE,WAAW;wBACvC,OAAO,mBAAmB,EAAE,SAAS;yBACrC,OAAO,WAAW,EAAE,UAAU;;;;4BAK9B;IACZ,IAAQ,EAAE,MAAM,CAAA;IAChB,qBAAyB,EAAE,OAAO,CAAA;IAClC,qBAAyB,EAAE,OAAO,CAAA;IAClC,SAAa,EAAE;QACf,IAAU,EAAE,MAAM,CAAA;QAClB,IAAU,EAAE,UAAU,CAAA;QACtB,UAAgB,EAAE,OAAO,CAAA;KACpB,EAAE,CAAA;IACP,OAAW,CAAC,EAAE,UAAU,CAAA;IACxB,gBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC7C,UAAc,EAAE,UAAU,CAAA;CACvB;wBAIS,KAAK,IACL,GAAE,CAAgB,IAAX,MAAM,KAAK,GAAG,CAAC,SAAS,gBAAgB,GAAG,MAAM,GAAG,QAAQ,GAAC"}
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"TypeSchema.d.ts","sourceRoot":"","sources":["../../src/codegen/TypeSchema.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,iCAHW,UAAU,GACR,CAAC,MAAM,EAAE,MAAM,CAAC,
|
|
1
|
+
{"version":3,"file":"TypeSchema.d.ts","sourceRoot":"","sources":["../../src/codegen/TypeSchema.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,iCAHW,UAAU,GACR,CAAC,MAAM,EAAE,MAAM,CAAC,CAiK5B;yBAzKY,OAAO,yBAAyB,EAAE,UAAU"}
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"CompilerLib_v0_16.d.ts","sourceRoot":"","sources":["../../src/compiler/CompilerLib_v0_16.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;GAYG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;;;;GAKG;AAEH;;;;;;GAMG;AACH;;;;;;;;;;;;GAYG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;;GAGG;AAEH;;GAEG;AACH,0CAFgB,WAAW;IAGvB;;OAEG;IACH,iBAFW,GAAG,EAMb;IAHG,SAAc;IAKlB;;OAEG;IACH,qBAQC;IAED;;OAEG;IACH,sBAEC;IAED;;;OAGG;IACH,2BAHW,MAAM,GACJ,cAAc,CAe1B;IAED;;;;;OAKG;IACH,cALW,MAAM,WACN,MAAM,EAAE,WACR,cAAc,GACZ,aAAa,CA6CzB;IAED;;;;OAIG;IACH,sBAJW,MAAM,EAAE,WACR,MAAM,EAAE,GACN,eAAe,CA6F3B;IAED;;;;;;;;;;;OAWG;IACH,
|
|
1
|
+
{"version":3,"file":"CompilerLib_v0_16.d.ts","sourceRoot":"","sources":["../../src/compiler/CompilerLib_v0_16.js"],"names":[],"mappings":"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"}
|