@sig-net/midnight-signer 0.0.0-stage → 0.26.0-rc.11

package/README.md

@@ -1,3 +1,32 @@
-# Temporary Holding Version
+# @sig-net/midnight-signer
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The central [Sig Network](https://sig.network) signet signer on the [Midnight blockchain](https://midnight.network): the contract that exposes the MPC's [sign bidirectional flow](https://github.com/sig-net/midnight-integration/blob/main/README.md#sign-bidirectional-protocol-flow) to other Midnight contracts. Integrating contracts notify it of their requests through `signBidirectional`, which emits a named contract event the MPC polls. The MPC posts its responses to the [signet responder](https://www.npmjs.com/package/@sig-net/midnight-responder), and clients poll that contract's events.
+
+## What is in it
+
+- The curated export surface (package root): the generated contract module (`Contract`), the handwritten witnesses, and the platform-agnostic contract surface (circuit ids and the provider type).
+- The `./managed/*` subpath export: the compiled contract assets (compiler output, `zkir/`, prover/verifier `keys/`) so runtimes can fetch them as files. The published package always carries the proving keys.
+
+Consumers import the package root. The `./managed/*` paths exist only for runtimes that load zk assets.
+
+## Install
+
+```sh
+npm install @sig-net/midnight-signer
+```
+
+## Documentation
+
+The protocol and integration documentation lives in the [sig-net/midnight-integration README](https://github.com/sig-net/midnight-integration/blob/main/README.md):
+
+- [Sign Bidirectional Flow](https://github.com/sig-net/midnight-integration/blob/main/README.md#sign-bidirectional-protocol-flow): the 5-step protocol this contract starts, with diagram, failure handling and output recovery: which circuit each step calls and which event it emits.
+- [Integrator Guide](https://github.com/sig-net/midnight-integration/blob/main/README.md#integrator-guide): how client contracts and dApps drive this contract's `signBidirectional` and read the responder's events per request.
+- [Handling Failure](https://github.com/sig-net/midnight-integration/blob/main/README.md#handling-failure): how a failed foreign transaction still completes the flow, attested through the responder's `respondBidirectional` circuit as an empty output under a failure output kind.
+
+## Related packages
+
+- [`@sig-net/midnight-contract-deploy`](https://www.npmjs.com/package/@sig-net/midnight-contract-deploy): deploys this contract (it takes no constructor arguments: the MPC derives a response key per client contract, and each client pins its own).
+- [`@sig-net/midnight`](https://www.npmjs.com/package/@sig-net/midnight): the client-agnostic protocol library for decoding this contract's events and verifying the MPC's responses.
+- [`@sig-net/midnight-responder`](https://www.npmjs.com/package/@sig-net/midnight-responder): the contract the MPC posts its responses to.
+
+Developed in [sig-net/midnight-integration](https://github.com/sig-net/midnight-integration). Example applications live in [sig-net/midnight-examples](https://github.com/sig-net/midnight-examples).

package/dist/contract-surface.d.ts

@@ -0,0 +1,20 @@
+import type { MidnightProviders } from "@midnight-ntwrk/midnight-js/types";
+import type { Contract } from "./managed/contract/index.js";
+import type { SignetSignerPrivateState } from "./witnesses.ts";
+/** The contract's provable circuit ids, straight from the generated contract. */
+export type SignetSignerCircuitId = keyof InstanceType<typeof Contract>["provableCircuits"];
+/**
+ * Literal of the private-state storage key. Just a string, but a single-value
+ * union so the providers/`findDeployedContract` pairing is enforced by the
+ * type system.
+ */
+export type SignetSignerPrivateStateId = "signet-signer";
+/**
+ * Key under which midnight-js persists this contract's private state locally
+ * (in whatever private-state store the consumer's provider set uses).
+ * Distinct per contract so two clients don't share an entry.
+ */
+export declare const SIGNET_SIGNER_PRIVATE_STATE_ID: SignetSignerPrivateStateId;
+/** The full midnight-js provider set, typed to the signet signer. */
+export type SignetSignerProviders = MidnightProviders<SignetSignerCircuitId, SignetSignerPrivateStateId, SignetSignerPrivateState>;
+//# sourceMappingURL=contract-surface.d.ts.map

package/dist/contract-surface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-surface.d.ts","sourceRoot":"","sources":["../src/contract-surface.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAE3E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAE/D,iFAAiF;AACjF,MAAM,MAAM,qBAAqB,GAAG,MAAM,YAAY,CAAC,OAAO,QAAQ,CAAC,CAAC,kBAAkB,CAAC,CAAC;AAE5F;;;;GAIG;AACH,MAAM,MAAM,0BAA0B,GAAG,eAAe,CAAC;AAEzD;;;;GAIG;AACH,eAAO,MAAM,8BAA8B,EAAE,0BAA4C,CAAC;AAE1F,qEAAqE;AACrE,MAAM,MAAM,qBAAqB,GAAG,iBAAiB,CAEnD,qBAAqB,EAErB,0BAA0B,EAE1B,wBAAwB,CACzB,CAAC"}

package/dist/contract-surface.js

@@ -0,0 +1,15 @@
+// The contract's platform-agnostic client surface: the circuit-id union, the
+// private-state store key, and the provider-set TYPE. Deliberately nothing
+// runnable — no wallet flavor, no zk-config source, no state store, no proof
+// provider. Composing a live midnight-js provider set is CONSUMER territory
+// (it differs per environment: Node fs vs browser fetch, LevelDB vs
+// IndexedDB, WalletFacade vs a connector API), so each consumer declares its
+// own — see this monorepo's signet-contract-deploy package for the Node
+// operator composition.
+/**
+ * Key under which midnight-js persists this contract's private state locally
+ * (in whatever private-state store the consumer's provider set uses).
+ * Distinct per contract so two clients don't share an entry.
+ */
+export const SIGNET_SIGNER_PRIVATE_STATE_ID = "signet-signer";
+//# sourceMappingURL=contract-surface.js.map

package/dist/contract-surface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-surface.js","sourceRoot":"","sources":["../src/contract-surface.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,2EAA2E;AAC3E,6EAA6E;AAC7E,4EAA4E;AAC5E,oEAAoE;AACpE,6EAA6E;AAC7E,wEAAwE;AACxE,wBAAwB;AAiBxB;;;;GAIG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAA+B,eAAe,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./contract-surface.ts";
+export * from "./managed/contract/index.js";
+export * from "./witnesses.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAMA,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,9 @@
+// Curated export surface — this IS the "sdk" face of the package.
+// Everything the compiler emitted, the handwritten witnesses, and the
+// platform-agnostic contract surface (ids + provider TYPE). Environment
+// bindings (zk-config source, state store, wallet adapter) deliberately
+// live with each consumer, not here.
+export * from "./contract-surface.js";
+export * from "./managed/contract/index.js";
+export * from "./witnesses.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,sEAAsE;AACtE,wEAAwE;AACxE,wEAAwE;AACxE,qCAAqC;AAErC,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gBAAgB,CAAC"}

package/dist/managed/compiler/contract-info.json

@@ -0,0 +1,60 @@
+{
+  "compiler-version": "0.36.0",
+  "compiler-commit": "b5d9e4dfc532fe47011c4f6296e254f4853eb469",
+  "language-version": "0.28.0",
+  "runtime-version": "0.21.0",
+  "circuits": [
+    {
+      "name": "signBidirectional",
+      "pure": false,
+      "proof": true,
+      "arguments": [
+        {
+          "name": "requestId",
+          "type": {
+            "type-name": "Alias",
+            "name": "RequestId",
+            "type": {
+              "type-name": "Bytes",
+              "length": 32
+            }
+          }
+        },
+        {
+          "name": "notification",
+          "type": {
+            "type-name": "Struct",
+            "name": "SignBidirectionalEventNotification",
+            "elements": [
+              {
+                "name": "version",
+                "type": {
+                  "type-name": "Uint",
+                  "maxval": 255
+                }
+              },
+              {
+                "name": "payload",
+                "type": {
+                  "type-name": "Bytes",
+                  "length": 128
+                }
+              }
+            ]
+          }
+        }
+      ],
+      "result-type": {
+        "type-name": "Tuple",
+        "types": [
+        ]
+      }
+    }
+  ],
+  "witnesses": [
+  ],
+  "contracts": [
+  ],
+  "ledger": [
+  ]
+}

package/dist/managed/compiler/contract-manifest.json

@@ -0,0 +1,59 @@
+{
+  "manifest-version": "1",
+  "compiler-version": "0.36.0",
+  "compiler-commit": "b5d9e4dfc532fe47011c4f6296e254f4853eb469",
+  "language-version": "0.28.0",
+  "runtime-version": "0.21.0",
+  "compiler": {
+    "type": "directory",
+    "contract-info.json": {
+      "type": "file",
+      "size": 1291,
+      "hash": "087c93a19c421556ce1d17601d27a5d128fab0ccf7328783df68ac176dd14d12"
+    }
+  },
+  "contract": {
+    "type": "directory",
+    "index.d.ts": {
+      "type": "file",
+      "size": 1716,
+      "hash": "5fd38aac1491b656058ecee302c1ab63a5b439e5a163e4b02774c62a583b4ee8"
+    },
+    "index.js": {
+      "type": "file",
+      "size": 17916,
+      "hash": "b8e43aff8fb0405a0708c0c023c54c229c8003cbfcaa1e820049eee69c24dd9c"
+    },
+    "index.js.map": {
+      "type": "file",
+      "size": 644,
+      "hash": "5d27c2335f2e59e917d1dd551aece8bf201616bf6a4c36f404aea4f2435efb1e"
+    }
+  },
+  "zkir": {
+    "type": "directory",
+    "signBidirectional.bzkir": {
+      "type": "file",
+      "size": 20006,
+      "hash": "01bd6e0a8ff44f0cb831cc9559e83bdf3faed31f247eecc11926ecf9f9c8f4f4"
+    },
+    "signBidirectional.zkir": {
+      "type": "file",
+      "size": 74419,
+      "hash": "a73e482939c4ba3f88ba204bdd0140a83f480d720f09be7801c46daefbe0dae0"
+    }
+  },
+  "keys": {
+    "type": "directory",
+    "signBidirectional.prover": {
+      "type": "file",
+      "size": 113268984,
+      "hash": "9c7a528f2eefbf2491f1ad2036f289271d178e5ff6eac967381a70e3b938cb62"
+    },
+    "signBidirectional.verifier": {
+      "type": "file",
+      "size": 1353,
+      "hash": "db4268c2740ee34ea5c1297b9fdf21c9eab5cd4f95b1d692ccab981520db71e7"
+    }
+  }
+}

package/dist/managed/contract/index.d.ts

@@ -0,0 +1,43 @@
+import type * as __compactRuntime from '@midnight-ntwrk/compact-runtime';
+
+export type Witnesses<PS> = {
+}
+
+export type ImpureCircuits<PS> = {
+  signBidirectional(context: __compactRuntime.CircuitContext<PS>,
+                    requestId_0: Uint8Array,
+                    notification_0: { version: bigint, payload: Uint8Array }): Promise<__compactRuntime.CircuitResults<PS, []>>;
+}
+
+export type ProvableCircuits<PS> = {
+  signBidirectional(context: __compactRuntime.CircuitContext<PS>,
+                    requestId_0: Uint8Array,
+                    notification_0: { version: bigint, payload: Uint8Array }): Promise<__compactRuntime.CircuitResults<PS, []>>;
+}
+
+export type PureCircuits = {
+}
+
+export type Circuits<PS> = {
+  signBidirectional(context: __compactRuntime.CircuitContext<PS>,
+                    requestId_0: Uint8Array,
+                    notification_0: { version: bigint, payload: Uint8Array }): Promise<__compactRuntime.CircuitResults<PS, []>>;
+}
+
+export type Ledger = {
+}
+
+export declare class Contract<PS = any, W extends Witnesses<PS> = Witnesses<PS>> {
+  witnesses: W;
+  circuits: Circuits<PS>;
+  impureCircuits: ImpureCircuits<PS>;
+  provableCircuits: ProvableCircuits<PS>;
+  constructor(witnesses: W);
+  initialState(context: __compactRuntime.ConstructorContext<PS>): Promise<__compactRuntime.ConstructorResult<PS>>;
+}
+
+export declare function ledger(state: __compactRuntime.StateValue | __compactRuntime.ChargedState): Ledger;
+export declare const pureCircuits: PureCircuits;
+export declare const expectedVk: Record<string, string>;
+export declare const circuitSignatures: __compactRuntime.CircuitSignatures;
+export declare const declaredInterfaces: __compactRuntime.DeclaredInterfaces;

package/dist/managed/contract/index.js

@@ -0,0 +1,286 @@
+import * as __compactRuntime from '@midnight-ntwrk/compact-runtime';
+__compactRuntime.checkRuntimeVersion('0.21.0');
+
+const _descriptor_0 = new __compactRuntime.CompactTypeBytes(288);
+
+const _descriptor_1 = new __compactRuntime.CompactTypeBytes(32);
+
+const _descriptor_2 = new __compactRuntime.CompactTypeUnsignedInteger(255n, 1);
+
+const _descriptor_3 = new __compactRuntime.CompactTypeBytes(128);
+
+class _SignBidirectionalEventNotification_0 {
+  alignment() {
+    return _descriptor_2.alignment().concat(_descriptor_3.alignment());
+  }
+  fromValue(value_0) {
+    return {
+      version: _descriptor_2.fromValue(value_0),
+      payload: _descriptor_3.fromValue(value_0)
+    }
+  }
+  toValue(value_0) {
+    return _descriptor_2.toValue(value_0.version).concat(_descriptor_3.toValue(value_0.payload));
+  }
+}
+
+const _descriptor_4 = new _SignBidirectionalEventNotification_0();
+
+const _descriptor_5 = new __compactRuntime.CompactTypeUnsignedInteger(18446744073709551615n, 8);
+
+const _descriptor_6 = __compactRuntime.CompactTypeBoolean;
+
+class _Either_0 {
+  alignment() {
+    return _descriptor_6.alignment().concat(_descriptor_1.alignment().concat(_descriptor_1.alignment()));
+  }
+  fromValue(value_0) {
+    return {
+      is_left: _descriptor_6.fromValue(value_0),
+      left: _descriptor_1.fromValue(value_0),
+      right: _descriptor_1.fromValue(value_0)
+    }
+  }
+  toValue(value_0) {
+    return _descriptor_6.toValue(value_0.is_left).concat(_descriptor_1.toValue(value_0.left).concat(_descriptor_1.toValue(value_0.right)));
+  }
+}
+
+const _descriptor_7 = new _Either_0();
+
+const _descriptor_8 = new __compactRuntime.CompactTypeUnsignedInteger(340282366920938463463374607431768211455n, 16);
+
+class _ContractAddress_0 {
+  alignment() {
+    return _descriptor_1.alignment();
+  }
+  fromValue(value_0) {
+    return {
+      bytes: _descriptor_1.fromValue(value_0)
+    }
+  }
+  toValue(value_0) {
+    return _descriptor_1.toValue(value_0.bytes);
+  }
+}
+
+const _descriptor_9 = new _ContractAddress_0();
+
+class _UserAddress_0 {
+  alignment() {
+    return _descriptor_1.alignment();
+  }
+  fromValue(value_0) {
+    return {
+      bytes: _descriptor_1.fromValue(value_0)
+    }
+  }
+  toValue(value_0) {
+    return _descriptor_1.toValue(value_0.bytes);
+  }
+}
+
+const _descriptor_10 = new _UserAddress_0();
+
+class _Either_1 {
+  alignment() {
+    return _descriptor_6.alignment().concat(_descriptor_9.alignment().concat(_descriptor_10.alignment()));
+  }
+  fromValue(value_0) {
+    return {
+      is_left: _descriptor_6.fromValue(value_0),
+      left: _descriptor_9.fromValue(value_0),
+      right: _descriptor_10.fromValue(value_0)
+    }
+  }
+  toValue(value_0) {
+    return _descriptor_6.toValue(value_0.is_left).concat(_descriptor_9.toValue(value_0.left).concat(_descriptor_10.toValue(value_0.right)));
+  }
+}
+
+const _descriptor_11 = new _Either_1();
+
+class _Maybe_0 {
+  alignment() {
+    return _descriptor_6.alignment().concat(_descriptor_11.alignment());
+  }
+  fromValue(value_0) {
+    return {
+      is_some: _descriptor_6.fromValue(value_0),
+      value: _descriptor_11.fromValue(value_0)
+    }
+  }
+  toValue(value_0) {
+    return _descriptor_6.toValue(value_0.is_some).concat(_descriptor_11.toValue(value_0.value));
+  }
+}
+
+const _descriptor_12 = new _Maybe_0();
+
+const _descriptor_13 = 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 = {
+      signBidirectional: async (...args_1) => {
+        if (args_1.length !== 3) {
+          throw new __compactRuntime.CompactError(`signBidirectional: expected 3 arguments (as invoked from Typescript), received ${args_1.length}`);
+        }
+        const contextOrig_0 = args_1[0];
+        const requestId_0 = args_1[1];
+        const notification_0 = args_1[2];
+        if (!(typeof(contextOrig_0) === 'object' && contextOrig_0.callContext.currentQueryContext != undefined)) {
+          __compactRuntime.typeError('signBidirectional',
+                                     'argument 1 (as invoked from Typescript)',
+                                     'signet-signer.compact line 30 char 1',
+                                     'CircuitContext',
+                                     contextOrig_0)
+        }
+        if (!(requestId_0.buffer instanceof ArrayBuffer && requestId_0.BYTES_PER_ELEMENT === 1 && requestId_0.length === 32)) {
+          __compactRuntime.typeError('signBidirectional',
+                                     'argument 1 (argument 2 as invoked from Typescript)',
+                                     'signet-signer.compact line 30 char 1',
+                                     'Bytes<32>',
+                                     requestId_0)
+        }
+        if (!(typeof(notification_0) === 'object' && typeof(notification_0.version) === 'bigint' && notification_0.version >= 0n && notification_0.version <= 255n && notification_0.payload.buffer instanceof ArrayBuffer && notification_0.payload.BYTES_PER_ELEMENT === 1 && notification_0.payload.length === 128)) {
+          __compactRuntime.typeError('signBidirectional',
+                                     'argument 2 (argument 3 as invoked from Typescript)',
+                                     'signet-signer.compact line 30 char 1',
+                                     'struct SignBidirectionalEventNotification<version: Uint<0..256>, payload: Bytes<128>>',
+                                     notification_0)
+        }
+        const context = __compactRuntime.copyCircuitContext(contextOrig_0);
+        const partialProofData = {
+          input: {
+            value: _descriptor_1.toValue(requestId_0).concat(_descriptor_4.toValue(notification_0)),
+            alignment: _descriptor_1.alignment().concat(_descriptor_4.alignment())
+          },
+          output: undefined,
+          publicTranscript: [],
+          privateTranscriptOutputs: []
+        };
+        const result_0 = await this._signBidirectional_0(context,
+                                                         partialProofData,
+                                                         requestId_0,
+                                                         notification_0);
+        partialProofData.output = { value: [], alignment: [] };
+        __compactRuntime.finalizeCallProofData(context, partialProofData);
+        return { result: result_0, context: context, gasCost: context.callContext.currentGasCost };
+      }
+    };
+    this.impureCircuits = {
+      signBidirectional: this.circuits.signBidirectional
+    };
+    this.provableCircuits = {
+      signBidirectional: this.circuits.signBidirectional
+    };
+  }
+  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();
+    state_0.data = new __compactRuntime.ChargedState(stateValue_0);
+    state_0.setOperation('signBidirectional', 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: []
+    };
+    state_0.data = new __compactRuntime.ChargedState(context.callContext.currentQueryContext.state.state);
+    return {
+      currentContractState: state_0,
+      currentPrivateState: context.callContext.currentPrivateState,
+      currentZswapLocalState: context.callContext.currentZswapLocalState
+    }
+  }
+  async _signBidirectional_0(context,
+                             partialProofData,
+                             requestId_0,
+                             notification_0)
+  {
+    let t_0;
+    __compactRuntime.queryLedgerState(context,
+                                      partialProofData,
+                                      [
+                                       { push: { storage: false,
+                                                 value: __compactRuntime.StateValue.newArray()
+                                                          .arrayPush(__compactRuntime.StateValue.newCell({ value: _descriptor_13.toValue(1n),
+                                                                                                           alignment: _descriptor_13.alignment() })).arrayPush(__compactRuntime.StateValue.newCell({ value: _descriptor_2.toValue(10n),
+                                                                                                                                                                                                     alignment: _descriptor_2.alignment() })).arrayPush(__compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue((t_0 = { name:
+                                                                                                                                                                                                                                                                                                                                      new Uint8Array([83, 105, 103, 110, 66, 105, 100, 105, 114, 101, 99, 116, 105, 111, 110, 97, 108, 69, 118, 101, 110, 116, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+                                                                                                                                                                                                                                                                                                                                    payload:
+                                                                                                                                                                                                                                                                                                                                      Uint8Array.from([notification_0.version,
+                                                                                                                                                                                                                                                                                                                                                       ...Array.from(requestId_0,
+                                                                                                                                                                                                                                                                                                                                                                     BigInt),
+                                                                                                                                                                                                                                                                                                                                                       ...Array.from(notification_0.payload,
+                                                                                                                                                                                                                                                                                                                                                                     BigInt),
+                                                                                                                                                                                                                                                                                                                                                       ...Array.from(new Uint8Array(95),
+                                                                                                                                                                                                                                                                                                                                                                     BigInt)],
+                                                                                                                                                                                                                                                                                                                                                      Number) },
+                                                                                                                                                                                                                                                                                                                            Uint8Array.from([...Array.from(t_0.name,
+                                                                                                                                                                                                                                                                                                                                                           BigInt),
+                                                                                                                                                                                                                                                                                                                                             ...Array.from(t_0.payload,
+                                                                                                                                                                                                                                                                                                                                                           BigInt)],
+                                                                                                                                                                                                                                                                                                                                            Number))),
+                                                                                                                                                                                                                                                                                              alignment: _descriptor_0.alignment() }))
+                                                          .encode() } },
+                                       'log']);
+    return [];
+  }
+}
+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 {
+  };
+}
+const _emptyContext = {
+  callContext: { currentQueryContext: new __compactRuntime.QueryContext(new __compactRuntime.ContractState().data, __compactRuntime.dummyContractAddress()), currentGasCost: __compactRuntime.emptyRunningCost() }
+};
+const _dummyContract = new Contract({ });
+export const pureCircuits = {};
+export const expectedVk = {
+  'signBidirectional': 'db4268c2740ee34ea5c1297b9fdf21c9eab5cd4f95b1d692ccab981520db71e7',
+};
+
+export const circuitSignatures = {
+  'signBidirectional': {pure: false, provable: true, argumentTypes: [{tag: 'Alias', name: 'RequestId', type: {tag: 'Bytes', length: 32}}, {tag: 'Struct', name: 'SignBidirectionalEventNotification', elements: [{name: 'version', type: {tag: 'Uint', maxval: '255'}}, {name: 'payload', type: {tag: 'Bytes', length: 128}}]}], resultType: {tag: 'Tuple', types: []}},
+};
+
+export const declaredInterfaces = {};
+
+//# sourceMappingURL=index.js.map

package/dist/managed/contract/index.js.map

@@ -0,0 +1,8 @@
+{
+  "version": 3,
+  "file": "index.js",
+  "sourceRoot": "../../../",
+  "sources": ["src/signet-signer.compact"],
+  "names": [],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAA;;;;;;;;;;MA6BA,AAAA,iBAaC;;;;;cAZK,WAAoB;cACpB,cAAgD;;;;;;;;;;;;;;;;;;;;;;;;;yCADhD,WAAoB,+BACpB,cAAgD;;;;;;;;;yDADhD,WAAoB;yDACpB,cAAgD;;;;OAWrD;;;;;;;;GACA;EA3CD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CC;EAdD,AAAA,0BAaC;;6BAZK,WAAoB;6BACpB,cAAgD;;QAElD,GAQE;;;;;;;;;;;uVALe,cAAY;qWACT,WAAS;;qWACT,cAAY;;;;;2VALhC,GAQE;;2VARF,GAQE;;;;;;;GACL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"
+}

package/dist/managed/keys/signBidirectional.prover

@@ -0,0 +1,4 @@
+[diffend] Oversized file quarantined before diffing.
+name: package/dist/managed/keys/signBidirectional.prover
+size: 113268984 bytes
+sha256: 9c7a528f2eefbf2491f1ad2036f289271d178e5ff6eac967381a70e3b938cb62