@sig-net/midnight-contract 0.0.9 → 0.11.0
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/README.md +1 -1
- package/dist/managed/compiler/contract-info.json +173 -87
- package/dist/managed/compiler/contract-manifest.json +34 -34
- package/dist/managed/contract/index.d.ts +98 -76
- package/dist/managed/contract/index.js +157 -127
- package/dist/managed/contract/index.js.map +1 -1
- package/dist/managed/keys/{postRespondBidirectional.prover → respondBidirectional.prover} +0 -0
- package/dist/managed/keys/respondBidirectional.verifier +0 -0
- package/dist/managed/zkir/respondBidirectional.bzkir +0 -0
- package/dist/managed/zkir/{postRespondBidirectional.zkir → respondBidirectional.zkir} +17 -13
- package/dist/witnesses.js +3 -3
- package/dist/witnesses.js.map +1 -1
- package/package.json +2 -2
- package/dist/managed/keys/postRespondBidirectional.verifier +0 -0
- package/dist/managed/zkir/postRespondBidirectional.bzkir +0 -0
- /package/dist/managed/keys/{postSignatureResponse.prover → respond.prover} +0 -0
- /package/dist/managed/keys/{postSignatureResponse.verifier → respond.verifier} +0 -0
- /package/dist/managed/keys/{signBidirectionalEvent.prover → signBidirectional.prover} +0 -0
- /package/dist/managed/keys/{signBidirectionalEvent.verifier → signBidirectional.verifier} +0 -0
- /package/dist/managed/zkir/{postSignatureResponse.bzkir → respond.bzkir} +0 -0
- /package/dist/managed/zkir/{postSignatureResponse.zkir → respond.zkir} +0 -0
- /package/dist/managed/zkir/{signBidirectionalEvent.bzkir → signBidirectional.bzkir} +0 -0
- /package/dist/managed/zkir/{signBidirectionalEvent.zkir → signBidirectional.zkir} +0 -0
|
@@ -30,25 +30,58 @@ const _descriptor_5 = new __compactRuntime.CompactTypeBytes(128);
|
|
|
30
30
|
|
|
31
31
|
const _descriptor_6 = new __compactRuntime.CompactTypeUnsignedInteger(255n, 1);
|
|
32
32
|
|
|
33
|
+
class _AffinePoint_0 {
|
|
34
|
+
alignment() {
|
|
35
|
+
return _descriptor_0.alignment().concat(_descriptor_0.alignment());
|
|
36
|
+
}
|
|
37
|
+
fromValue(value_0) {
|
|
38
|
+
return {
|
|
39
|
+
x: _descriptor_0.fromValue(value_0),
|
|
40
|
+
y: _descriptor_0.fromValue(value_0)
|
|
41
|
+
}
|
|
42
|
+
}
|
|
43
|
+
toValue(value_0) {
|
|
44
|
+
return _descriptor_0.toValue(value_0.x).concat(_descriptor_0.toValue(value_0.y));
|
|
45
|
+
}
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
const _descriptor_7 = new _AffinePoint_0();
|
|
49
|
+
|
|
50
|
+
class _Signature_0 {
|
|
51
|
+
alignment() {
|
|
52
|
+
return _descriptor_7.alignment().concat(_descriptor_0.alignment().concat(_descriptor_6.alignment()));
|
|
53
|
+
}
|
|
54
|
+
fromValue(value_0) {
|
|
55
|
+
return {
|
|
56
|
+
bigR: _descriptor_7.fromValue(value_0),
|
|
57
|
+
s: _descriptor_0.fromValue(value_0),
|
|
58
|
+
recoveryId: _descriptor_6.fromValue(value_0)
|
|
59
|
+
}
|
|
60
|
+
}
|
|
61
|
+
toValue(value_0) {
|
|
62
|
+
return _descriptor_7.toValue(value_0.bigR).concat(_descriptor_0.toValue(value_0.s).concat(_descriptor_6.toValue(value_0.recoveryId)));
|
|
63
|
+
}
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
const _descriptor_8 = new _Signature_0();
|
|
67
|
+
|
|
33
68
|
class _RespondBidirectionalEvent_0 {
|
|
34
69
|
alignment() {
|
|
35
|
-
return _descriptor_5.alignment().concat(_descriptor_6.alignment().concat(
|
|
70
|
+
return _descriptor_5.alignment().concat(_descriptor_6.alignment().concat(_descriptor_8.alignment()));
|
|
36
71
|
}
|
|
37
72
|
fromValue(value_0) {
|
|
38
73
|
return {
|
|
39
74
|
serializedOutput: _descriptor_5.fromValue(value_0),
|
|
40
75
|
outputLen: _descriptor_6.fromValue(value_0),
|
|
41
|
-
|
|
42
|
-
s: _descriptor_0.fromValue(value_0),
|
|
43
|
-
recoveryId: _descriptor_6.fromValue(value_0)
|
|
76
|
+
signature: _descriptor_8.fromValue(value_0)
|
|
44
77
|
}
|
|
45
78
|
}
|
|
46
79
|
toValue(value_0) {
|
|
47
|
-
return _descriptor_5.toValue(value_0.serializedOutput).concat(_descriptor_6.toValue(value_0.outputLen).concat(
|
|
80
|
+
return _descriptor_5.toValue(value_0.serializedOutput).concat(_descriptor_6.toValue(value_0.outputLen).concat(_descriptor_8.toValue(value_0.signature)));
|
|
48
81
|
}
|
|
49
82
|
}
|
|
50
83
|
|
|
51
|
-
const
|
|
84
|
+
const _descriptor_9 = new _RespondBidirectionalEvent_0();
|
|
52
85
|
|
|
53
86
|
class _SignBidirectionalEventNotification_0 {
|
|
54
87
|
alignment() {
|
|
@@ -65,26 +98,23 @@ class _SignBidirectionalEventNotification_0 {
|
|
|
65
98
|
}
|
|
66
99
|
}
|
|
67
100
|
|
|
68
|
-
const
|
|
101
|
+
const _descriptor_10 = new _SignBidirectionalEventNotification_0();
|
|
69
102
|
|
|
70
103
|
class _SignatureRespondedEvent_0 {
|
|
71
104
|
alignment() {
|
|
72
|
-
return
|
|
105
|
+
return _descriptor_8.alignment();
|
|
73
106
|
}
|
|
74
107
|
fromValue(value_0) {
|
|
75
108
|
return {
|
|
76
|
-
|
|
77
|
-
bigRy: _descriptor_0.fromValue(value_0),
|
|
78
|
-
s: _descriptor_0.fromValue(value_0),
|
|
79
|
-
recoveryId: _descriptor_6.fromValue(value_0)
|
|
109
|
+
signature: _descriptor_8.fromValue(value_0)
|
|
80
110
|
}
|
|
81
111
|
}
|
|
82
112
|
toValue(value_0) {
|
|
83
|
-
return
|
|
113
|
+
return _descriptor_8.toValue(value_0.signature);
|
|
84
114
|
}
|
|
85
115
|
}
|
|
86
116
|
|
|
87
|
-
const
|
|
117
|
+
const _descriptor_11 = new _SignatureRespondedEvent_0();
|
|
88
118
|
|
|
89
119
|
class _Either_0 {
|
|
90
120
|
alignment() {
|
|
@@ -102,9 +132,9 @@ class _Either_0 {
|
|
|
102
132
|
}
|
|
103
133
|
}
|
|
104
134
|
|
|
105
|
-
const
|
|
135
|
+
const _descriptor_12 = new _Either_0();
|
|
106
136
|
|
|
107
|
-
const
|
|
137
|
+
const _descriptor_13 = new __compactRuntime.CompactTypeUnsignedInteger(340282366920938463463374607431768211455n, 16);
|
|
108
138
|
|
|
109
139
|
class _ContractAddress_0 {
|
|
110
140
|
alignment() {
|
|
@@ -120,9 +150,9 @@ class _ContractAddress_0 {
|
|
|
120
150
|
}
|
|
121
151
|
}
|
|
122
152
|
|
|
123
|
-
const
|
|
153
|
+
const _descriptor_14 = new _ContractAddress_0();
|
|
124
154
|
|
|
125
|
-
const
|
|
155
|
+
const _descriptor_15 = new __compactRuntime.CompactTypeUnsignedInteger(4294967295n, 4);
|
|
126
156
|
|
|
127
157
|
export class Contract {
|
|
128
158
|
witnesses;
|
|
@@ -136,29 +166,29 @@ export class Contract {
|
|
|
136
166
|
}
|
|
137
167
|
this.witnesses = witnesses_0;
|
|
138
168
|
this.circuits = {
|
|
139
|
-
|
|
169
|
+
signBidirectional: async (...args_1) => {
|
|
140
170
|
if (args_1.length !== 3) {
|
|
141
|
-
throw new __compactRuntime.CompactError(`
|
|
171
|
+
throw new __compactRuntime.CompactError(`signBidirectional: expected 3 arguments (as invoked from Typescript), received ${args_1.length}`);
|
|
142
172
|
}
|
|
143
173
|
const contextOrig_0 = args_1[0];
|
|
144
174
|
const requestId_0 = args_1[1];
|
|
145
175
|
const notification_0 = args_1[2];
|
|
146
176
|
if (!(typeof(contextOrig_0) === 'object' && contextOrig_0.callContext.currentQueryContext != undefined)) {
|
|
147
|
-
__compactRuntime.typeError('
|
|
177
|
+
__compactRuntime.typeError('signBidirectional',
|
|
148
178
|
'argument 1 (as invoked from Typescript)',
|
|
149
179
|
'signet-contract.compact line 37 char 1',
|
|
150
180
|
'CircuitContext',
|
|
151
181
|
contextOrig_0)
|
|
152
182
|
}
|
|
153
183
|
if (!(requestId_0.buffer instanceof ArrayBuffer && requestId_0.BYTES_PER_ELEMENT === 1 && requestId_0.length === 32)) {
|
|
154
|
-
__compactRuntime.typeError('
|
|
184
|
+
__compactRuntime.typeError('signBidirectional',
|
|
155
185
|
'argument 1 (argument 2 as invoked from Typescript)',
|
|
156
186
|
'signet-contract.compact line 37 char 1',
|
|
157
187
|
'Bytes<32>',
|
|
158
188
|
requestId_0)
|
|
159
189
|
}
|
|
160
190
|
if (!(typeof(notification_0) === 'object' && typeof(notification_0.version) === 'bigint' && notification_0.version >= 0n && notification_0.version <= 255n && notification_0.payload.buffer instanceof ArrayBuffer && notification_0.payload.BYTES_PER_ELEMENT === 1 && notification_0.payload.length === 128)) {
|
|
161
|
-
__compactRuntime.typeError('
|
|
191
|
+
__compactRuntime.typeError('signBidirectional',
|
|
162
192
|
'argument 2 (argument 3 as invoked from Typescript)',
|
|
163
193
|
'signet-contract.compact line 37 char 1',
|
|
164
194
|
'struct SignBidirectionalEventNotification<version: Uint<0..256>, payload: Bytes<128>>',
|
|
@@ -167,123 +197,123 @@ export class Contract {
|
|
|
167
197
|
const context = __compactRuntime.copyCircuitContext(contextOrig_0);
|
|
168
198
|
const partialProofData = {
|
|
169
199
|
input: {
|
|
170
|
-
value: _descriptor_0.toValue(requestId_0).concat(
|
|
171
|
-
alignment: _descriptor_0.alignment().concat(
|
|
200
|
+
value: _descriptor_0.toValue(requestId_0).concat(_descriptor_10.toValue(notification_0)),
|
|
201
|
+
alignment: _descriptor_0.alignment().concat(_descriptor_10.alignment())
|
|
172
202
|
},
|
|
173
203
|
output: undefined,
|
|
174
204
|
publicTranscript: [],
|
|
175
205
|
privateTranscriptOutputs: []
|
|
176
206
|
};
|
|
177
|
-
const result_0 = await this.
|
|
178
|
-
|
|
179
|
-
|
|
180
|
-
|
|
207
|
+
const result_0 = await this._signBidirectional_0(context,
|
|
208
|
+
partialProofData,
|
|
209
|
+
requestId_0,
|
|
210
|
+
notification_0);
|
|
181
211
|
partialProofData.output = { value: _descriptor_4.toValue(result_0), alignment: _descriptor_4.alignment() };
|
|
182
212
|
__compactRuntime.finalizeCallProofData(context, partialProofData);
|
|
183
213
|
return { result: result_0, context: context, gasCost: context.callContext.currentGasCost };
|
|
184
214
|
},
|
|
185
|
-
|
|
215
|
+
respond: async (...args_1) => {
|
|
186
216
|
if (args_1.length !== 3) {
|
|
187
|
-
throw new __compactRuntime.CompactError(`
|
|
217
|
+
throw new __compactRuntime.CompactError(`respond: expected 3 arguments (as invoked from Typescript), received ${args_1.length}`);
|
|
188
218
|
}
|
|
189
219
|
const contextOrig_0 = args_1[0];
|
|
190
220
|
const requestId_0 = args_1[1];
|
|
191
221
|
const signatureRespondedEvent_0 = args_1[2];
|
|
192
222
|
if (!(typeof(contextOrig_0) === 'object' && contextOrig_0.callContext.currentQueryContext != undefined)) {
|
|
193
|
-
__compactRuntime.typeError('
|
|
223
|
+
__compactRuntime.typeError('respond',
|
|
194
224
|
'argument 1 (as invoked from Typescript)',
|
|
195
225
|
'signet-contract.compact line 66 char 1',
|
|
196
226
|
'CircuitContext',
|
|
197
227
|
contextOrig_0)
|
|
198
228
|
}
|
|
199
229
|
if (!(requestId_0.buffer instanceof ArrayBuffer && requestId_0.BYTES_PER_ELEMENT === 1 && requestId_0.length === 32)) {
|
|
200
|
-
__compactRuntime.typeError('
|
|
230
|
+
__compactRuntime.typeError('respond',
|
|
201
231
|
'argument 1 (argument 2 as invoked from Typescript)',
|
|
202
232
|
'signet-contract.compact line 66 char 1',
|
|
203
233
|
'Bytes<32>',
|
|
204
234
|
requestId_0)
|
|
205
235
|
}
|
|
206
|
-
if (!(typeof(signatureRespondedEvent_0) === 'object' && signatureRespondedEvent_0.
|
|
207
|
-
__compactRuntime.typeError('
|
|
236
|
+
if (!(typeof(signatureRespondedEvent_0) === 'object' && typeof(signatureRespondedEvent_0.signature) === 'object' && typeof(signatureRespondedEvent_0.signature.bigR) === 'object' && signatureRespondedEvent_0.signature.bigR.x.buffer instanceof ArrayBuffer && signatureRespondedEvent_0.signature.bigR.x.BYTES_PER_ELEMENT === 1 && signatureRespondedEvent_0.signature.bigR.x.length === 32 && signatureRespondedEvent_0.signature.bigR.y.buffer instanceof ArrayBuffer && signatureRespondedEvent_0.signature.bigR.y.BYTES_PER_ELEMENT === 1 && signatureRespondedEvent_0.signature.bigR.y.length === 32 && signatureRespondedEvent_0.signature.s.buffer instanceof ArrayBuffer && signatureRespondedEvent_0.signature.s.BYTES_PER_ELEMENT === 1 && signatureRespondedEvent_0.signature.s.length === 32 && typeof(signatureRespondedEvent_0.signature.recoveryId) === 'bigint' && signatureRespondedEvent_0.signature.recoveryId >= 0n && signatureRespondedEvent_0.signature.recoveryId <= 255n)) {
|
|
237
|
+
__compactRuntime.typeError('respond',
|
|
208
238
|
'argument 2 (argument 3 as invoked from Typescript)',
|
|
209
239
|
'signet-contract.compact line 66 char 1',
|
|
210
|
-
'struct SignatureRespondedEvent<
|
|
240
|
+
'struct SignatureRespondedEvent<signature: struct Signature<bigR: struct AffinePoint<x: Bytes<32>, y: Bytes<32>>, s: Bytes<32>, recoveryId: Uint<0..256>>>',
|
|
211
241
|
signatureRespondedEvent_0)
|
|
212
242
|
}
|
|
213
243
|
const context = __compactRuntime.copyCircuitContext(contextOrig_0);
|
|
214
244
|
const partialProofData = {
|
|
215
245
|
input: {
|
|
216
|
-
value: _descriptor_0.toValue(requestId_0).concat(
|
|
217
|
-
alignment: _descriptor_0.alignment().concat(
|
|
246
|
+
value: _descriptor_0.toValue(requestId_0).concat(_descriptor_11.toValue(signatureRespondedEvent_0)),
|
|
247
|
+
alignment: _descriptor_0.alignment().concat(_descriptor_11.alignment())
|
|
218
248
|
},
|
|
219
249
|
output: undefined,
|
|
220
250
|
publicTranscript: [],
|
|
221
251
|
privateTranscriptOutputs: []
|
|
222
252
|
};
|
|
223
|
-
const result_0 = await this.
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
253
|
+
const result_0 = await this._respond_0(context,
|
|
254
|
+
partialProofData,
|
|
255
|
+
requestId_0,
|
|
256
|
+
signatureRespondedEvent_0);
|
|
227
257
|
partialProofData.output = { value: [], alignment: [] };
|
|
228
258
|
__compactRuntime.finalizeCallProofData(context, partialProofData);
|
|
229
259
|
return { result: result_0, context: context, gasCost: context.callContext.currentGasCost };
|
|
230
260
|
},
|
|
231
|
-
|
|
261
|
+
respondBidirectional: async (...args_1) => {
|
|
232
262
|
if (args_1.length !== 3) {
|
|
233
|
-
throw new __compactRuntime.CompactError(`
|
|
263
|
+
throw new __compactRuntime.CompactError(`respondBidirectional: expected 3 arguments (as invoked from Typescript), received ${args_1.length}`);
|
|
234
264
|
}
|
|
235
265
|
const contextOrig_0 = args_1[0];
|
|
236
266
|
const requestId_0 = args_1[1];
|
|
237
267
|
const respondBidirectionalEvent_0 = args_1[2];
|
|
238
268
|
if (!(typeof(contextOrig_0) === 'object' && contextOrig_0.callContext.currentQueryContext != undefined)) {
|
|
239
|
-
__compactRuntime.typeError('
|
|
269
|
+
__compactRuntime.typeError('respondBidirectional',
|
|
240
270
|
'argument 1 (as invoked from Typescript)',
|
|
241
271
|
'signet-contract.compact line 97 char 1',
|
|
242
272
|
'CircuitContext',
|
|
243
273
|
contextOrig_0)
|
|
244
274
|
}
|
|
245
275
|
if (!(requestId_0.buffer instanceof ArrayBuffer && requestId_0.BYTES_PER_ELEMENT === 1 && requestId_0.length === 32)) {
|
|
246
|
-
__compactRuntime.typeError('
|
|
276
|
+
__compactRuntime.typeError('respondBidirectional',
|
|
247
277
|
'argument 1 (argument 2 as invoked from Typescript)',
|
|
248
278
|
'signet-contract.compact line 97 char 1',
|
|
249
279
|
'Bytes<32>',
|
|
250
280
|
requestId_0)
|
|
251
281
|
}
|
|
252
|
-
if (!(typeof(respondBidirectionalEvent_0) === 'object' && respondBidirectionalEvent_0.serializedOutput.buffer instanceof ArrayBuffer && respondBidirectionalEvent_0.serializedOutput.BYTES_PER_ELEMENT === 1 && respondBidirectionalEvent_0.serializedOutput.length === 128 && typeof(respondBidirectionalEvent_0.outputLen) === 'bigint' && respondBidirectionalEvent_0.outputLen >= 0n && respondBidirectionalEvent_0.outputLen <= 255n && respondBidirectionalEvent_0.
|
|
253
|
-
__compactRuntime.typeError('
|
|
282
|
+
if (!(typeof(respondBidirectionalEvent_0) === 'object' && respondBidirectionalEvent_0.serializedOutput.buffer instanceof ArrayBuffer && respondBidirectionalEvent_0.serializedOutput.BYTES_PER_ELEMENT === 1 && respondBidirectionalEvent_0.serializedOutput.length === 128 && typeof(respondBidirectionalEvent_0.outputLen) === 'bigint' && respondBidirectionalEvent_0.outputLen >= 0n && respondBidirectionalEvent_0.outputLen <= 255n && typeof(respondBidirectionalEvent_0.signature) === 'object' && typeof(respondBidirectionalEvent_0.signature.bigR) === 'object' && respondBidirectionalEvent_0.signature.bigR.x.buffer instanceof ArrayBuffer && respondBidirectionalEvent_0.signature.bigR.x.BYTES_PER_ELEMENT === 1 && respondBidirectionalEvent_0.signature.bigR.x.length === 32 && respondBidirectionalEvent_0.signature.bigR.y.buffer instanceof ArrayBuffer && respondBidirectionalEvent_0.signature.bigR.y.BYTES_PER_ELEMENT === 1 && respondBidirectionalEvent_0.signature.bigR.y.length === 32 && respondBidirectionalEvent_0.signature.s.buffer instanceof ArrayBuffer && respondBidirectionalEvent_0.signature.s.BYTES_PER_ELEMENT === 1 && respondBidirectionalEvent_0.signature.s.length === 32 && typeof(respondBidirectionalEvent_0.signature.recoveryId) === 'bigint' && respondBidirectionalEvent_0.signature.recoveryId >= 0n && respondBidirectionalEvent_0.signature.recoveryId <= 255n)) {
|
|
283
|
+
__compactRuntime.typeError('respondBidirectional',
|
|
254
284
|
'argument 2 (argument 3 as invoked from Typescript)',
|
|
255
285
|
'signet-contract.compact line 97 char 1',
|
|
256
|
-
'struct RespondBidirectionalEvent<serializedOutput: Bytes<128>, outputLen: Uint<0..256>,
|
|
286
|
+
'struct RespondBidirectionalEvent<serializedOutput: Bytes<128>, outputLen: Uint<0..256>, signature: struct Signature<bigR: struct AffinePoint<x: Bytes<32>, y: Bytes<32>>, s: Bytes<32>, recoveryId: Uint<0..256>>>',
|
|
257
287
|
respondBidirectionalEvent_0)
|
|
258
288
|
}
|
|
259
289
|
const context = __compactRuntime.copyCircuitContext(contextOrig_0);
|
|
260
290
|
const partialProofData = {
|
|
261
291
|
input: {
|
|
262
|
-
value: _descriptor_0.toValue(requestId_0).concat(
|
|
263
|
-
alignment: _descriptor_0.alignment().concat(
|
|
292
|
+
value: _descriptor_0.toValue(requestId_0).concat(_descriptor_9.toValue(respondBidirectionalEvent_0)),
|
|
293
|
+
alignment: _descriptor_0.alignment().concat(_descriptor_9.alignment())
|
|
264
294
|
},
|
|
265
295
|
output: undefined,
|
|
266
296
|
publicTranscript: [],
|
|
267
297
|
privateTranscriptOutputs: []
|
|
268
298
|
};
|
|
269
|
-
const result_0 = await this.
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
299
|
+
const result_0 = await this._respondBidirectional_0(context,
|
|
300
|
+
partialProofData,
|
|
301
|
+
requestId_0,
|
|
302
|
+
respondBidirectionalEvent_0);
|
|
273
303
|
partialProofData.output = { value: [], alignment: [] };
|
|
274
304
|
__compactRuntime.finalizeCallProofData(context, partialProofData);
|
|
275
305
|
return { result: result_0, context: context, gasCost: context.callContext.currentGasCost };
|
|
276
306
|
}
|
|
277
307
|
};
|
|
278
308
|
this.impureCircuits = {
|
|
279
|
-
|
|
280
|
-
|
|
281
|
-
|
|
309
|
+
signBidirectional: this.circuits.signBidirectional,
|
|
310
|
+
respond: this.circuits.respond,
|
|
311
|
+
respondBidirectional: this.circuits.respondBidirectional
|
|
282
312
|
};
|
|
283
313
|
this.provableCircuits = {
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
314
|
+
signBidirectional: this.circuits.signBidirectional,
|
|
315
|
+
respond: this.circuits.respond,
|
|
316
|
+
respondBidirectional: this.circuits.respondBidirectional
|
|
287
317
|
};
|
|
288
318
|
}
|
|
289
319
|
async initialState(...args_0) {
|
|
@@ -309,9 +339,9 @@ export class Contract {
|
|
|
309
339
|
stateValue_0 = stateValue_0.arrayPush(__compactRuntime.StateValue.newNull());
|
|
310
340
|
stateValue_0 = stateValue_0.arrayPush(__compactRuntime.StateValue.newNull());
|
|
311
341
|
state_0.data = new __compactRuntime.ChargedState(stateValue_0);
|
|
312
|
-
state_0.setOperation('
|
|
313
|
-
state_0.setOperation('
|
|
314
|
-
state_0.setOperation('
|
|
342
|
+
state_0.setOperation('signBidirectional', new __compactRuntime.ContractOperation());
|
|
343
|
+
state_0.setOperation('respond', new __compactRuntime.ContractOperation());
|
|
344
|
+
state_0.setOperation('respondBidirectional', new __compactRuntime.ContractOperation());
|
|
315
345
|
const context = __compactRuntime.createCircuitContext('constructor', __compactRuntime.dummyContractAddress(), constructorContext_0.initialZswapLocalState.coinPublicKey, state_0.data, constructorContext_0.initialPrivateState);
|
|
316
346
|
const partialProofData = {
|
|
317
347
|
input: { value: [], alignment: [] },
|
|
@@ -392,10 +422,10 @@ export class Contract {
|
|
|
392
422
|
currentZswapLocalState: context.callContext.currentZswapLocalState
|
|
393
423
|
}
|
|
394
424
|
}
|
|
395
|
-
async
|
|
396
|
-
|
|
397
|
-
|
|
398
|
-
|
|
425
|
+
async _signBidirectional_0(context,
|
|
426
|
+
partialProofData,
|
|
427
|
+
requestId_0,
|
|
428
|
+
notification_0)
|
|
399
429
|
{
|
|
400
430
|
__compactRuntime.assert(notification_0.version === 1n,
|
|
401
431
|
'only version 1 notification supported');
|
|
@@ -483,16 +513,16 @@ export class Contract {
|
|
|
483
513
|
value: __compactRuntime.StateValue.newCell({ value: _descriptor_4.toValue(signBidirectionalEventNotificationMapKey_0),
|
|
484
514
|
alignment: _descriptor_4.alignment() }).encode() } },
|
|
485
515
|
{ push: { storage: true,
|
|
486
|
-
value: __compactRuntime.StateValue.newCell({ value:
|
|
487
|
-
alignment:
|
|
516
|
+
value: __compactRuntime.StateValue.newCell({ value: _descriptor_10.toValue(notification_0),
|
|
517
|
+
alignment: _descriptor_10.alignment() }).encode() } },
|
|
488
518
|
{ ins: { cached: false, n: 1 } },
|
|
489
519
|
{ ins: { cached: true, n: 1 } }]);
|
|
490
520
|
return signBidirectionalEventNotificationMapKey_0;
|
|
491
521
|
}
|
|
492
|
-
async
|
|
493
|
-
|
|
494
|
-
|
|
495
|
-
|
|
522
|
+
async _respond_0(context,
|
|
523
|
+
partialProofData,
|
|
524
|
+
requestId_0,
|
|
525
|
+
signatureRespondedEvent_0)
|
|
496
526
|
{
|
|
497
527
|
const disclosedRequestId_0 = requestId_0;
|
|
498
528
|
if (!_descriptor_2.fromValue(__compactRuntime.queryLedgerState(context,
|
|
@@ -578,16 +608,16 @@ export class Contract {
|
|
|
578
608
|
value: __compactRuntime.StateValue.newCell({ value: _descriptor_4.toValue(tmp_1),
|
|
579
609
|
alignment: _descriptor_4.alignment() }).encode() } },
|
|
580
610
|
{ push: { storage: true,
|
|
581
|
-
value: __compactRuntime.StateValue.newCell({ value:
|
|
582
|
-
alignment:
|
|
611
|
+
value: __compactRuntime.StateValue.newCell({ value: _descriptor_11.toValue(signatureRespondedEvent_0),
|
|
612
|
+
alignment: _descriptor_11.alignment() }).encode() } },
|
|
583
613
|
{ ins: { cached: false, n: 1 } },
|
|
584
614
|
{ ins: { cached: true, n: 1 } }]);
|
|
585
615
|
return [];
|
|
586
616
|
}
|
|
587
|
-
async
|
|
588
|
-
|
|
589
|
-
|
|
590
|
-
|
|
617
|
+
async _respondBidirectional_0(context,
|
|
618
|
+
partialProofData,
|
|
619
|
+
requestId_0,
|
|
620
|
+
respondBidirectionalEvent_0)
|
|
591
621
|
{
|
|
592
622
|
const disclosedRequestId_0 = requestId_0;
|
|
593
623
|
if (!_descriptor_2.fromValue(__compactRuntime.queryLedgerState(context,
|
|
@@ -673,8 +703,8 @@ export class Contract {
|
|
|
673
703
|
value: __compactRuntime.StateValue.newCell({ value: _descriptor_4.toValue(tmp_1),
|
|
674
704
|
alignment: _descriptor_4.alignment() }).encode() } },
|
|
675
705
|
{ push: { storage: true,
|
|
676
|
-
value: __compactRuntime.StateValue.newCell({ value:
|
|
677
|
-
alignment:
|
|
706
|
+
value: __compactRuntime.StateValue.newCell({ value: _descriptor_9.toValue(respondBidirectionalEvent_0),
|
|
707
|
+
alignment: _descriptor_9.alignment() }).encode() } },
|
|
678
708
|
{ ins: { cached: false, n: 1 } },
|
|
679
709
|
{ ins: { cached: true, n: 1 } }]);
|
|
680
710
|
return [];
|
|
@@ -886,34 +916,34 @@ export function ledger(stateOrChargedState) {
|
|
|
886
916
|
'struct SignetMapKey<count: Uint<0..18446744073709551616>, requestId: Bytes<32>>',
|
|
887
917
|
key_0)
|
|
888
918
|
}
|
|
889
|
-
return
|
|
890
|
-
|
|
891
|
-
|
|
892
|
-
|
|
893
|
-
|
|
894
|
-
|
|
895
|
-
|
|
896
|
-
|
|
897
|
-
|
|
898
|
-
|
|
899
|
-
|
|
900
|
-
|
|
901
|
-
|
|
902
|
-
|
|
903
|
-
|
|
904
|
-
|
|
905
|
-
|
|
906
|
-
|
|
919
|
+
return _descriptor_10.fromValue(__compactRuntime.queryLedgerState(context,
|
|
920
|
+
partialProofData,
|
|
921
|
+
[
|
|
922
|
+
{ dup: { n: 0 } },
|
|
923
|
+
{ idx: { cached: false,
|
|
924
|
+
pushPath: false,
|
|
925
|
+
path: [
|
|
926
|
+
{ tag: 'value',
|
|
927
|
+
value: { value: _descriptor_6.toValue(1n),
|
|
928
|
+
alignment: _descriptor_6.alignment() } }] } },
|
|
929
|
+
{ idx: { cached: false,
|
|
930
|
+
pushPath: false,
|
|
931
|
+
path: [
|
|
932
|
+
{ tag: 'value',
|
|
933
|
+
value: { value: _descriptor_4.toValue(key_0),
|
|
934
|
+
alignment: _descriptor_4.alignment() } }] } },
|
|
935
|
+
{ popeq: { cached: false,
|
|
936
|
+
result: undefined } }]).value);
|
|
907
937
|
},
|
|
908
938
|
[Symbol.iterator](...args_0) {
|
|
909
939
|
if (args_0.length !== 0) {
|
|
910
940
|
throw new __compactRuntime.CompactError(`iter: expected 0 arguments, received ${args_0.length}`);
|
|
911
941
|
}
|
|
912
942
|
const self_0 = state.asArray()[1];
|
|
913
|
-
return self_0.asMap().keys().map( (key) => { const value = self_0.asMap().get(key).asCell(); return [ _descriptor_4.fromValue(key.value),
|
|
943
|
+
return self_0.asMap().keys().map( (key) => { const value = self_0.asMap().get(key).asCell(); return [ _descriptor_4.fromValue(key.value), _descriptor_10.fromValue(value.value) ]; })[Symbol.iterator]();
|
|
914
944
|
}
|
|
915
945
|
},
|
|
916
|
-
|
|
946
|
+
respondCounterMap: {
|
|
917
947
|
isEmpty(...args_0) {
|
|
918
948
|
if (args_0.length !== 0) {
|
|
919
949
|
throw new __compactRuntime.CompactError(`isEmpty: expected 0 arguments, received ${args_0.length}`);
|
|
@@ -1023,7 +1053,7 @@ export function ledger(stateOrChargedState) {
|
|
|
1023
1053
|
}
|
|
1024
1054
|
}
|
|
1025
1055
|
},
|
|
1026
|
-
|
|
1056
|
+
respondMap: {
|
|
1027
1057
|
isEmpty(...args_0) {
|
|
1028
1058
|
if (args_0.length !== 0) {
|
|
1029
1059
|
throw new __compactRuntime.CompactError(`isEmpty: expected 0 arguments, received ${args_0.length}`);
|
|
@@ -1105,31 +1135,31 @@ export function ledger(stateOrChargedState) {
|
|
|
1105
1135
|
'struct SignetMapKey<count: Uint<0..18446744073709551616>, requestId: Bytes<32>>',
|
|
1106
1136
|
key_0)
|
|
1107
1137
|
}
|
|
1108
|
-
return
|
|
1109
|
-
|
|
1110
|
-
|
|
1111
|
-
|
|
1112
|
-
|
|
1113
|
-
|
|
1114
|
-
|
|
1115
|
-
|
|
1116
|
-
|
|
1117
|
-
|
|
1118
|
-
|
|
1119
|
-
|
|
1120
|
-
|
|
1121
|
-
|
|
1122
|
-
|
|
1123
|
-
|
|
1124
|
-
|
|
1125
|
-
|
|
1138
|
+
return _descriptor_11.fromValue(__compactRuntime.queryLedgerState(context,
|
|
1139
|
+
partialProofData,
|
|
1140
|
+
[
|
|
1141
|
+
{ dup: { n: 0 } },
|
|
1142
|
+
{ idx: { cached: false,
|
|
1143
|
+
pushPath: false,
|
|
1144
|
+
path: [
|
|
1145
|
+
{ tag: 'value',
|
|
1146
|
+
value: { value: _descriptor_6.toValue(3n),
|
|
1147
|
+
alignment: _descriptor_6.alignment() } }] } },
|
|
1148
|
+
{ idx: { cached: false,
|
|
1149
|
+
pushPath: false,
|
|
1150
|
+
path: [
|
|
1151
|
+
{ tag: 'value',
|
|
1152
|
+
value: { value: _descriptor_4.toValue(key_0),
|
|
1153
|
+
alignment: _descriptor_4.alignment() } }] } },
|
|
1154
|
+
{ popeq: { cached: false,
|
|
1155
|
+
result: undefined } }]).value);
|
|
1126
1156
|
},
|
|
1127
1157
|
[Symbol.iterator](...args_0) {
|
|
1128
1158
|
if (args_0.length !== 0) {
|
|
1129
1159
|
throw new __compactRuntime.CompactError(`iter: expected 0 arguments, received ${args_0.length}`);
|
|
1130
1160
|
}
|
|
1131
1161
|
const self_0 = state.asArray()[3];
|
|
1132
|
-
return self_0.asMap().keys().map( (key) => { const value = self_0.asMap().get(key).asCell(); return [ _descriptor_4.fromValue(key.value),
|
|
1162
|
+
return self_0.asMap().keys().map( (key) => { const value = self_0.asMap().get(key).asCell(); return [ _descriptor_4.fromValue(key.value), _descriptor_11.fromValue(value.value) ]; })[Symbol.iterator]();
|
|
1133
1163
|
}
|
|
1134
1164
|
},
|
|
1135
1165
|
respondBidirectionalCounterMap: {
|
|
@@ -1324,7 +1354,7 @@ export function ledger(stateOrChargedState) {
|
|
|
1324
1354
|
'struct SignetMapKey<count: Uint<0..18446744073709551616>, requestId: Bytes<32>>',
|
|
1325
1355
|
key_0)
|
|
1326
1356
|
}
|
|
1327
|
-
return
|
|
1357
|
+
return _descriptor_9.fromValue(__compactRuntime.queryLedgerState(context,
|
|
1328
1358
|
partialProofData,
|
|
1329
1359
|
[
|
|
1330
1360
|
{ dup: { n: 0 } },
|
|
@@ -1348,7 +1378,7 @@ export function ledger(stateOrChargedState) {
|
|
|
1348
1378
|
throw new __compactRuntime.CompactError(`iter: expected 0 arguments, received ${args_0.length}`);
|
|
1349
1379
|
}
|
|
1350
1380
|
const self_0 = state.asArray()[5];
|
|
1351
|
-
return self_0.asMap().keys().map( (key) => { const value = self_0.asMap().get(key).asCell(); return [ _descriptor_4.fromValue(key.value),
|
|
1381
|
+
return self_0.asMap().keys().map( (key) => { const value = self_0.asMap().get(key).asCell(); return [ _descriptor_4.fromValue(key.value), _descriptor_9.fromValue(value.value) ]; })[Symbol.iterator]();
|
|
1352
1382
|
}
|
|
1353
1383
|
}
|
|
1354
1384
|
};
|
|
@@ -1361,9 +1391,9 @@ export const pureCircuits = {};
|
|
|
1361
1391
|
export const contractReferenceLocations =
|
|
1362
1392
|
{ tag: 'publicLedgerArray', indices: { } };
|
|
1363
1393
|
export const expectedVk = {
|
|
1364
|
-
'
|
|
1365
|
-
'
|
|
1366
|
-
'
|
|
1394
|
+
'respond': '22938eaebc029fd624db271e92857b132977c0373bf2f9ce823e21d011973e0d',
|
|
1395
|
+
'respondBidirectional': '54cc1474465848c419a898730ce6351deff8586827f41022d24a29d627bece9d',
|
|
1396
|
+
'signBidirectional': '3e603e64ac930b8e4e1412e0afb5b3769e3d9db62c3a0bace1fe367eb7dc868e',
|
|
1367
1397
|
};
|
|
1368
1398
|
|
|
1369
1399
|
//# sourceMappingURL=index.js.map
|
|
@@ -4,5 +4,5 @@
|
|
|
4
4
|
"sourceRoot": "../../../",
|
|
5
5
|
"sources": ["src/signet-contract.compact"],
|
|
6
6
|
"names": [],
|
|
7
|
-
"mappings": "
|
|
7
|
+
"mappings": "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"
|
|
8
8
|
}
|
|
Binary file
|
|
Binary file
|
|
Binary file
|