@odatano/contract-m402-vault 0.0.0-stage → 0.2.0

package/managed/m402-vault/contract/index.js

@@ -0,0 +1,2216 @@
+import * as __compactRuntime from '@midnight-ntwrk/compact-runtime';
+__compactRuntime.checkRuntimeVersion('0.21.0');
+
+const _descriptor_0 = new __compactRuntime.CompactTypeBytes(32);
+
+const _descriptor_1 = __compactRuntime.CompactTypeBoolean;
+
+const _descriptor_2 = new __compactRuntime.CompactTypeUnsignedInteger(18446744073709551615n, 8);
+
+class _ContractAddress_0 {
+  alignment() {
+    return _descriptor_0.alignment();
+  }
+  fromValue(value_0) {
+    return {
+      bytes: _descriptor_0.fromValue(value_0)
+    }
+  }
+  toValue(value_0) {
+    return _descriptor_0.toValue(value_0.bytes);
+  }
+}
+
+const _descriptor_3 = new _ContractAddress_0();
+
+const _descriptor_4 = new __compactRuntime.CompactTypeUnsignedInteger(340282366920938463463374607431768211455n, 16);
+
+class _ShieldedCoinInfo_0 {
+  alignment() {
+    return _descriptor_0.alignment().concat(_descriptor_0.alignment().concat(_descriptor_4.alignment()));
+  }
+  fromValue(value_0) {
+    return {
+      nonce: _descriptor_0.fromValue(value_0),
+      color: _descriptor_0.fromValue(value_0),
+      value: _descriptor_4.fromValue(value_0)
+    }
+  }
+  toValue(value_0) {
+    return _descriptor_0.toValue(value_0.nonce).concat(_descriptor_0.toValue(value_0.color).concat(_descriptor_4.toValue(value_0.value)));
+  }
+}
+
+const _descriptor_5 = new _ShieldedCoinInfo_0();
+
+const _descriptor_6 = new __compactRuntime.CompactTypeUnsignedInteger(65535n, 2);
+
+class _QualifiedShieldedCoinInfo_0 {
+  alignment() {
+    return _descriptor_0.alignment().concat(_descriptor_0.alignment().concat(_descriptor_4.alignment().concat(_descriptor_2.alignment())));
+  }
+  fromValue(value_0) {
+    return {
+      nonce: _descriptor_0.fromValue(value_0),
+      color: _descriptor_0.fromValue(value_0),
+      value: _descriptor_4.fromValue(value_0),
+      mt_index: _descriptor_2.fromValue(value_0)
+    }
+  }
+  toValue(value_0) {
+    return _descriptor_0.toValue(value_0.nonce).concat(_descriptor_0.toValue(value_0.color).concat(_descriptor_4.toValue(value_0.value).concat(_descriptor_2.toValue(value_0.mt_index))));
+  }
+}
+
+const _descriptor_7 = new _QualifiedShieldedCoinInfo_0();
+
+class _ZswapCoinPublicKey_0 {
+  alignment() {
+    return _descriptor_0.alignment();
+  }
+  fromValue(value_0) {
+    return {
+      bytes: _descriptor_0.fromValue(value_0)
+    }
+  }
+  toValue(value_0) {
+    return _descriptor_0.toValue(value_0.bytes);
+  }
+}
+
+const _descriptor_8 = new _ZswapCoinPublicKey_0();
+
+class _Either_0 {
+  alignment() {
+    return _descriptor_1.alignment().concat(_descriptor_8.alignment().concat(_descriptor_3.alignment()));
+  }
+  fromValue(value_0) {
+    return {
+      is_left: _descriptor_1.fromValue(value_0),
+      left: _descriptor_8.fromValue(value_0),
+      right: _descriptor_3.fromValue(value_0)
+    }
+  }
+  toValue(value_0) {
+    return _descriptor_1.toValue(value_0.is_left).concat(_descriptor_8.toValue(value_0.left).concat(_descriptor_3.toValue(value_0.right)));
+  }
+}
+
+const _descriptor_9 = new _Either_0();
+
+const _descriptor_10 = __compactRuntime.CompactTypeField;
+
+const _descriptor_11 = new __compactRuntime.CompactTypeVector(2, _descriptor_0);
+
+const _descriptor_12 = new __compactRuntime.CompactTypeVector(4, _descriptor_0);
+
+const _descriptor_13 = new __compactRuntime.CompactTypeBytes(21);
+
+class _CoinPreimage_0 {
+  alignment() {
+    return _descriptor_13.alignment().concat(_descriptor_5.alignment().concat(_descriptor_1.alignment().concat(_descriptor_0.alignment())));
+  }
+  fromValue(value_0) {
+    return {
+      domain_sep: _descriptor_13.fromValue(value_0),
+      info: _descriptor_5.fromValue(value_0),
+      dataType: _descriptor_1.fromValue(value_0),
+      data: _descriptor_0.fromValue(value_0)
+    }
+  }
+  toValue(value_0) {
+    return _descriptor_13.toValue(value_0.domain_sep).concat(_descriptor_5.toValue(value_0.info).concat(_descriptor_1.toValue(value_0.dataType).concat(_descriptor_0.toValue(value_0.data))));
+  }
+}
+
+const _descriptor_14 = new _CoinPreimage_0();
+
+const _descriptor_15 = new __compactRuntime.CompactTypeVector(2, _descriptor_10);
+
+const _descriptor_16 = new __compactRuntime.CompactTypeVector(3, _descriptor_0);
+
+class _Either_1 {
+  alignment() {
+    return _descriptor_1.alignment().concat(_descriptor_0.alignment().concat(_descriptor_0.alignment()));
+  }
+  fromValue(value_0) {
+    return {
+      is_left: _descriptor_1.fromValue(value_0),
+      left: _descriptor_0.fromValue(value_0),
+      right: _descriptor_0.fromValue(value_0)
+    }
+  }
+  toValue(value_0) {
+    return _descriptor_1.toValue(value_0.is_left).concat(_descriptor_0.toValue(value_0.left).concat(_descriptor_0.toValue(value_0.right)));
+  }
+}
+
+const _descriptor_17 = new _Either_1();
+
+const _descriptor_18 = new __compactRuntime.CompactTypeVector(3, _descriptor_10);
+
+class _UserAddress_0 {
+  alignment() {
+    return _descriptor_0.alignment();
+  }
+  fromValue(value_0) {
+    return {
+      bytes: _descriptor_0.fromValue(value_0)
+    }
+  }
+  toValue(value_0) {
+    return _descriptor_0.toValue(value_0.bytes);
+  }
+}
+
+const _descriptor_19 = new _UserAddress_0();
+
+class _Either_2 {
+  alignment() {
+    return _descriptor_1.alignment().concat(_descriptor_3.alignment().concat(_descriptor_19.alignment()));
+  }
+  fromValue(value_0) {
+    return {
+      is_left: _descriptor_1.fromValue(value_0),
+      left: _descriptor_3.fromValue(value_0),
+      right: _descriptor_19.fromValue(value_0)
+    }
+  }
+  toValue(value_0) {
+    return _descriptor_1.toValue(value_0.is_left).concat(_descriptor_3.toValue(value_0.left).concat(_descriptor_19.toValue(value_0.right)));
+  }
+}
+
+const _descriptor_20 = new _Either_2();
+
+class _Maybe_0 {
+  alignment() {
+    return _descriptor_1.alignment().concat(_descriptor_5.alignment());
+  }
+  fromValue(value_0) {
+    return {
+      is_some: _descriptor_1.fromValue(value_0),
+      value: _descriptor_5.fromValue(value_0)
+    }
+  }
+  toValue(value_0) {
+    return _descriptor_1.toValue(value_0.is_some).concat(_descriptor_5.toValue(value_0.value));
+  }
+}
+
+const _descriptor_21 = new _Maybe_0();
+
+class _ShieldedSendResult_0 {
+  alignment() {
+    return _descriptor_21.alignment().concat(_descriptor_5.alignment());
+  }
+  fromValue(value_0) {
+    return {
+      change: _descriptor_21.fromValue(value_0),
+      sent: _descriptor_5.fromValue(value_0)
+    }
+  }
+  toValue(value_0) {
+    return _descriptor_21.toValue(value_0.change).concat(_descriptor_5.toValue(value_0.sent));
+  }
+}
+
+const _descriptor_22 = new _ShieldedSendResult_0();
+
+class _Maybe_1 {
+  alignment() {
+    return _descriptor_1.alignment().concat(_descriptor_20.alignment());
+  }
+  fromValue(value_0) {
+    return {
+      is_some: _descriptor_1.fromValue(value_0),
+      value: _descriptor_20.fromValue(value_0)
+    }
+  }
+  toValue(value_0) {
+    return _descriptor_1.toValue(value_0.is_some).concat(_descriptor_20.toValue(value_0.value));
+  }
+}
+
+const _descriptor_23 = new _Maybe_1();
+
+const _descriptor_24 = new __compactRuntime.CompactTypeUnsignedInteger(255n, 1);
+
+const _descriptor_25 = new __compactRuntime.CompactTypeUnsignedInteger(4294967295n, 4);
+
+export class Contract {
+  witnesses;
+  constructor(...args_0) {
+    if (args_0.length !== 1) {
+      throw new __compactRuntime.CompactError(`Contract constructor: expected 1 argument, received ${args_0.length}`);
+    }
+    const witnesses_0 = args_0[0];
+    if (typeof(witnesses_0) !== 'object') {
+      throw new __compactRuntime.CompactError('first (witnesses) argument to Contract constructor is not an object');
+    }
+    this.witnesses = witnesses_0;
+    this.circuits = {
+      async creditColor(context, ...args_1) {
+        return { result: pureCircuits.creditColor(...args_1), context };
+      },
+      async deriveReceipt(context, ...args_1) {
+        return { result: pureCircuits.deriveReceipt(...args_1), context };
+      },
+      async deriveServiceId(context, ...args_1) {
+        return { result: pureCircuits.deriveServiceId(...args_1), context };
+      },
+      registerService: async (...args_1) => {
+        if (args_1.length !== 4) {
+          throw new __compactRuntime.CompactError(`registerService: expected 4 arguments (as invoked from Typescript), received ${args_1.length}`);
+        }
+        const contextOrig_0 = args_1[0];
+        const salt_0 = args_1[1];
+        const price_0 = args_1[2];
+        const owner_0 = args_1[3];
+        if (!(typeof(contextOrig_0) === 'object' && contextOrig_0.callContext.currentQueryContext != undefined)) {
+          __compactRuntime.typeError('registerService',
+                                     'argument 1 (as invoked from Typescript)',
+                                     'm402-vault.compact line 44 char 1',
+                                     'CircuitContext',
+                                     contextOrig_0)
+        }
+        if (!(salt_0.buffer instanceof ArrayBuffer && salt_0.BYTES_PER_ELEMENT === 1 && salt_0.length === 32)) {
+          __compactRuntime.typeError('registerService',
+                                     'argument 1 (argument 2 as invoked from Typescript)',
+                                     'm402-vault.compact line 44 char 1',
+                                     'Bytes<32>',
+                                     salt_0)
+        }
+        if (!(typeof(price_0) === 'bigint' && price_0 >= 0n && price_0 <= 18446744073709551615n)) {
+          __compactRuntime.typeError('registerService',
+                                     'argument 2 (argument 3 as invoked from Typescript)',
+                                     'm402-vault.compact line 44 char 1',
+                                     'Uint<0..18446744073709551616>',
+                                     price_0)
+        }
+        if (!(owner_0.buffer instanceof ArrayBuffer && owner_0.BYTES_PER_ELEMENT === 1 && owner_0.length === 32)) {
+          __compactRuntime.typeError('registerService',
+                                     'argument 3 (argument 4 as invoked from Typescript)',
+                                     'm402-vault.compact line 44 char 1',
+                                     'Bytes<32>',
+                                     owner_0)
+        }
+        const context = __compactRuntime.copyCircuitContext(contextOrig_0);
+        const partialProofData = {
+          input: {
+            value: _descriptor_0.toValue(salt_0).concat(_descriptor_2.toValue(price_0).concat(_descriptor_0.toValue(owner_0))),
+            alignment: _descriptor_0.alignment().concat(_descriptor_2.alignment().concat(_descriptor_0.alignment()))
+          },
+          output: undefined,
+          publicTranscript: [],
+          privateTranscriptOutputs: []
+        };
+        const result_0 = await this._registerService_0(context,
+                                                       partialProofData,
+                                                       salt_0,
+                                                       price_0,
+                                                       owner_0);
+        partialProofData.output = { value: [], alignment: [] };
+        __compactRuntime.finalizeCallProofData(context, partialProofData);
+        return { result: result_0, context: context, gasCost: context.callContext.currentGasCost };
+      },
+      deposit: async (...args_1) => {
+        if (args_1.length !== 3) {
+          throw new __compactRuntime.CompactError(`deposit: expected 3 arguments (as invoked from Typescript), received ${args_1.length}`);
+        }
+        const contextOrig_0 = args_1[0];
+        const amount_0 = args_1[1];
+        const nonceSeed_0 = args_1[2];
+        if (!(typeof(contextOrig_0) === 'object' && contextOrig_0.callContext.currentQueryContext != undefined)) {
+          __compactRuntime.typeError('deposit',
+                                     'argument 1 (as invoked from Typescript)',
+                                     'm402-vault.compact line 59 char 1',
+                                     'CircuitContext',
+                                     contextOrig_0)
+        }
+        if (!(typeof(amount_0) === 'bigint' && amount_0 >= 0n && amount_0 <= 18446744073709551615n)) {
+          __compactRuntime.typeError('deposit',
+                                     'argument 1 (argument 2 as invoked from Typescript)',
+                                     'm402-vault.compact line 59 char 1',
+                                     'Uint<0..18446744073709551616>',
+                                     amount_0)
+        }
+        if (!(nonceSeed_0.buffer instanceof ArrayBuffer && nonceSeed_0.BYTES_PER_ELEMENT === 1 && nonceSeed_0.length === 32)) {
+          __compactRuntime.typeError('deposit',
+                                     'argument 2 (argument 3 as invoked from Typescript)',
+                                     'm402-vault.compact line 59 char 1',
+                                     'Bytes<32>',
+                                     nonceSeed_0)
+        }
+        const context = __compactRuntime.copyCircuitContext(contextOrig_0);
+        const partialProofData = {
+          input: {
+            value: _descriptor_2.toValue(amount_0).concat(_descriptor_0.toValue(nonceSeed_0)),
+            alignment: _descriptor_2.alignment().concat(_descriptor_0.alignment())
+          },
+          output: undefined,
+          publicTranscript: [],
+          privateTranscriptOutputs: []
+        };
+        const result_0 = await this._deposit_0(context,
+                                               partialProofData,
+                                               amount_0,
+                                               nonceSeed_0);
+        partialProofData.output = { value: [], alignment: [] };
+        __compactRuntime.finalizeCallProofData(context, partialProofData);
+        return { result: result_0, context: context, gasCost: context.callContext.currentGasCost };
+      },
+      pay: async (...args_1) => {
+        if (args_1.length !== 4) {
+          throw new __compactRuntime.CompactError(`pay: expected 4 arguments (as invoked from Typescript), received ${args_1.length}`);
+        }
+        const contextOrig_0 = args_1[0];
+        const serviceId_0 = args_1[1];
+        const credit_0 = args_1[2];
+        const receiptSecret_0 = args_1[3];
+        if (!(typeof(contextOrig_0) === 'object' && contextOrig_0.callContext.currentQueryContext != undefined)) {
+          __compactRuntime.typeError('pay',
+                                     'argument 1 (as invoked from Typescript)',
+                                     'm402-vault.compact line 81 char 1',
+                                     'CircuitContext',
+                                     contextOrig_0)
+        }
+        if (!(serviceId_0.buffer instanceof ArrayBuffer && serviceId_0.BYTES_PER_ELEMENT === 1 && serviceId_0.length === 32)) {
+          __compactRuntime.typeError('pay',
+                                     'argument 1 (argument 2 as invoked from Typescript)',
+                                     'm402-vault.compact line 81 char 1',
+                                     'Bytes<32>',
+                                     serviceId_0)
+        }
+        if (!(typeof(credit_0) === 'object' && credit_0.nonce.buffer instanceof ArrayBuffer && credit_0.nonce.BYTES_PER_ELEMENT === 1 && credit_0.nonce.length === 32 && credit_0.color.buffer instanceof ArrayBuffer && credit_0.color.BYTES_PER_ELEMENT === 1 && credit_0.color.length === 32 && typeof(credit_0.value) === 'bigint' && credit_0.value >= 0n && credit_0.value <= 340282366920938463463374607431768211455n)) {
+          __compactRuntime.typeError('pay',
+                                     'argument 2 (argument 3 as invoked from Typescript)',
+                                     'm402-vault.compact line 81 char 1',
+                                     'struct ShieldedCoinInfo<nonce: Bytes<32>, color: Bytes<32>, value: Uint<0..340282366920938463463374607431768211456>>',
+                                     credit_0)
+        }
+        if (!(receiptSecret_0.buffer instanceof ArrayBuffer && receiptSecret_0.BYTES_PER_ELEMENT === 1 && receiptSecret_0.length === 32)) {
+          __compactRuntime.typeError('pay',
+                                     'argument 3 (argument 4 as invoked from Typescript)',
+                                     'm402-vault.compact line 81 char 1',
+                                     'Bytes<32>',
+                                     receiptSecret_0)
+        }
+        const context = __compactRuntime.copyCircuitContext(contextOrig_0);
+        const partialProofData = {
+          input: {
+            value: _descriptor_0.toValue(serviceId_0).concat(_descriptor_5.toValue(credit_0).concat(_descriptor_0.toValue(receiptSecret_0))),
+            alignment: _descriptor_0.alignment().concat(_descriptor_5.alignment().concat(_descriptor_0.alignment()))
+          },
+          output: undefined,
+          publicTranscript: [],
+          privateTranscriptOutputs: []
+        };
+        const result_0 = await this._pay_0(context,
+                                           partialProofData,
+                                           serviceId_0,
+                                           credit_0,
+                                           receiptSecret_0);
+        partialProofData.output = { value: [], alignment: [] };
+        __compactRuntime.finalizeCallProofData(context, partialProofData);
+        return { result: result_0, context: context, gasCost: context.callContext.currentGasCost };
+      },
+      redeem: async (...args_1) => {
+        if (args_1.length !== 3) {
+          throw new __compactRuntime.CompactError(`redeem: expected 3 arguments (as invoked from Typescript), received ${args_1.length}`);
+        }
+        const contextOrig_0 = args_1[0];
+        const recipient_0 = args_1[1];
+        const credit_0 = args_1[2];
+        if (!(typeof(contextOrig_0) === 'object' && contextOrig_0.callContext.currentQueryContext != undefined)) {
+          __compactRuntime.typeError('redeem',
+                                     'argument 1 (as invoked from Typescript)',
+                                     'm402-vault.compact line 104 char 1',
+                                     'CircuitContext',
+                                     contextOrig_0)
+        }
+        if (!(recipient_0.buffer instanceof ArrayBuffer && recipient_0.BYTES_PER_ELEMENT === 1 && recipient_0.length === 32)) {
+          __compactRuntime.typeError('redeem',
+                                     'argument 1 (argument 2 as invoked from Typescript)',
+                                     'm402-vault.compact line 104 char 1',
+                                     'Bytes<32>',
+                                     recipient_0)
+        }
+        if (!(typeof(credit_0) === 'object' && credit_0.nonce.buffer instanceof ArrayBuffer && credit_0.nonce.BYTES_PER_ELEMENT === 1 && credit_0.nonce.length === 32 && credit_0.color.buffer instanceof ArrayBuffer && credit_0.color.BYTES_PER_ELEMENT === 1 && credit_0.color.length === 32 && typeof(credit_0.value) === 'bigint' && credit_0.value >= 0n && credit_0.value <= 340282366920938463463374607431768211455n)) {
+          __compactRuntime.typeError('redeem',
+                                     'argument 2 (argument 3 as invoked from Typescript)',
+                                     'm402-vault.compact line 104 char 1',
+                                     'struct ShieldedCoinInfo<nonce: Bytes<32>, color: Bytes<32>, value: Uint<0..340282366920938463463374607431768211456>>',
+                                     credit_0)
+        }
+        const context = __compactRuntime.copyCircuitContext(contextOrig_0);
+        const partialProofData = {
+          input: {
+            value: _descriptor_0.toValue(recipient_0).concat(_descriptor_5.toValue(credit_0)),
+            alignment: _descriptor_0.alignment().concat(_descriptor_5.alignment())
+          },
+          output: undefined,
+          publicTranscript: [],
+          privateTranscriptOutputs: []
+        };
+        const result_0 = await this._redeem_0(context,
+                                              partialProofData,
+                                              recipient_0,
+                                              credit_0);
+        partialProofData.output = { value: [], alignment: [] };
+        __compactRuntime.finalizeCallProofData(context, partialProofData);
+        return { result: result_0, context: context, gasCost: context.callContext.currentGasCost };
+      },
+      withdraw: async (...args_1) => {
+        if (args_1.length !== 3) {
+          throw new __compactRuntime.CompactError(`withdraw: expected 3 arguments (as invoked from Typescript), received ${args_1.length}`);
+        }
+        const contextOrig_0 = args_1[0];
+        const serviceId_0 = args_1[1];
+        const amount_0 = args_1[2];
+        if (!(typeof(contextOrig_0) === 'object' && contextOrig_0.callContext.currentQueryContext != undefined)) {
+          __compactRuntime.typeError('withdraw',
+                                     'argument 1 (as invoked from Typescript)',
+                                     'm402-vault.compact line 118 char 1',
+                                     'CircuitContext',
+                                     contextOrig_0)
+        }
+        if (!(serviceId_0.buffer instanceof ArrayBuffer && serviceId_0.BYTES_PER_ELEMENT === 1 && serviceId_0.length === 32)) {
+          __compactRuntime.typeError('withdraw',
+                                     'argument 1 (argument 2 as invoked from Typescript)',
+                                     'm402-vault.compact line 118 char 1',
+                                     'Bytes<32>',
+                                     serviceId_0)
+        }
+        if (!(typeof(amount_0) === 'bigint' && amount_0 >= 0n && amount_0 <= 18446744073709551615n)) {
+          __compactRuntime.typeError('withdraw',
+                                     'argument 2 (argument 3 as invoked from Typescript)',
+                                     'm402-vault.compact line 118 char 1',
+                                     'Uint<0..18446744073709551616>',
+                                     amount_0)
+        }
+        const context = __compactRuntime.copyCircuitContext(contextOrig_0);
+        const partialProofData = {
+          input: {
+            value: _descriptor_0.toValue(serviceId_0).concat(_descriptor_2.toValue(amount_0)),
+            alignment: _descriptor_0.alignment().concat(_descriptor_2.alignment())
+          },
+          output: undefined,
+          publicTranscript: [],
+          privateTranscriptOutputs: []
+        };
+        const result_0 = await this._withdraw_0(context,
+                                                partialProofData,
+                                                serviceId_0,
+                                                amount_0);
+        partialProofData.output = { value: [], alignment: [] };
+        __compactRuntime.finalizeCallProofData(context, partialProofData);
+        return { result: result_0, context: context, gasCost: context.callContext.currentGasCost };
+      }
+    };
+    this.impureCircuits = {
+      registerService: this.circuits.registerService,
+      deposit: this.circuits.deposit,
+      pay: this.circuits.pay,
+      redeem: this.circuits.redeem,
+      withdraw: this.circuits.withdraw
+    };
+    this.provableCircuits = {
+      registerService: this.circuits.registerService,
+      deposit: this.circuits.deposit,
+      pay: this.circuits.pay,
+      redeem: this.circuits.redeem,
+      withdraw: this.circuits.withdraw
+    };
+  }
+  async initialState(...args_0) {
+    if (args_0.length !== 1) {
+      throw new __compactRuntime.CompactError(`Contract state constructor: expected 1 argument (as invoked from Typescript), received ${args_0.length}`);
+    }
+    const constructorContext_0 = args_0[0];
+    if (typeof(constructorContext_0) !== 'object') {
+      throw new __compactRuntime.CompactError(`Contract state constructor: expected 'constructorContext' in argument 1 (as invoked from Typescript) to be an object`);
+    }
+    if (!('initialZswapLocalState' in constructorContext_0)) {
+      throw new __compactRuntime.CompactError(`Contract state constructor: expected 'initialZswapLocalState' in argument 1 (as invoked from Typescript)`);
+    }
+    if (typeof(constructorContext_0.initialZswapLocalState) !== 'object') {
+      throw new __compactRuntime.CompactError(`Contract state constructor: expected 'initialZswapLocalState' in argument 1 (as invoked from Typescript) to be an object`);
+    }
+    const state_0 = new __compactRuntime.ContractState();
+    let stateValue_0 = __compactRuntime.StateValue.newArray();
+    stateValue_0 = stateValue_0.arrayPush(__compactRuntime.StateValue.newNull());
+    stateValue_0 = stateValue_0.arrayPush(__compactRuntime.StateValue.newNull());
+    stateValue_0 = stateValue_0.arrayPush(__compactRuntime.StateValue.newNull());
+    stateValue_0 = stateValue_0.arrayPush(__compactRuntime.StateValue.newNull());
+    stateValue_0 = stateValue_0.arrayPush(__compactRuntime.StateValue.newNull());
+    state_0.data = new __compactRuntime.ChargedState(stateValue_0);
+    state_0.setOperation('registerService', new __compactRuntime.ContractOperation());
+    state_0.setOperation('deposit', new __compactRuntime.ContractOperation());
+    state_0.setOperation('pay', new __compactRuntime.ContractOperation());
+    state_0.setOperation('redeem', new __compactRuntime.ContractOperation());
+    state_0.setOperation('withdraw', new __compactRuntime.ContractOperation());
+    const context = __compactRuntime.createCircuitContext({circuitId: 'constructor', contractAddress: __compactRuntime.dummyContractAddress(), coinPublicKeyOrZswapState: constructorContext_0.initialZswapLocalState.coinPublicKey, contractState: state_0.data, privateState: constructorContext_0.initialPrivateState});
+    const partialProofData = {
+      input: { value: [], alignment: [] },
+      output: undefined,
+      publicTranscript: [],
+      privateTranscriptOutputs: []
+    };
+    __compactRuntime.queryLedgerState(context,
+                                      partialProofData,
+                                      [
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_24.toValue(0n),
+                                                                                              alignment: _descriptor_24.alignment() }).encode() } },
+                                       { push: { storage: true,
+                                                 value: __compactRuntime.StateValue.newMap(
+                                                          new __compactRuntime.StateMap()
+                                                        ).encode() } },
+                                       { ins: { cached: false, n: 1 } }]);
+    __compactRuntime.queryLedgerState(context,
+                                      partialProofData,
+                                      [
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_24.toValue(1n),
+                                                                                              alignment: _descriptor_24.alignment() }).encode() } },
+                                       { push: { storage: true,
+                                                 value: __compactRuntime.StateValue.newMap(
+                                                          new __compactRuntime.StateMap()
+                                                        ).encode() } },
+                                       { ins: { cached: false, n: 1 } }]);
+    __compactRuntime.queryLedgerState(context,
+                                      partialProofData,
+                                      [
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_24.toValue(2n),
+                                                                                              alignment: _descriptor_24.alignment() }).encode() } },
+                                       { push: { storage: true,
+                                                 value: __compactRuntime.StateValue.newMap(
+                                                          new __compactRuntime.StateMap()
+                                                        ).encode() } },
+                                       { ins: { cached: false, n: 1 } }]);
+    __compactRuntime.queryLedgerState(context,
+                                      partialProofData,
+                                      [
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_24.toValue(3n),
+                                                                                              alignment: _descriptor_24.alignment() }).encode() } },
+                                       { push: { storage: true,
+                                                 value: __compactRuntime.StateValue.newMap(
+                                                          new __compactRuntime.StateMap()
+                                                        ).encode() } },
+                                       { ins: { cached: false, n: 1 } }]);
+    __compactRuntime.queryLedgerState(context,
+                                      partialProofData,
+                                      [
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_24.toValue(4n),
+                                                                                              alignment: _descriptor_24.alignment() }).encode() } },
+                                       { push: { storage: true,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_2.toValue(0n),
+                                                                                              alignment: _descriptor_2.alignment() }).encode() } },
+                                       { ins: { cached: false, n: 1 } }]);
+    state_0.data = new __compactRuntime.ChargedState(context.callContext.currentQueryContext.state.state);
+    return {
+      currentContractState: state_0,
+      currentPrivateState: context.callContext.currentPrivateState,
+      currentZswapLocalState: context.callContext.currentZswapLocalState
+    }
+  }
+  _some_0(value_0) { return { is_some: true, value: value_0 }; }
+  _none_0() {
+    return { is_some: false,
+             value:
+               { nonce: new Uint8Array(32), color: new Uint8Array(32), value: 0n } };
+  }
+  _left_0(value_0) {
+    return { is_left: true, left: value_0, right: { bytes: new Uint8Array(32) } };
+  }
+  _left_1(value_0) {
+    return { is_left: true, left: value_0, right: new Uint8Array(32) };
+  }
+  _right_0(value_0) {
+    return { is_left: false, left: { bytes: new Uint8Array(32) }, right: value_0 };
+  }
+  _right_1(value_0) {
+    return { is_left: false, left: { bytes: new Uint8Array(32) }, right: value_0 };
+  }
+  _nativeToken_0() {
+    return new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+  }
+  _tokenType_0(domain_sep_0, contractAddress_0) {
+    return this._persistentCommit_0([domain_sep_0, contractAddress_0.bytes],
+                                    new Uint8Array([109, 105, 100, 110, 105, 103, 104, 116, 58, 100, 101, 114, 105, 118, 101, 95, 116, 111, 107, 101, 110, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
+  }
+  async _mintShieldedToken_0(context,
+                             partialProofData,
+                             domain_sep_0,
+                             value_0,
+                             nonce_0,
+                             recipient_0)
+  {
+    const coin_0 = { nonce: nonce_0,
+                     color:
+                       this._tokenType_0(domain_sep_0,
+                                         _descriptor_3.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                                                   partialProofData,
+                                                                                                   [
+                                                                                                    { dup: { n: 2 } },
+                                                                                                    { idx: { cached: true,
+                                                                                                             pushPath: false,
+                                                                                                             path: [
+                                                                                                                    { tag: 'value',
+                                                                                                                      value: { value: _descriptor_24.toValue(0n),
+                                                                                                                               alignment: _descriptor_24.alignment() } }] } },
+                                                                                                    { popeq: { cached: true,
+                                                                                                               result: undefined } }]).value)),
+                     value: value_0 };
+    __compactRuntime.queryLedgerState(context,
+                                      partialProofData,
+                                      [
+                                       { swap: { n: 0 } },
+                                       { idx: { cached: true,
+                                                pushPath: true,
+                                                path: [
+                                                       { tag: 'value',
+                                                         value: { value: _descriptor_24.toValue(4n),
+                                                                  alignment: _descriptor_24.alignment() } }] } },
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(domain_sep_0),
+                                                                                              alignment: _descriptor_0.alignment() }).encode() } },
+                                       { dup: { n: 1 } },
+                                       { dup: { n: 1 } },
+                                       'member',
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_2.toValue(value_0),
+                                                                                              alignment: _descriptor_2.alignment() }).encode() } },
+                                       { swap: { n: 0 } },
+                                       'neg',
+                                       { branch: { skip: 4 } },
+                                       { dup: { n: 2 } },
+                                       { dup: { n: 2 } },
+                                       { idx: { cached: true,
+                                                pushPath: false,
+                                                path: [ { tag: 'stack' }] } },
+                                       'add',
+                                       { ins: { cached: true, n: 2 } },
+                                       { swap: { n: 0 } }]);
+    this._createZswapOutput_0(context, partialProofData, coin_0, recipient_0);
+    const cm_0 = this._coinCommitment_0(coin_0, recipient_0);
+    __compactRuntime.queryLedgerState(context,
+                                      partialProofData,
+                                      [
+                                       { swap: { n: 0 } },
+                                       { idx: { cached: true,
+                                                pushPath: true,
+                                                path: [
+                                                       { tag: 'value',
+                                                         value: { value: _descriptor_24.toValue(2n),
+                                                                  alignment: _descriptor_24.alignment() } }] } },
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(cm_0),
+                                                                                              alignment: _descriptor_0.alignment() }).encode() } },
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newNull().encode() } },
+                                       { ins: { cached: true, n: 2 } },
+                                       { swap: { n: 0 } }]);
+    if (!recipient_0.is_left
+        &&
+        this._equal_0(recipient_0.right.bytes,
+                      _descriptor_3.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                                partialProofData,
+                                                                                [
+                                                                                 { dup: { n: 2 } },
+                                                                                 { idx: { cached: true,
+                                                                                          pushPath: false,
+                                                                                          path: [
+                                                                                                 { tag: 'value',
+                                                                                                   value: { value: _descriptor_24.toValue(0n),
+                                                                                                            alignment: _descriptor_24.alignment() } }] } },
+                                                                                 { popeq: { cached: true,
+                                                                                            result: undefined } }]).value).bytes))
+    {
+      __compactRuntime.queryLedgerState(context,
+                                        partialProofData,
+                                        [
+                                         { swap: { n: 0 } },
+                                         { idx: { cached: true,
+                                                  pushPath: true,
+                                                  path: [
+                                                         { tag: 'value',
+                                                           value: { value: _descriptor_24.toValue(1n),
+                                                                    alignment: _descriptor_24.alignment() } }] } },
+                                         { push: { storage: false,
+                                                   value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(cm_0),
+                                                                                                alignment: _descriptor_0.alignment() }).encode() } },
+                                         { push: { storage: false,
+                                                   value: __compactRuntime.StateValue.newNull().encode() } },
+                                         { ins: { cached: true, n: 2 } },
+                                         { swap: { n: 0 } }]);
+    }
+    return coin_0;
+  }
+  _evolveNonce_0(index_0, nonce_0) {
+    return this._upgradeFromTransient_0(this._transientHash_0([__compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                                   28,
+                                                                                                   new Uint8Array([109, 105, 100, 110, 105, 103, 104, 116, 58, 107, 101, 114, 110, 101, 108, 58, 110, 111, 110, 99, 101, 95, 101, 118, 111, 108, 118, 101]),
+                                                                                                   'Field',
+                                                                                                   '<standard library>'),
+                                                               index_0,
+                                                               this._degradeToTransient_0(nonce_0)]));
+  }
+  async _receiveShielded_0(context, partialProofData, coin_0) {
+    const recipient_0 = this._right_0(_descriptor_3.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                                                partialProofData,
+                                                                                                [
+                                                                                                 { dup: { n: 2 } },
+                                                                                                 { idx: { cached: true,
+                                                                                                          pushPath: false,
+                                                                                                          path: [
+                                                                                                                 { tag: 'value',
+                                                                                                                   value: { value: _descriptor_24.toValue(0n),
+                                                                                                                            alignment: _descriptor_24.alignment() } }] } },
+                                                                                                 { popeq: { cached: true,
+                                                                                                            result: undefined } }]).value));
+    this._createZswapOutput_0(context, partialProofData, coin_0, recipient_0);
+    const tmp_0 = this._coinCommitment_0(coin_0, recipient_0);
+    __compactRuntime.queryLedgerState(context,
+                                      partialProofData,
+                                      [
+                                       { swap: { n: 0 } },
+                                       { idx: { cached: true,
+                                                pushPath: true,
+                                                path: [
+                                                       { tag: 'value',
+                                                         value: { value: _descriptor_24.toValue(1n),
+                                                                  alignment: _descriptor_24.alignment() } }] } },
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(tmp_0),
+                                                                                              alignment: _descriptor_0.alignment() }).encode() } },
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newNull().encode() } },
+                                       { ins: { cached: true, n: 2 } },
+                                       { swap: { n: 0 } }]);
+    return [];
+  }
+  async _sendShielded_0(context, partialProofData, input_0, recipient_0, value_0)
+  {
+    const selfAddr_0 = _descriptor_3.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                                 partialProofData,
+                                                                                 [
+                                                                                  { dup: { n: 2 } },
+                                                                                  { idx: { cached: true,
+                                                                                           pushPath: false,
+                                                                                           path: [
+                                                                                                  { tag: 'value',
+                                                                                                    value: { value: _descriptor_24.toValue(0n),
+                                                                                                             alignment: _descriptor_24.alignment() } }] } },
+                                                                                  { popeq: { cached: true,
+                                                                                             result: undefined } }]).value);
+    this._createZswapInput_0(context, partialProofData, input_0);
+    const tmp_0 = this._coinNullifier_0(this._downcastQualifiedCoin_0(input_0),
+                                        selfAddr_0);
+    __compactRuntime.queryLedgerState(context,
+                                      partialProofData,
+                                      [
+                                       { swap: { n: 0 } },
+                                       { idx: { cached: true,
+                                                pushPath: true,
+                                                path: [
+                                                       { tag: 'value',
+                                                         value: { value: _descriptor_24.toValue(0n),
+                                                                  alignment: _descriptor_24.alignment() } }] } },
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(tmp_0),
+                                                                                              alignment: _descriptor_0.alignment() }).encode() } },
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newNull().encode() } },
+                                       { ins: { cached: true, n: 2 } },
+                                       { swap: { n: 0 } }]);
+    let t_0;
+    const change_0 = (t_0 = input_0.value,
+                      (__compactRuntime.assert(t_0 >= value_0,
+                                               'result of subtraction would be negative'),
+                       t_0 - value_0));
+    const output_0 = { nonce:
+                         this._upgradeFromTransient_0(this._transientHash_1([__compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                                                 28,
+                                                                                                                 new Uint8Array([109, 105, 100, 110, 105, 103, 104, 116, 58, 107, 101, 114, 110, 101, 108, 58, 110, 111, 110, 99, 101, 95, 101, 118, 111, 108, 118, 101]),
+                                                                                                                 'Field',
+                                                                                                                 '<standard library>'),
+                                                                             this._degradeToTransient_0(input_0.nonce)])),
+                       color: input_0.color,
+                       value: value_0 };
+    this._createZswapOutput_0(context, partialProofData, output_0, recipient_0);
+    const tmp_1 = this._coinCommitment_0(output_0, recipient_0);
+    __compactRuntime.queryLedgerState(context,
+                                      partialProofData,
+                                      [
+                                       { swap: { n: 0 } },
+                                       { idx: { cached: true,
+                                                pushPath: true,
+                                                path: [
+                                                       { tag: 'value',
+                                                         value: { value: _descriptor_24.toValue(2n),
+                                                                  alignment: _descriptor_24.alignment() } }] } },
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(tmp_1),
+                                                                                              alignment: _descriptor_0.alignment() }).encode() } },
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newNull().encode() } },
+                                       { ins: { cached: true, n: 2 } },
+                                       { swap: { n: 0 } }]);
+    if (!recipient_0.is_left
+        &&
+        this._equal_1(recipient_0.right.bytes, selfAddr_0.bytes))
+    {
+      const tmp_2 = this._coinCommitment_0(output_0, recipient_0);
+      __compactRuntime.queryLedgerState(context,
+                                        partialProofData,
+                                        [
+                                         { swap: { n: 0 } },
+                                         { idx: { cached: true,
+                                                  pushPath: true,
+                                                  path: [
+                                                         { tag: 'value',
+                                                           value: { value: _descriptor_24.toValue(1n),
+                                                                    alignment: _descriptor_24.alignment() } }] } },
+                                         { push: { storage: false,
+                                                   value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(tmp_2),
+                                                                                                alignment: _descriptor_0.alignment() }).encode() } },
+                                         { push: { storage: false,
+                                                   value: __compactRuntime.StateValue.newNull().encode() } },
+                                         { ins: { cached: true, n: 2 } },
+                                         { swap: { n: 0 } }]);
+    }
+    if (change_0 === 0n) {
+      return { change: this._none_0(), sent: output_0 };
+    } else {
+      const changeCoin_0 = { nonce:
+                               this._upgradeFromTransient_0(this._transientHash_1([__compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                                                       30,
+                                                                                                                       new Uint8Array([109, 105, 100, 110, 105, 103, 104, 116, 58, 107, 101, 114, 110, 101, 108, 58, 110, 111, 110, 99, 101, 95, 101, 118, 111, 108, 118, 101, 47, 50]),
+                                                                                                                       'Field',
+                                                                                                                       '<standard library>'),
+                                                                                   this._degradeToTransient_0(input_0.nonce)])),
+                             color: input_0.color,
+                             value: change_0 };
+      this._createZswapOutput_0(context,
+                                partialProofData,
+                                changeCoin_0,
+                                this._right_0(selfAddr_0));
+      const cm_0 = this._coinCommitment_0(changeCoin_0,
+                                          this._right_0(selfAddr_0));
+      __compactRuntime.queryLedgerState(context,
+                                        partialProofData,
+                                        [
+                                         { swap: { n: 0 } },
+                                         { idx: { cached: true,
+                                                  pushPath: true,
+                                                  path: [
+                                                         { tag: 'value',
+                                                           value: { value: _descriptor_24.toValue(2n),
+                                                                    alignment: _descriptor_24.alignment() } }] } },
+                                         { push: { storage: false,
+                                                   value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(cm_0),
+                                                                                                alignment: _descriptor_0.alignment() }).encode() } },
+                                         { push: { storage: false,
+                                                   value: __compactRuntime.StateValue.newNull().encode() } },
+                                         { ins: { cached: true, n: 2 } },
+                                         { swap: { n: 0 } }]);
+      __compactRuntime.queryLedgerState(context,
+                                        partialProofData,
+                                        [
+                                         { swap: { n: 0 } },
+                                         { idx: { cached: true,
+                                                  pushPath: true,
+                                                  path: [
+                                                         { tag: 'value',
+                                                           value: { value: _descriptor_24.toValue(1n),
+                                                                    alignment: _descriptor_24.alignment() } }] } },
+                                         { push: { storage: false,
+                                                   value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(cm_0),
+                                                                                                alignment: _descriptor_0.alignment() }).encode() } },
+                                         { push: { storage: false,
+                                                   value: __compactRuntime.StateValue.newNull().encode() } },
+                                         { ins: { cached: true, n: 2 } },
+                                         { swap: { n: 0 } }]);
+      return { change: this._some_0(changeCoin_0), sent: output_0 };
+    }
+  }
+  async _sendImmediateShielded_0(context,
+                                 partialProofData,
+                                 input_0,
+                                 target_0,
+                                 value_0)
+  {
+    return await this._sendShielded_0(context,
+                                      partialProofData,
+                                      this._upcastQualifiedCoin_0(input_0),
+                                      target_0,
+                                      value_0);
+  }
+  _downcastQualifiedCoin_0(coin_0) {
+    return { nonce: coin_0.nonce, color: coin_0.color, value: coin_0.value };
+  }
+  _upcastQualifiedCoin_0(coin_0) {
+    return { nonce: coin_0.nonce,
+             color: coin_0.color,
+             value: coin_0.value,
+             mt_index: 0n };
+  }
+  _coinCommitment_0(coin_0, recipient_0) {
+    return this._persistentHash_2({ domain_sep:
+                                      new Uint8Array([109, 105, 100, 110, 105, 103, 104, 116, 58, 122, 115, 119, 97, 112, 45, 99, 99, 91, 118, 49, 93]),
+                                    info: coin_0,
+                                    dataType: recipient_0.is_left,
+                                    data:
+                                      recipient_0.is_left ?
+                                      recipient_0.left.bytes :
+                                      recipient_0.right.bytes });
+  }
+  _coinNullifier_0(coin_0, addr_0) {
+    return this._persistentHash_2({ domain_sep:
+                                      new Uint8Array([109, 105, 100, 110, 105, 103, 104, 116, 58, 122, 115, 119, 97, 112, 45, 99, 110, 91, 118, 49, 93]),
+                                    info: coin_0,
+                                    dataType: false,
+                                    data: addr_0.bytes });
+  }
+  async _sendUnshielded_0(context,
+                          partialProofData,
+                          color_0,
+                          amount_0,
+                          recipient_0)
+  {
+    const tmp_0 = this._left_1(color_0);
+    __compactRuntime.queryLedgerState(context,
+                                      partialProofData,
+                                      [
+                                       { swap: { n: 0 } },
+                                       { idx: { cached: true,
+                                                pushPath: true,
+                                                path: [
+                                                       { tag: 'value',
+                                                         value: { value: _descriptor_24.toValue(7n),
+                                                                  alignment: _descriptor_24.alignment() } }] } },
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_17.toValue(tmp_0),
+                                                                                              alignment: _descriptor_17.alignment() }).encode() } },
+                                       { dup: { n: 1 } },
+                                       { dup: { n: 1 } },
+                                       'member',
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_4.toValue(amount_0),
+                                                                                              alignment: _descriptor_4.alignment() }).encode() } },
+                                       { swap: { n: 0 } },
+                                       'neg',
+                                       { branch: { skip: 4 } },
+                                       { dup: { n: 2 } },
+                                       { dup: { n: 2 } },
+                                       { idx: { cached: true,
+                                                pushPath: false,
+                                                path: [ { tag: 'stack' }] } },
+                                       'add',
+                                       { ins: { cached: true, n: 2 } },
+                                       { swap: { n: 0 } }]);
+    const tmp_1 = this._left_1(color_0);
+    __compactRuntime.queryLedgerState(context,
+                                      partialProofData,
+                                      [
+                                       { swap: { n: 0 } },
+                                       { idx: { cached: true,
+                                                pushPath: true,
+                                                path: [
+                                                       { tag: 'value',
+                                                         value: { value: _descriptor_24.toValue(8n),
+                                                                  alignment: _descriptor_24.alignment() } }] } },
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newCell(__compactRuntime.alignedConcat(
+                                                                                              { value: _descriptor_17.toValue(tmp_1),
+                                                                                                alignment: _descriptor_17.alignment() },
+                                                                                              { value: _descriptor_20.toValue(recipient_0),
+                                                                                                alignment: _descriptor_20.alignment() }
+                                                                                            )).encode() } },
+                                       { dup: { n: 1 } },
+                                       { dup: { n: 1 } },
+                                       'member',
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_4.toValue(amount_0),
+                                                                                              alignment: _descriptor_4.alignment() }).encode() } },
+                                       { swap: { n: 0 } },
+                                       'neg',
+                                       { branch: { skip: 4 } },
+                                       { dup: { n: 2 } },
+                                       { dup: { n: 2 } },
+                                       { idx: { cached: true,
+                                                pushPath: false,
+                                                path: [ { tag: 'stack' }] } },
+                                       'add',
+                                       { ins: { cached: true, n: 2 } },
+                                       { swap: { n: 0 } }]);
+    if (recipient_0.is_left
+        &&
+        this._equal_2(recipient_0.left.bytes,
+                      _descriptor_3.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                                partialProofData,
+                                                                                [
+                                                                                 { dup: { n: 2 } },
+                                                                                 { idx: { cached: true,
+                                                                                          pushPath: false,
+                                                                                          path: [
+                                                                                                 { tag: 'value',
+                                                                                                   value: { value: _descriptor_24.toValue(0n),
+                                                                                                            alignment: _descriptor_24.alignment() } }] } },
+                                                                                 { popeq: { cached: true,
+                                                                                            result: undefined } }]).value).bytes))
+    {
+      const tmp_2 = this._left_1(color_0);
+      __compactRuntime.queryLedgerState(context,
+                                        partialProofData,
+                                        [
+                                         { swap: { n: 0 } },
+                                         { idx: { cached: true,
+                                                  pushPath: true,
+                                                  path: [
+                                                         { tag: 'value',
+                                                           value: { value: _descriptor_24.toValue(6n),
+                                                                    alignment: _descriptor_24.alignment() } }] } },
+                                         { push: { storage: false,
+                                                   value: __compactRuntime.StateValue.newCell({ value: _descriptor_17.toValue(tmp_2),
+                                                                                                alignment: _descriptor_17.alignment() }).encode() } },
+                                         { dup: { n: 1 } },
+                                         { dup: { n: 1 } },
+                                         'member',
+                                         { push: { storage: false,
+                                                   value: __compactRuntime.StateValue.newCell({ value: _descriptor_4.toValue(amount_0),
+                                                                                                alignment: _descriptor_4.alignment() }).encode() } },
+                                         { swap: { n: 0 } },
+                                         'neg',
+                                         { branch: { skip: 4 } },
+                                         { dup: { n: 2 } },
+                                         { dup: { n: 2 } },
+                                         { idx: { cached: true,
+                                                  pushPath: false,
+                                                  path: [ { tag: 'stack' }] } },
+                                         'add',
+                                         { ins: { cached: true, n: 2 } },
+                                         { swap: { n: 0 } }]);
+    }
+    return [];
+  }
+  async _receiveUnshielded_0(context, partialProofData, color_0, amount_0) {
+    const tmp_0 = this._left_1(color_0);
+    __compactRuntime.queryLedgerState(context,
+                                      partialProofData,
+                                      [
+                                       { swap: { n: 0 } },
+                                       { idx: { cached: true,
+                                                pushPath: true,
+                                                path: [
+                                                       { tag: 'value',
+                                                         value: { value: _descriptor_24.toValue(6n),
+                                                                  alignment: _descriptor_24.alignment() } }] } },
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_17.toValue(tmp_0),
+                                                                                              alignment: _descriptor_17.alignment() }).encode() } },
+                                       { dup: { n: 1 } },
+                                       { dup: { n: 1 } },
+                                       'member',
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_4.toValue(amount_0),
+                                                                                              alignment: _descriptor_4.alignment() }).encode() } },
+                                       { swap: { n: 0 } },
+                                       'neg',
+                                       { branch: { skip: 4 } },
+                                       { dup: { n: 2 } },
+                                       { dup: { n: 2 } },
+                                       { idx: { cached: true,
+                                                pushPath: false,
+                                                path: [ { tag: 'stack' }] } },
+                                       'add',
+                                       { ins: { cached: true, n: 2 } },
+                                       { swap: { n: 0 } }]);
+    return [];
+  }
+  _transientHash_0(value_0) {
+    const result_0 = __compactRuntime.transientHash(_descriptor_18, value_0);
+    return result_0;
+  }
+  _transientHash_1(value_0) {
+    const result_0 = __compactRuntime.transientHash(_descriptor_15, value_0);
+    return result_0;
+  }
+  _persistentHash_0(value_0) {
+    const result_0 = __compactRuntime.persistentHash(_descriptor_16, value_0);
+    return result_0;
+  }
+  _persistentHash_1(value_0) {
+    const result_0 = __compactRuntime.persistentHash(_descriptor_12, value_0);
+    return result_0;
+  }
+  _persistentHash_2(value_0) {
+    const result_0 = __compactRuntime.persistentHash(_descriptor_14, value_0);
+    return result_0;
+  }
+  _persistentCommit_0(value_0, rand_0) {
+    const result_0 = __compactRuntime.persistentCommit(_descriptor_11,
+                                                       value_0,
+                                                       rand_0);
+    return result_0;
+  }
+  _degradeToTransient_0(x_0) {
+    const result_0 = __compactRuntime.degradeToTransient(x_0);
+    return result_0;
+  }
+  _upgradeFromTransient_0(x_0) {
+    const result_0 = __compactRuntime.upgradeFromTransient(x_0);
+    return result_0;
+  }
+  _ownPublicKey_0(context, partialProofData) {
+    const result_0 = __compactRuntime.ownPublicKey(context);
+    partialProofData.privateTranscriptOutputs.push({
+      value: _descriptor_8.toValue(result_0),
+      alignment: _descriptor_8.alignment()
+    });
+    return result_0;
+  }
+  _createZswapInput_0(context, partialProofData, coin_0) {
+    const result_0 = __compactRuntime.createZswapInput(context, coin_0);
+    partialProofData.privateTranscriptOutputs.push({
+      value: [],
+      alignment: []
+    });
+    return result_0;
+  }
+  _createZswapOutput_0(context, partialProofData, coin_0, recipient_0) {
+    const result_0 = __compactRuntime.createZswapOutput(context,
+                                                        coin_0,
+                                                        recipient_0);
+    partialProofData.privateTranscriptOutputs.push({
+      value: [],
+      alignment: []
+    });
+    return result_0;
+  }
+  _creditDomain_0() {
+    return new Uint8Array([109, 52, 48, 50, 58, 99, 114, 101, 100, 105, 116, 58, 118, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+  }
+  _creditColor_0(self_0) {
+    return this._tokenType_0(this._creditDomain_0(), self_0);
+  }
+  _deriveReceipt_0(secret_0, serviceId_0) {
+    return this._persistentHash_0([new Uint8Array([109, 52, 48, 50, 58, 114, 101, 99, 101, 105, 112, 116, 58, 118, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+                                   secret_0,
+                                   serviceId_0]);
+  }
+  _deriveServiceId_0(owner_0, salt_0, price_0) {
+    return this._persistentHash_1([new Uint8Array([109, 52, 48, 50, 58, 115, 105, 100, 58, 118, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+                                   owner_0,
+                                   salt_0,
+                                   __compactRuntime.convertBigintToBytes(32,
+                                                                         price_0,
+                                                                         'm402-vault.compact line 40 char 43')]);
+  }
+  async _registerService_0(context, partialProofData, salt_0, price_0, owner_0)
+  {
+    __compactRuntime.assert(price_0 > 0n, 'price must be positive');
+    __compactRuntime.assert(!this._equal_3(owner_0,
+                                           new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])),
+                            'owner must be set');
+    const serviceId_0 = this._deriveServiceId_0(owner_0, salt_0, price_0);
+    __compactRuntime.assert(!_descriptor_1.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                                       partialProofData,
+                                                                                       [
+                                                                                        { dup: { n: 0 } },
+                                                                                        { idx: { cached: false,
+                                                                                                 pushPath: false,
+                                                                                                 path: [
+                                                                                                        { tag: 'value',
+                                                                                                          value: { value: _descriptor_24.toValue(0n),
+                                                                                                                   alignment: _descriptor_24.alignment() } }] } },
+                                                                                        { push: { storage: false,
+                                                                                                  value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(serviceId_0),
+                                                                                                                                               alignment: _descriptor_0.alignment() }).encode() } },
+                                                                                        'member',
+                                                                                        { popeq: { cached: true,
+                                                                                                   result: undefined } }]).value),
+                            'already registered');
+    __compactRuntime.assert(!_descriptor_1.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                                       partialProofData,
+                                                                                       [
+                                                                                        { dup: { n: 0 } },
+                                                                                        { idx: { cached: false,
+                                                                                                 pushPath: false,
+                                                                                                 path: [
+                                                                                                        { tag: 'value',
+                                                                                                          value: { value: _descriptor_24.toValue(1n),
+                                                                                                                   alignment: _descriptor_24.alignment() } }] } },
+                                                                                        { push: { storage: false,
+                                                                                                  value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(serviceId_0),
+                                                                                                                                               alignment: _descriptor_0.alignment() }).encode() } },
+                                                                                        'member',
+                                                                                        { popeq: { cached: true,
+                                                                                                   result: undefined } }]).value),
+                            'already registered');
+    __compactRuntime.queryLedgerState(context,
+                                      partialProofData,
+                                      [
+                                       { idx: { cached: false,
+                                                pushPath: true,
+                                                path: [
+                                                       { tag: 'value',
+                                                         value: { value: _descriptor_24.toValue(0n),
+                                                                  alignment: _descriptor_24.alignment() } }] } },
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(serviceId_0),
+                                                                                              alignment: _descriptor_0.alignment() }).encode() } },
+                                       { push: { storage: true,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_2.toValue(price_0),
+                                                                                              alignment: _descriptor_2.alignment() }).encode() } },
+                                       { ins: { cached: false, n: 1 } },
+                                       { ins: { cached: true, n: 1 } }]);
+    __compactRuntime.queryLedgerState(context,
+                                      partialProofData,
+                                      [
+                                       { idx: { cached: false,
+                                                pushPath: true,
+                                                path: [
+                                                       { tag: 'value',
+                                                         value: { value: _descriptor_24.toValue(1n),
+                                                                  alignment: _descriptor_24.alignment() } }] } },
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(serviceId_0),
+                                                                                              alignment: _descriptor_0.alignment() }).encode() } },
+                                       { push: { storage: true,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(owner_0),
+                                                                                              alignment: _descriptor_0.alignment() }).encode() } },
+                                       { ins: { cached: false, n: 1 } },
+                                       { ins: { cached: true, n: 1 } }]);
+    return [];
+  }
+  async _deposit_0(context, partialProofData, amount_0, nonceSeed_0) {
+    __compactRuntime.assert(amount_0 > 0n, 'amount must be positive');
+    await this._receiveUnshielded_0(context,
+                                    partialProofData,
+                                    this._nativeToken_0(),
+                                    amount_0);
+    const nonce_0 = this._evolveNonce_0(((t1) => {
+                                          if (t1 > 18446744073709551615n) {
+                                            throw new __compactRuntime.CompactError('m402-vault.compact line 63 char 38: cast from Field or Uint value to smaller Uint value failed: ' + t1 + ' is greater than 18446744073709551615');
+                                          }
+                                          return t1;
+                                        })(_descriptor_2.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                                                     partialProofData,
+                                                                                                     [
+                                                                                                      { dup: { n: 0 } },
+                                                                                                      { idx: { cached: false,
+                                                                                                               pushPath: false,
+                                                                                                               path: [
+                                                                                                                      { tag: 'value',
+                                                                                                                        value: { value: _descriptor_24.toValue(4n),
+                                                                                                                                 alignment: _descriptor_24.alignment() } }] } },
+                                                                                                      { popeq: { cached: true,
+                                                                                                                 result: undefined } }]).value)),
+                                        nonceSeed_0);
+    const coin_0 = await this._mintShieldedToken_0(context,
+                                                   partialProofData,
+                                                   this._creditDomain_0(),
+                                                   amount_0,
+                                                   nonce_0,
+                                                   this._right_0(_descriptor_3.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                                                                           partialProofData,
+                                                                                                                           [
+                                                                                                                            { dup: { n: 2 } },
+                                                                                                                            { idx: { cached: true,
+                                                                                                                                     pushPath: false,
+                                                                                                                                     path: [
+                                                                                                                                            { tag: 'value',
+                                                                                                                                              value: { value: _descriptor_24.toValue(0n),
+                                                                                                                                                       alignment: _descriptor_24.alignment() } }] } },
+                                                                                                                            { popeq: { cached: true,
+                                                                                                                                       result: undefined } }]).value)));
+    await this._sendImmediateShielded_0(context,
+                                        partialProofData,
+                                        coin_0,
+                                        this._left_0(this._ownPublicKey_0(context,
+                                                                          partialProofData)),
+                                        coin_0.value);
+    const tmp_0 = 1n;
+    __compactRuntime.queryLedgerState(context,
+                                      partialProofData,
+                                      [
+                                       { idx: { cached: false,
+                                                pushPath: true,
+                                                path: [
+                                                       { tag: 'value',
+                                                         value: { value: _descriptor_24.toValue(4n),
+                                                                  alignment: _descriptor_24.alignment() } }] } },
+                                       { addi: { immediate: parseInt(__compactRuntime.valueToBigInt(
+                                                              { value: _descriptor_6.toValue(tmp_0),
+                                                                alignment: _descriptor_6.alignment() }
+                                                                .value
+                                                            )) } },
+                                       { ins: { cached: true, n: 1 } }]);
+    return [];
+  }
+  async _pay_0(context, partialProofData, serviceId_0, credit_0, receiptSecret_0)
+  {
+    const sid_0 = serviceId_0;
+    __compactRuntime.assert(_descriptor_1.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                                      partialProofData,
+                                                                                      [
+                                                                                       { dup: { n: 0 } },
+                                                                                       { idx: { cached: false,
+                                                                                                pushPath: false,
+                                                                                                path: [
+                                                                                                       { tag: 'value',
+                                                                                                         value: { value: _descriptor_24.toValue(0n),
+                                                                                                                  alignment: _descriptor_24.alignment() } }] } },
+                                                                                       { push: { storage: false,
+                                                                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(sid_0),
+                                                                                                                                              alignment: _descriptor_0.alignment() }).encode() } },
+                                                                                       'member',
+                                                                                       { popeq: { cached: true,
+                                                                                                  result: undefined } }]).value),
+                            'unknown service');
+    const price_0 = _descriptor_2.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                              partialProofData,
+                                                                              [
+                                                                               { dup: { n: 0 } },
+                                                                               { idx: { cached: false,
+                                                                                        pushPath: false,
+                                                                                        path: [
+                                                                                               { tag: 'value',
+                                                                                                 value: { value: _descriptor_24.toValue(0n),
+                                                                                                          alignment: _descriptor_24.alignment() } }] } },
+                                                                               { idx: { cached: false,
+                                                                                        pushPath: false,
+                                                                                        path: [
+                                                                                               { tag: 'value',
+                                                                                                 value: { value: _descriptor_0.toValue(sid_0),
+                                                                                                          alignment: _descriptor_0.alignment() } }] } },
+                                                                               { popeq: { cached: false,
+                                                                                          result: undefined } }]).value);
+    __compactRuntime.assert(this._equal_4(credit_0.color,
+                                          this._tokenType_0(this._creditDomain_0(),
+                                                            _descriptor_3.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                                                                      partialProofData,
+                                                                                                                      [
+                                                                                                                       { dup: { n: 2 } },
+                                                                                                                       { idx: { cached: true,
+                                                                                                                                pushPath: false,
+                                                                                                                                path: [
+                                                                                                                                       { tag: 'value',
+                                                                                                                                         value: { value: _descriptor_24.toValue(0n),
+                                                                                                                                                  alignment: _descriptor_24.alignment() } }] } },
+                                                                                                                       { popeq: { cached: true,
+                                                                                                                                  result: undefined } }]).value))),
+                            'not an m402 credit');
+    __compactRuntime.assert(credit_0.value === price_0, 'wrong amount');
+    const receipt_0 = this._deriveReceipt_0(receiptSecret_0, sid_0);
+    __compactRuntime.assert(!_descriptor_1.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                                       partialProofData,
+                                                                                       [
+                                                                                        { dup: { n: 0 } },
+                                                                                        { idx: { cached: false,
+                                                                                                 pushPath: false,
+                                                                                                 path: [
+                                                                                                        { tag: 'value',
+                                                                                                          value: { value: _descriptor_24.toValue(2n),
+                                                                                                                   alignment: _descriptor_24.alignment() } }] } },
+                                                                                        { push: { storage: false,
+                                                                                                  value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(receipt_0),
+                                                                                                                                               alignment: _descriptor_0.alignment() }).encode() } },
+                                                                                        'member',
+                                                                                        { popeq: { cached: true,
+                                                                                                   result: undefined } }]).value),
+                            'receipt reused');
+    await this._receiveShielded_0(context, partialProofData, credit_0);
+    __compactRuntime.queryLedgerState(context,
+                                      partialProofData,
+                                      [
+                                       { idx: { cached: false,
+                                                pushPath: true,
+                                                path: [
+                                                       { tag: 'value',
+                                                         value: { value: _descriptor_24.toValue(2n),
+                                                                  alignment: _descriptor_24.alignment() } }] } },
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(receipt_0),
+                                                                                              alignment: _descriptor_0.alignment() }).encode() } },
+                                       { push: { storage: true,
+                                                 value: __compactRuntime.StateValue.newNull().encode() } },
+                                       { ins: { cached: false, n: 1 } },
+                                       { ins: { cached: true, n: 1 } }]);
+    const owner_0 = _descriptor_0.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                              partialProofData,
+                                                                              [
+                                                                               { dup: { n: 0 } },
+                                                                               { idx: { cached: false,
+                                                                                        pushPath: false,
+                                                                                        path: [
+                                                                                               { tag: 'value',
+                                                                                                 value: { value: _descriptor_24.toValue(1n),
+                                                                                                          alignment: _descriptor_24.alignment() } }] } },
+                                                                               { idx: { cached: false,
+                                                                                        pushPath: false,
+                                                                                        path: [
+                                                                                               { tag: 'value',
+                                                                                                 value: { value: _descriptor_0.toValue(sid_0),
+                                                                                                          alignment: _descriptor_0.alignment() } }] } },
+                                                                               { popeq: { cached: false,
+                                                                                          result: undefined } }]).value);
+    const prior_0 = _descriptor_1.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                              partialProofData,
+                                                                              [
+                                                                               { dup: { n: 0 } },
+                                                                               { idx: { cached: false,
+                                                                                        pushPath: false,
+                                                                                        path: [
+                                                                                               { tag: 'value',
+                                                                                                 value: { value: _descriptor_24.toValue(3n),
+                                                                                                          alignment: _descriptor_24.alignment() } }] } },
+                                                                               { push: { storage: false,
+                                                                                         value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(owner_0),
+                                                                                                                                      alignment: _descriptor_0.alignment() }).encode() } },
+                                                                               'member',
+                                                                               { popeq: { cached: true,
+                                                                                          result: undefined } }]).value)
+                    ?
+                    _descriptor_2.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                              partialProofData,
+                                                                              [
+                                                                               { dup: { n: 0 } },
+                                                                               { idx: { cached: false,
+                                                                                        pushPath: false,
+                                                                                        path: [
+                                                                                               { tag: 'value',
+                                                                                                 value: { value: _descriptor_24.toValue(3n),
+                                                                                                          alignment: _descriptor_24.alignment() } }] } },
+                                                                               { idx: { cached: false,
+                                                                                        pushPath: false,
+                                                                                        path: [
+                                                                                               { tag: 'value',
+                                                                                                 value: { value: _descriptor_0.toValue(owner_0),
+                                                                                                          alignment: _descriptor_0.alignment() } }] } },
+                                                                               { popeq: { cached: false,
+                                                                                          result: undefined } }]).value)
+                    :
+                    0n;
+    const tmp_0 = ((t1) => {
+                    if (t1 > 18446744073709551615n) {
+                      throw new __compactRuntime.CompactError('m402-vault.compact line 99 char 33: cast from Field or Uint value to smaller Uint value failed: ' + t1 + ' is greater than 18446744073709551615');
+                    }
+                    return t1;
+                  })(prior_0 + price_0);
+    __compactRuntime.queryLedgerState(context,
+                                      partialProofData,
+                                      [
+                                       { idx: { cached: false,
+                                                pushPath: true,
+                                                path: [
+                                                       { tag: 'value',
+                                                         value: { value: _descriptor_24.toValue(3n),
+                                                                  alignment: _descriptor_24.alignment() } }] } },
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(owner_0),
+                                                                                              alignment: _descriptor_0.alignment() }).encode() } },
+                                       { push: { storage: true,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_2.toValue(tmp_0),
+                                                                                              alignment: _descriptor_2.alignment() }).encode() } },
+                                       { ins: { cached: false, n: 1 } },
+                                       { ins: { cached: true, n: 1 } }]);
+    return [];
+  }
+  async _redeem_0(context, partialProofData, recipient_0, credit_0) {
+    __compactRuntime.assert(!this._equal_5(recipient_0,
+                                           new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])),
+                            'recipient must be set');
+    __compactRuntime.assert(this._equal_6(credit_0.color,
+                                          this._tokenType_0(this._creditDomain_0(),
+                                                            _descriptor_3.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                                                                      partialProofData,
+                                                                                                                      [
+                                                                                                                       { dup: { n: 2 } },
+                                                                                                                       { idx: { cached: true,
+                                                                                                                                pushPath: false,
+                                                                                                                                path: [
+                                                                                                                                       { tag: 'value',
+                                                                                                                                         value: { value: _descriptor_24.toValue(0n),
+                                                                                                                                                  alignment: _descriptor_24.alignment() } }] } },
+                                                                                                                       { popeq: { cached: true,
+                                                                                                                                  result: undefined } }]).value))),
+                            'not an m402 credit');
+    let t_0;
+    __compactRuntime.assert((t_0 = credit_0.value, t_0 > 0n),
+                            'nothing to redeem');
+    await this._receiveShielded_0(context, partialProofData, credit_0);
+    await this._sendUnshielded_0(context,
+                                 partialProofData,
+                                 this._nativeToken_0(),
+                                 credit_0.value,
+                                 this._right_1({ bytes: recipient_0 }));
+    return [];
+  }
+  async _withdraw_0(context, partialProofData, serviceId_0, amount_0) {
+    const sid_0 = serviceId_0;
+    __compactRuntime.assert(amount_0 > 0n, 'amount must be positive');
+    __compactRuntime.assert(_descriptor_1.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                                      partialProofData,
+                                                                                      [
+                                                                                       { dup: { n: 0 } },
+                                                                                       { idx: { cached: false,
+                                                                                                pushPath: false,
+                                                                                                path: [
+                                                                                                       { tag: 'value',
+                                                                                                         value: { value: _descriptor_24.toValue(1n),
+                                                                                                                  alignment: _descriptor_24.alignment() } }] } },
+                                                                                       { push: { storage: false,
+                                                                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(sid_0),
+                                                                                                                                              alignment: _descriptor_0.alignment() }).encode() } },
+                                                                                       'member',
+                                                                                       { popeq: { cached: true,
+                                                                                                  result: undefined } }]).value),
+                            'unknown service');
+    const owner_0 = _descriptor_0.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                              partialProofData,
+                                                                              [
+                                                                               { dup: { n: 0 } },
+                                                                               { idx: { cached: false,
+                                                                                        pushPath: false,
+                                                                                        path: [
+                                                                                               { tag: 'value',
+                                                                                                 value: { value: _descriptor_24.toValue(1n),
+                                                                                                          alignment: _descriptor_24.alignment() } }] } },
+                                                                               { idx: { cached: false,
+                                                                                        pushPath: false,
+                                                                                        path: [
+                                                                                               { tag: 'value',
+                                                                                                 value: { value: _descriptor_0.toValue(sid_0),
+                                                                                                          alignment: _descriptor_0.alignment() } }] } },
+                                                                               { popeq: { cached: false,
+                                                                                          result: undefined } }]).value);
+    __compactRuntime.assert(_descriptor_1.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                                      partialProofData,
+                                                                                      [
+                                                                                       { dup: { n: 0 } },
+                                                                                       { idx: { cached: false,
+                                                                                                pushPath: false,
+                                                                                                path: [
+                                                                                                       { tag: 'value',
+                                                                                                         value: { value: _descriptor_24.toValue(3n),
+                                                                                                                  alignment: _descriptor_24.alignment() } }] } },
+                                                                                       { push: { storage: false,
+                                                                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(owner_0),
+                                                                                                                                              alignment: _descriptor_0.alignment() }).encode() } },
+                                                                                       'member',
+                                                                                       { popeq: { cached: true,
+                                                                                                  result: undefined } }]).value),
+                            'no balance');
+    const balance_0 = _descriptor_2.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                                partialProofData,
+                                                                                [
+                                                                                 { dup: { n: 0 } },
+                                                                                 { idx: { cached: false,
+                                                                                          pushPath: false,
+                                                                                          path: [
+                                                                                                 { tag: 'value',
+                                                                                                   value: { value: _descriptor_24.toValue(3n),
+                                                                                                            alignment: _descriptor_24.alignment() } }] } },
+                                                                                 { idx: { cached: false,
+                                                                                          pushPath: false,
+                                                                                          path: [
+                                                                                                 { tag: 'value',
+                                                                                                   value: { value: _descriptor_0.toValue(owner_0),
+                                                                                                            alignment: _descriptor_0.alignment() } }] } },
+                                                                                 { popeq: { cached: false,
+                                                                                            result: undefined } }]).value);
+    __compactRuntime.assert(balance_0 >= amount_0, 'insufficient balance');
+    await this._sendUnshielded_0(context,
+                                 partialProofData,
+                                 this._nativeToken_0(),
+                                 amount_0,
+                                 this._right_1({ bytes: owner_0 }));
+    let t_0;
+    const tmp_0 = (t_0 = amount_0,
+                   (__compactRuntime.assert(balance_0 >= t_0,
+                                            'result of subtraction would be negative'),
+                    balance_0 - t_0));
+    __compactRuntime.queryLedgerState(context,
+                                      partialProofData,
+                                      [
+                                       { idx: { cached: false,
+                                                pushPath: true,
+                                                path: [
+                                                       { tag: 'value',
+                                                         value: { value: _descriptor_24.toValue(3n),
+                                                                  alignment: _descriptor_24.alignment() } }] } },
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(owner_0),
+                                                                                              alignment: _descriptor_0.alignment() }).encode() } },
+                                       { push: { storage: true,
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_2.toValue(tmp_0),
+                                                                                              alignment: _descriptor_2.alignment() }).encode() } },
+                                       { ins: { cached: false, n: 1 } },
+                                       { ins: { cached: true, n: 1 } }]);
+    return [];
+  }
+  _equal_0(x0, y0) {
+    if (!x0.every((x, i) => y0[i] === x)) { return false; }
+    return true;
+  }
+  _equal_1(x0, y0) {
+    if (!x0.every((x, i) => y0[i] === x)) { return false; }
+    return true;
+  }
+  _equal_2(x0, y0) {
+    if (!x0.every((x, i) => y0[i] === x)) { return false; }
+    return true;
+  }
+  _equal_3(x0, y0) {
+    if (!x0.every((x, i) => y0[i] === x)) { return false; }
+    return true;
+  }
+  _equal_4(x0, y0) {
+    if (!x0.every((x, i) => y0[i] === x)) { return false; }
+    return true;
+  }
+  _equal_5(x0, y0) {
+    if (!x0.every((x, i) => y0[i] === x)) { return false; }
+    return true;
+  }
+  _equal_6(x0, y0) {
+    if (!x0.every((x, i) => y0[i] === x)) { return false; }
+    return true;
+  }
+}
+export function ledger(stateOrChargedState) {
+  const state = stateOrChargedState instanceof __compactRuntime.StateValue ? stateOrChargedState : stateOrChargedState.state;
+  const chargedState = stateOrChargedState instanceof __compactRuntime.StateValue ? new __compactRuntime.ChargedState(stateOrChargedState) : stateOrChargedState;
+  const context = {
+    callContext: { currentQueryContext: new __compactRuntime.QueryContext(chargedState, __compactRuntime.dummyContractAddress()), currentGasCost: __compactRuntime.emptyRunningCost() },
+    costModel: __compactRuntime.CostModel.initialCostModel()
+  };
+  const partialProofData = {
+    input: { value: [], alignment: [] },
+    output: undefined,
+    publicTranscript: [],
+    privateTranscriptOutputs: []
+  };
+  return {
+    servicePrice: {
+      isEmpty(...args_0) {
+        if (args_0.length !== 0) {
+          throw new __compactRuntime.CompactError(`isEmpty: expected 0 arguments, received ${args_0.length}`);
+        }
+        return _descriptor_1.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                         partialProofData,
+                                                                         [
+                                                                          { dup: { n: 0 } },
+                                                                          { idx: { cached: false,
+                                                                                   pushPath: false,
+                                                                                   path: [
+                                                                                          { tag: 'value',
+                                                                                            value: { value: _descriptor_24.toValue(0n),
+                                                                                                     alignment: _descriptor_24.alignment() } }] } },
+                                                                          'size',
+                                                                          { push: { storage: false,
+                                                                                    value: __compactRuntime.StateValue.newCell({ value: _descriptor_2.toValue(0n),
+                                                                                                                                 alignment: _descriptor_2.alignment() }).encode() } },
+                                                                          'eq',
+                                                                          { popeq: { cached: true,
+                                                                                     result: undefined } }]).value);
+      },
+      size(...args_0) {
+        if (args_0.length !== 0) {
+          throw new __compactRuntime.CompactError(`size: expected 0 arguments, received ${args_0.length}`);
+        }
+        return _descriptor_2.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                         partialProofData,
+                                                                         [
+                                                                          { dup: { n: 0 } },
+                                                                          { idx: { cached: false,
+                                                                                   pushPath: false,
+                                                                                   path: [
+                                                                                          { tag: 'value',
+                                                                                            value: { value: _descriptor_24.toValue(0n),
+                                                                                                     alignment: _descriptor_24.alignment() } }] } },
+                                                                          'size',
+                                                                          { popeq: { cached: true,
+                                                                                     result: undefined } }]).value);
+      },
+      member(...args_0) {
+        if (args_0.length !== 1) {
+          throw new __compactRuntime.CompactError(`member: expected 1 argument, received ${args_0.length}`);
+        }
+        const key_0 = args_0[0];
+        if (!(key_0.buffer instanceof ArrayBuffer && key_0.BYTES_PER_ELEMENT === 1 && key_0.length === 32)) {
+          __compactRuntime.typeError('member',
+                                     'argument 1',
+                                     'm402-vault.compact line 10 char 1',
+                                     'Bytes<32>',
+                                     key_0)
+        }
+        return _descriptor_1.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                         partialProofData,
+                                                                         [
+                                                                          { dup: { n: 0 } },
+                                                                          { idx: { cached: false,
+                                                                                   pushPath: false,
+                                                                                   path: [
+                                                                                          { tag: 'value',
+                                                                                            value: { value: _descriptor_24.toValue(0n),
+                                                                                                     alignment: _descriptor_24.alignment() } }] } },
+                                                                          { push: { storage: false,
+                                                                                    value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(key_0),
+                                                                                                                                 alignment: _descriptor_0.alignment() }).encode() } },
+                                                                          'member',
+                                                                          { popeq: { cached: true,
+                                                                                     result: undefined } }]).value);
+      },
+      lookup(...args_0) {
+        if (args_0.length !== 1) {
+          throw new __compactRuntime.CompactError(`lookup: expected 1 argument, received ${args_0.length}`);
+        }
+        const key_0 = args_0[0];
+        if (!(key_0.buffer instanceof ArrayBuffer && key_0.BYTES_PER_ELEMENT === 1 && key_0.length === 32)) {
+          __compactRuntime.typeError('lookup',
+                                     'argument 1',
+                                     'm402-vault.compact line 10 char 1',
+                                     'Bytes<32>',
+                                     key_0)
+        }
+        return _descriptor_2.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                         partialProofData,
+                                                                         [
+                                                                          { dup: { n: 0 } },
+                                                                          { idx: { cached: false,
+                                                                                   pushPath: false,
+                                                                                   path: [
+                                                                                          { tag: 'value',
+                                                                                            value: { value: _descriptor_24.toValue(0n),
+                                                                                                     alignment: _descriptor_24.alignment() } }] } },
+                                                                          { idx: { cached: false,
+                                                                                   pushPath: false,
+                                                                                   path: [
+                                                                                          { tag: 'value',
+                                                                                            value: { value: _descriptor_0.toValue(key_0),
+                                                                                                     alignment: _descriptor_0.alignment() } }] } },
+                                                                          { popeq: { cached: false,
+                                                                                     result: undefined } }]).value);
+      },
+      [Symbol.iterator](...args_0) {
+        if (args_0.length !== 0) {
+          throw new __compactRuntime.CompactError(`iter: expected 0 arguments, received ${args_0.length}`);
+        }
+        const self_0 = state.asArray()[0];
+        return self_0.asMap().keys().map(  (key) => {    const value = self_0.asMap().get(key).asCell();    return [      _descriptor_0.fromValue(key.value),      _descriptor_2.fromValue(value.value)    ];  })[Symbol.iterator]();
+      }
+    },
+    serviceOwner: {
+      isEmpty(...args_0) {
+        if (args_0.length !== 0) {
+          throw new __compactRuntime.CompactError(`isEmpty: expected 0 arguments, received ${args_0.length}`);
+        }
+        return _descriptor_1.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                         partialProofData,
+                                                                         [
+                                                                          { dup: { n: 0 } },
+                                                                          { idx: { cached: false,
+                                                                                   pushPath: false,
+                                                                                   path: [
+                                                                                          { tag: 'value',
+                                                                                            value: { value: _descriptor_24.toValue(1n),
+                                                                                                     alignment: _descriptor_24.alignment() } }] } },
+                                                                          'size',
+                                                                          { push: { storage: false,
+                                                                                    value: __compactRuntime.StateValue.newCell({ value: _descriptor_2.toValue(0n),
+                                                                                                                                 alignment: _descriptor_2.alignment() }).encode() } },
+                                                                          'eq',
+                                                                          { popeq: { cached: true,
+                                                                                     result: undefined } }]).value);
+      },
+      size(...args_0) {
+        if (args_0.length !== 0) {
+          throw new __compactRuntime.CompactError(`size: expected 0 arguments, received ${args_0.length}`);
+        }
+        return _descriptor_2.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                         partialProofData,
+                                                                         [
+                                                                          { dup: { n: 0 } },
+                                                                          { idx: { cached: false,
+                                                                                   pushPath: false,
+                                                                                   path: [
+                                                                                          { tag: 'value',
+                                                                                            value: { value: _descriptor_24.toValue(1n),
+                                                                                                     alignment: _descriptor_24.alignment() } }] } },
+                                                                          'size',
+                                                                          { popeq: { cached: true,
+                                                                                     result: undefined } }]).value);
+      },
+      member(...args_0) {
+        if (args_0.length !== 1) {
+          throw new __compactRuntime.CompactError(`member: expected 1 argument, received ${args_0.length}`);
+        }
+        const key_0 = args_0[0];
+        if (!(key_0.buffer instanceof ArrayBuffer && key_0.BYTES_PER_ELEMENT === 1 && key_0.length === 32)) {
+          __compactRuntime.typeError('member',
+                                     'argument 1',
+                                     'm402-vault.compact line 11 char 1',
+                                     'Bytes<32>',
+                                     key_0)
+        }
+        return _descriptor_1.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                         partialProofData,
+                                                                         [
+                                                                          { dup: { n: 0 } },
+                                                                          { idx: { cached: false,
+                                                                                   pushPath: false,
+                                                                                   path: [
+                                                                                          { tag: 'value',
+                                                                                            value: { value: _descriptor_24.toValue(1n),
+                                                                                                     alignment: _descriptor_24.alignment() } }] } },
+                                                                          { push: { storage: false,
+                                                                                    value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(key_0),
+                                                                                                                                 alignment: _descriptor_0.alignment() }).encode() } },
+                                                                          'member',
+                                                                          { popeq: { cached: true,
+                                                                                     result: undefined } }]).value);
+      },
+      lookup(...args_0) {
+        if (args_0.length !== 1) {
+          throw new __compactRuntime.CompactError(`lookup: expected 1 argument, received ${args_0.length}`);
+        }
+        const key_0 = args_0[0];
+        if (!(key_0.buffer instanceof ArrayBuffer && key_0.BYTES_PER_ELEMENT === 1 && key_0.length === 32)) {
+          __compactRuntime.typeError('lookup',
+                                     'argument 1',
+                                     'm402-vault.compact line 11 char 1',
+                                     'Bytes<32>',
+                                     key_0)
+        }
+        return _descriptor_0.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                         partialProofData,
+                                                                         [
+                                                                          { dup: { n: 0 } },
+                                                                          { idx: { cached: false,
+                                                                                   pushPath: false,
+                                                                                   path: [
+                                                                                          { tag: 'value',
+                                                                                            value: { value: _descriptor_24.toValue(1n),
+                                                                                                     alignment: _descriptor_24.alignment() } }] } },
+                                                                          { idx: { cached: false,
+                                                                                   pushPath: false,
+                                                                                   path: [
+                                                                                          { tag: 'value',
+                                                                                            value: { value: _descriptor_0.toValue(key_0),
+                                                                                                     alignment: _descriptor_0.alignment() } }] } },
+                                                                          { popeq: { cached: false,
+                                                                                     result: undefined } }]).value);
+      },
+      [Symbol.iterator](...args_0) {
+        if (args_0.length !== 0) {
+          throw new __compactRuntime.CompactError(`iter: expected 0 arguments, received ${args_0.length}`);
+        }
+        const self_0 = state.asArray()[1];
+        return self_0.asMap().keys().map(  (key) => {    const value = self_0.asMap().get(key).asCell();    return [      _descriptor_0.fromValue(key.value),      _descriptor_0.fromValue(value.value)    ];  })[Symbol.iterator]();
+      }
+    },
+    receipts: {
+      isEmpty(...args_0) {
+        if (args_0.length !== 0) {
+          throw new __compactRuntime.CompactError(`isEmpty: expected 0 arguments, received ${args_0.length}`);
+        }
+        return _descriptor_1.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                         partialProofData,
+                                                                         [
+                                                                          { dup: { n: 0 } },
+                                                                          { idx: { cached: false,
+                                                                                   pushPath: false,
+                                                                                   path: [
+                                                                                          { tag: 'value',
+                                                                                            value: { value: _descriptor_24.toValue(2n),
+                                                                                                     alignment: _descriptor_24.alignment() } }] } },
+                                                                          'size',
+                                                                          { push: { storage: false,
+                                                                                    value: __compactRuntime.StateValue.newCell({ value: _descriptor_2.toValue(0n),
+                                                                                                                                 alignment: _descriptor_2.alignment() }).encode() } },
+                                                                          'eq',
+                                                                          { popeq: { cached: true,
+                                                                                     result: undefined } }]).value);
+      },
+      size(...args_0) {
+        if (args_0.length !== 0) {
+          throw new __compactRuntime.CompactError(`size: expected 0 arguments, received ${args_0.length}`);
+        }
+        return _descriptor_2.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                         partialProofData,
+                                                                         [
+                                                                          { dup: { n: 0 } },
+                                                                          { idx: { cached: false,
+                                                                                   pushPath: false,
+                                                                                   path: [
+                                                                                          { tag: 'value',
+                                                                                            value: { value: _descriptor_24.toValue(2n),
+                                                                                                     alignment: _descriptor_24.alignment() } }] } },
+                                                                          'size',
+                                                                          { popeq: { cached: true,
+                                                                                     result: undefined } }]).value);
+      },
+      member(...args_0) {
+        if (args_0.length !== 1) {
+          throw new __compactRuntime.CompactError(`member: expected 1 argument, received ${args_0.length}`);
+        }
+        const elem_0 = args_0[0];
+        if (!(elem_0.buffer instanceof ArrayBuffer && elem_0.BYTES_PER_ELEMENT === 1 && elem_0.length === 32)) {
+          __compactRuntime.typeError('member',
+                                     'argument 1',
+                                     'm402-vault.compact line 12 char 1',
+                                     'Bytes<32>',
+                                     elem_0)
+        }
+        return _descriptor_1.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                         partialProofData,
+                                                                         [
+                                                                          { dup: { n: 0 } },
+                                                                          { idx: { cached: false,
+                                                                                   pushPath: false,
+                                                                                   path: [
+                                                                                          { tag: 'value',
+                                                                                            value: { value: _descriptor_24.toValue(2n),
+                                                                                                     alignment: _descriptor_24.alignment() } }] } },
+                                                                          { push: { storage: false,
+                                                                                    value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(elem_0),
+                                                                                                                                 alignment: _descriptor_0.alignment() }).encode() } },
+                                                                          'member',
+                                                                          { popeq: { cached: true,
+                                                                                     result: undefined } }]).value);
+      },
+      [Symbol.iterator](...args_0) {
+        if (args_0.length !== 0) {
+          throw new __compactRuntime.CompactError(`iter: expected 0 arguments, received ${args_0.length}`);
+        }
+        const self_0 = state.asArray()[2];
+        return self_0.asMap().keys().map((elem) => _descriptor_0.fromValue(elem.value))[Symbol.iterator]();
+      }
+    },
+    merchantBalance: {
+      isEmpty(...args_0) {
+        if (args_0.length !== 0) {
+          throw new __compactRuntime.CompactError(`isEmpty: expected 0 arguments, received ${args_0.length}`);
+        }
+        return _descriptor_1.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                         partialProofData,
+                                                                         [
+                                                                          { dup: { n: 0 } },
+                                                                          { idx: { cached: false,
+                                                                                   pushPath: false,
+                                                                                   path: [
+                                                                                          { tag: 'value',
+                                                                                            value: { value: _descriptor_24.toValue(3n),
+                                                                                                     alignment: _descriptor_24.alignment() } }] } },
+                                                                          'size',
+                                                                          { push: { storage: false,
+                                                                                    value: __compactRuntime.StateValue.newCell({ value: _descriptor_2.toValue(0n),
+                                                                                                                                 alignment: _descriptor_2.alignment() }).encode() } },
+                                                                          'eq',
+                                                                          { popeq: { cached: true,
+                                                                                     result: undefined } }]).value);
+      },
+      size(...args_0) {
+        if (args_0.length !== 0) {
+          throw new __compactRuntime.CompactError(`size: expected 0 arguments, received ${args_0.length}`);
+        }
+        return _descriptor_2.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                         partialProofData,
+                                                                         [
+                                                                          { dup: { n: 0 } },
+                                                                          { idx: { cached: false,
+                                                                                   pushPath: false,
+                                                                                   path: [
+                                                                                          { tag: 'value',
+                                                                                            value: { value: _descriptor_24.toValue(3n),
+                                                                                                     alignment: _descriptor_24.alignment() } }] } },
+                                                                          'size',
+                                                                          { popeq: { cached: true,
+                                                                                     result: undefined } }]).value);
+      },
+      member(...args_0) {
+        if (args_0.length !== 1) {
+          throw new __compactRuntime.CompactError(`member: expected 1 argument, received ${args_0.length}`);
+        }
+        const key_0 = args_0[0];
+        if (!(key_0.buffer instanceof ArrayBuffer && key_0.BYTES_PER_ELEMENT === 1 && key_0.length === 32)) {
+          __compactRuntime.typeError('member',
+                                     'argument 1',
+                                     'm402-vault.compact line 13 char 1',
+                                     'Bytes<32>',
+                                     key_0)
+        }
+        return _descriptor_1.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                         partialProofData,
+                                                                         [
+                                                                          { dup: { n: 0 } },
+                                                                          { idx: { cached: false,
+                                                                                   pushPath: false,
+                                                                                   path: [
+                                                                                          { tag: 'value',
+                                                                                            value: { value: _descriptor_24.toValue(3n),
+                                                                                                     alignment: _descriptor_24.alignment() } }] } },
+                                                                          { push: { storage: false,
+                                                                                    value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(key_0),
+                                                                                                                                 alignment: _descriptor_0.alignment() }).encode() } },
+                                                                          'member',
+                                                                          { popeq: { cached: true,
+                                                                                     result: undefined } }]).value);
+      },
+      lookup(...args_0) {
+        if (args_0.length !== 1) {
+          throw new __compactRuntime.CompactError(`lookup: expected 1 argument, received ${args_0.length}`);
+        }
+        const key_0 = args_0[0];
+        if (!(key_0.buffer instanceof ArrayBuffer && key_0.BYTES_PER_ELEMENT === 1 && key_0.length === 32)) {
+          __compactRuntime.typeError('lookup',
+                                     'argument 1',
+                                     'm402-vault.compact line 13 char 1',
+                                     'Bytes<32>',
+                                     key_0)
+        }
+        return _descriptor_2.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                         partialProofData,
+                                                                         [
+                                                                          { dup: { n: 0 } },
+                                                                          { idx: { cached: false,
+                                                                                   pushPath: false,
+                                                                                   path: [
+                                                                                          { tag: 'value',
+                                                                                            value: { value: _descriptor_24.toValue(3n),
+                                                                                                     alignment: _descriptor_24.alignment() } }] } },
+                                                                          { idx: { cached: false,
+                                                                                   pushPath: false,
+                                                                                   path: [
+                                                                                          { tag: 'value',
+                                                                                            value: { value: _descriptor_0.toValue(key_0),
+                                                                                                     alignment: _descriptor_0.alignment() } }] } },
+                                                                          { popeq: { cached: false,
+                                                                                     result: undefined } }]).value);
+      },
+      [Symbol.iterator](...args_0) {
+        if (args_0.length !== 0) {
+          throw new __compactRuntime.CompactError(`iter: expected 0 arguments, received ${args_0.length}`);
+        }
+        const self_0 = state.asArray()[3];
+        return self_0.asMap().keys().map(  (key) => {    const value = self_0.asMap().get(key).asCell();    return [      _descriptor_0.fromValue(key.value),      _descriptor_2.fromValue(value.value)    ];  })[Symbol.iterator]();
+      }
+    },
+    get mintCounter() {
+      return _descriptor_2.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                       partialProofData,
+                                                                       [
+                                                                        { dup: { n: 0 } },
+                                                                        { idx: { cached: false,
+                                                                                 pushPath: false,
+                                                                                 path: [
+                                                                                        { tag: 'value',
+                                                                                          value: { value: _descriptor_24.toValue(4n),
+                                                                                                   alignment: _descriptor_24.alignment() } }] } },
+                                                                        { popeq: { cached: true,
+                                                                                   result: undefined } }]).value);
+    }
+  };
+}
+const _emptyContext = {
+  callContext: { currentQueryContext: new __compactRuntime.QueryContext(new __compactRuntime.ContractState().data, __compactRuntime.dummyContractAddress()), currentGasCost: __compactRuntime.emptyRunningCost() }
+};
+const _dummyContract = new Contract({ });
+export const pureCircuits = {
+  creditColor: (...args_0) => {
+    if (args_0.length !== 1) {
+      throw new __compactRuntime.CompactError(`creditColor: expected 1 argument (as invoked from Typescript), received ${args_0.length}`);
+    }
+    const self_0 = args_0[0];
+    if (!(typeof(self_0) === 'object' && self_0.bytes.buffer instanceof ArrayBuffer && self_0.bytes.BYTES_PER_ELEMENT === 1 && self_0.bytes.length === 32)) {
+      __compactRuntime.typeError('creditColor',
+                                 'argument 1',
+                                 'm402-vault.compact line 20 char 1',
+                                 'struct ContractAddress<bytes: Bytes<32>>',
+                                 self_0)
+    }
+    return _dummyContract._creditColor_0(self_0);
+  },
+  deriveReceipt: (...args_0) => {
+    if (args_0.length !== 2) {
+      throw new __compactRuntime.CompactError(`deriveReceipt: expected 2 arguments (as invoked from Typescript), received ${args_0.length}`);
+    }
+    const secret_0 = args_0[0];
+    const serviceId_0 = args_0[1];
+    if (!(secret_0.buffer instanceof ArrayBuffer && secret_0.BYTES_PER_ELEMENT === 1 && secret_0.length === 32)) {
+      __compactRuntime.typeError('deriveReceipt',
+                                 'argument 1',
+                                 'm402-vault.compact line 26 char 1',
+                                 'Bytes<32>',
+                                 secret_0)
+    }
+    if (!(serviceId_0.buffer instanceof ArrayBuffer && serviceId_0.BYTES_PER_ELEMENT === 1 && serviceId_0.length === 32)) {
+      __compactRuntime.typeError('deriveReceipt',
+                                 'argument 2',
+                                 'm402-vault.compact line 26 char 1',
+                                 'Bytes<32>',
+                                 serviceId_0)
+    }
+    return _dummyContract._deriveReceipt_0(secret_0, serviceId_0);
+  },
+  deriveServiceId: (...args_0) => {
+    if (args_0.length !== 3) {
+      throw new __compactRuntime.CompactError(`deriveServiceId: expected 3 arguments (as invoked from Typescript), received ${args_0.length}`);
+    }
+    const owner_0 = args_0[0];
+    const salt_0 = args_0[1];
+    const price_0 = args_0[2];
+    if (!(owner_0.buffer instanceof ArrayBuffer && owner_0.BYTES_PER_ELEMENT === 1 && owner_0.length === 32)) {
+      __compactRuntime.typeError('deriveServiceId',
+                                 'argument 1',
+                                 'm402-vault.compact line 34 char 1',
+                                 'Bytes<32>',
+                                 owner_0)
+    }
+    if (!(salt_0.buffer instanceof ArrayBuffer && salt_0.BYTES_PER_ELEMENT === 1 && salt_0.length === 32)) {
+      __compactRuntime.typeError('deriveServiceId',
+                                 'argument 2',
+                                 'm402-vault.compact line 34 char 1',
+                                 'Bytes<32>',
+                                 salt_0)
+    }
+    if (!(typeof(price_0) === 'bigint' && price_0 >= 0n && price_0 <= 18446744073709551615n)) {
+      __compactRuntime.typeError('deriveServiceId',
+                                 'argument 3',
+                                 'm402-vault.compact line 34 char 1',
+                                 'Uint<0..18446744073709551616>',
+                                 price_0)
+    }
+    return _dummyContract._deriveServiceId_0(owner_0, salt_0, price_0);
+  }
+};
+export const expectedVk = {
+  'deposit': '3967aa980c22fa7db0111c36ab0580752d1c27d242cbef9461fea2b2c0562566',
+  'pay': '44146e9d3102fc60deb47d61cc44029424f841c589322d9944b866b9e8d44a34',
+  'redeem': '13b94ab51c5988bbfd64c2aabd243da27a3ffffe298aa7041ef957480d2fb915',
+  'registerService': 'dece03cc1c292c0d305f9bd23485399c71336c88d74765f1ab1e53ced6905ff8',
+  'withdraw': 'a61392d20dae6d8fa2d7faac960b0213b92264c267fbdef1ad3b4415794d12d8',
+};
+
+export const circuitSignatures = {
+  'creditColor': {pure: true, provable: false, argumentTypes: [{tag: 'Struct', name: 'ContractAddress', elements: [{name: 'bytes', type: {tag: 'Bytes', length: 32}}]}], resultType: {tag: 'Bytes', length: 32}},
+  'deriveReceipt': {pure: true, provable: false, argumentTypes: [{tag: 'Bytes', length: 32}, {tag: 'Bytes', length: 32}], resultType: {tag: 'Bytes', length: 32}},
+  'deriveServiceId': {pure: true, provable: false, argumentTypes: [{tag: 'Bytes', length: 32}, {tag: 'Bytes', length: 32}, {tag: 'Uint', maxval: '18446744073709551615'}], resultType: {tag: 'Bytes', length: 32}},
+  'registerService': {pure: false, provable: true, argumentTypes: [{tag: 'Bytes', length: 32}, {tag: 'Uint', maxval: '18446744073709551615'}, {tag: 'Bytes', length: 32}], resultType: {tag: 'Tuple', types: []}},
+  'deposit': {pure: false, provable: true, argumentTypes: [{tag: 'Uint', maxval: '18446744073709551615'}, {tag: 'Bytes', length: 32}], resultType: {tag: 'Tuple', types: []}},
+  'pay': {pure: false, provable: true, argumentTypes: [{tag: 'Bytes', length: 32}, {tag: 'Struct', name: 'ShieldedCoinInfo', elements: [{name: 'nonce', type: {tag: 'Bytes', length: 32}}, {name: 'color', type: {tag: 'Bytes', length: 32}}, {name: 'value', type: {tag: 'Uint', maxval: '340282366920938463463374607431768211455'}}]}, {tag: 'Bytes', length: 32}], resultType: {tag: 'Tuple', types: []}},
+  'redeem': {pure: false, provable: true, argumentTypes: [{tag: 'Bytes', length: 32}, {tag: 'Struct', name: 'ShieldedCoinInfo', elements: [{name: 'nonce', type: {tag: 'Bytes', length: 32}}, {name: 'color', type: {tag: 'Bytes', length: 32}}, {name: 'value', type: {tag: 'Uint', maxval: '340282366920938463463374607431768211455'}}]}], resultType: {tag: 'Tuple', types: []}},
+  'withdraw': {pure: false, provable: true, argumentTypes: [{tag: 'Bytes', length: 32}, {tag: 'Uint', maxval: '18446744073709551615'}], resultType: {tag: 'Tuple', types: []}},
+};
+
+export const declaredInterfaces = {};
+
+//# sourceMappingURL=index.js.map