@ocap/mcrypto 1.31.8 → 1.32.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (49) hide show
  1. package/esm/bridge-governance/evm-abi.d.mts +179 -0
  2. package/esm/bridge-governance/evm-abi.mjs +344 -0
  3. package/esm/bridge-governance/evm-proposals.d.mts +39 -0
  4. package/esm/bridge-governance/evm-proposals.mjs +345 -0
  5. package/esm/bridge-governance/evm-sync.d.mts +45 -0
  6. package/esm/bridge-governance/evm-sync.mjs +120 -0
  7. package/esm/bridge-governance/index.d.mts +8 -0
  8. package/esm/bridge-governance/index.mjs +9 -0
  9. package/esm/bridge-governance/keys.d.mts +60 -0
  10. package/esm/bridge-governance/keys.mjs +224 -0
  11. package/esm/bridge-governance/membership.d.mts +116 -0
  12. package/esm/bridge-governance/membership.mjs +175 -0
  13. package/esm/bridge-governance/ocap-proposals.d.mts +132 -0
  14. package/esm/bridge-governance/ocap-proposals.mjs +481 -0
  15. package/esm/bridge-governance/strict-json.d.mts +8 -0
  16. package/esm/bridge-governance/strict-json.mjs +102 -0
  17. package/esm/bridge-governance.d.mts +9 -116
  18. package/esm/bridge-governance.mjs +8 -174
  19. package/esm/envelope.mjs +28 -1
  20. package/esm/index.d.mts +10 -2
  21. package/esm/index.mjs +8 -2
  22. package/esm/signer/ethereum.mjs +2 -2
  23. package/esm/signer/secp256k1.d.mts +5 -0
  24. package/esm/signer/secp256k1.mjs +18 -0
  25. package/lib/_vendor/@noble/hashes/utils.cjs +19 -1
  26. package/lib/bridge-governance/evm-abi.cjs +362 -0
  27. package/lib/bridge-governance/evm-abi.d.cts +179 -0
  28. package/lib/bridge-governance/evm-proposals.cjs +353 -0
  29. package/lib/bridge-governance/evm-proposals.d.cts +39 -0
  30. package/lib/bridge-governance/evm-sync.cjs +130 -0
  31. package/lib/bridge-governance/evm-sync.d.cts +45 -0
  32. package/lib/bridge-governance/index.cjs +129 -0
  33. package/lib/bridge-governance/index.d.cts +8 -0
  34. package/lib/bridge-governance/keys.cjs +273 -0
  35. package/lib/bridge-governance/keys.d.cts +60 -0
  36. package/lib/bridge-governance/membership.cjs +195 -0
  37. package/lib/bridge-governance/membership.d.cts +116 -0
  38. package/lib/bridge-governance/ocap-proposals.cjs +491 -0
  39. package/lib/bridge-governance/ocap-proposals.d.cts +132 -0
  40. package/lib/bridge-governance/strict-json.cjs +103 -0
  41. package/lib/bridge-governance/strict-json.d.cts +8 -0
  42. package/lib/bridge-governance.cjs +128 -194
  43. package/lib/bridge-governance.d.cts +8 -116
  44. package/lib/envelope.cjs +28 -1
  45. package/lib/index.cjs +128 -21
  46. package/lib/index.d.cts +9 -2
  47. package/lib/signer/secp256k1.cjs +18 -0
  48. package/lib/signer/secp256k1.d.cts +5 -0
  49. package/package.json +2 -2
@@ -0,0 +1,195 @@
1
+ const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
2
+ const require_utils = require('../_vendor/@noble/hashes/utils.cjs');
3
+ const require_secp256k1 = require('../_vendor/@noble/curves/secp256k1.cjs');
4
+ const require_sha3 = require('../_vendor/@noble/hashes/sha3.cjs');
5
+ let _ocap_util = require("@ocap/util");
6
+
7
+ //#region src/bridge-governance/membership.ts
8
+ /**
9
+ * EIP-712 structs the on-chain bridge governance (bridge/docs/ocap-protocols.md §v2.2) verifies on the OCAP side:
10
+ * `BridgeMembership` (operator consent / join / leave) and `BridgeOwnerAttestation` (Ethereum owner proof).
11
+ *
12
+ * This is a port of `membership.ts` in `@arcblock/bridge-types` (bridge/types/src/membership.ts). Core packages cannot
13
+ * depend on the private bridge workspace, so the logic is duplicated on purpose and a parity test
14
+ * (core/mcrypto/tests/bridge-governance.spec.ts) runs this port against the vector file
15
+ * bridge/types/vectors/membership.json, which is generated from viem (what wallets run). Change both together.
16
+ *
17
+ * Domain: `{ name: "ArcBridgeOcap", version: "1" }` with NO chainId / verifyingContract; the OCAP chain and the bridge
18
+ * are carried inside the struct (`ocapChainId`, `bridge`), so an approval cannot be replayed across chains or bridges.
19
+ */
20
+ const BRIDGE_GOV_DOMAIN_NAME = "ArcBridgeOcap";
21
+ const BRIDGE_GOV_DOMAIN_VERSION = "1";
22
+ const BRIDGE_MEMBERSHIP_TYPE_STRING = "BridgeMembership(string ocapChainId,string bridge,uint64 epoch,address[] validators,uint32 threshold,uint64 activeFrom,uint64 voucherValidity,bytes32 endpointsHash,uint8 action)";
23
+ const BRIDGE_OWNER_ATTESTATION_TYPE_STRING = "BridgeOwnerAttestation(string ocapChainId,bytes32 salt,string ocapToken,uint256 ethChainId,address gateway,address ethToken)";
24
+ /** `action` of a BridgeMembership: CREATE = epoch 1 consent, JOIN / LEAVE = epoch change. */
25
+ const BRIDGE_MEMBERSHIP_ACTION = {
26
+ CREATE: 0,
27
+ JOIN: 1,
28
+ LEAVE: 2
29
+ };
30
+ const utf8 = (s) => new Uint8Array(Buffer.from(s, "utf8"));
31
+ const keccakUtf8 = (s) => require_sha3.keccak_256(utf8(s));
32
+ const concat = (...parts) => new Uint8Array(Buffer.concat(parts));
33
+ const DOMAIN_TYPEHASH = keccakUtf8("EIP712Domain(string name,string version)");
34
+ const MEMBERSHIP_TYPEHASH = keccakUtf8(BRIDGE_MEMBERSHIP_TYPE_STRING);
35
+ const ATTESTATION_TYPEHASH = keccakUtf8(BRIDGE_OWNER_ATTESTATION_TYPE_STRING);
36
+ const DOMAIN_SEPARATOR = require_sha3.keccak_256(concat(DOMAIN_TYPEHASH, keccakUtf8(BRIDGE_GOV_DOMAIN_NAME), keccakUtf8(BRIDGE_GOV_DOMAIN_VERSION)));
37
+ function uintWord(value, bits, name) {
38
+ let n;
39
+ try {
40
+ n = typeof value === "bigint" ? value : BigInt(value);
41
+ } catch {
42
+ throw new Error(`${name} is not an integer`);
43
+ }
44
+ if (n < 0n || n >= 1n << BigInt(bits)) throw new Error(`${name} does not fit uint${bits}`);
45
+ return new Uint8Array(Buffer.from(n.toString(16).padStart(64, "0"), "hex"));
46
+ }
47
+ function addressWord(value, name) {
48
+ if (typeof value !== "string" || !/^0x[0-9a-fA-F]{40}$/.test(value)) throw new Error(`${name} is not an address`);
49
+ return new Uint8Array(Buffer.from(value.slice(2).toLowerCase().padStart(64, "0"), "hex"));
50
+ }
51
+ function bytes32Word(value, name) {
52
+ if (typeof value !== "string" || !/^0x[0-9a-fA-F]{64}$/.test(value)) throw new Error(`${name} is not a bytes32`);
53
+ return new Uint8Array(Buffer.from(value.slice(2), "hex"));
54
+ }
55
+ function digestOf(structHash) {
56
+ return require_sha3.keccak_256(concat(new Uint8Array([25, 1]), DOMAIN_SEPARATOR, structHash));
57
+ }
58
+ /**
59
+ * `keccak256(keccak256(endpoint_0) || keccak256(endpoint_1) || ...)` over the endpoints of the validators in the order
60
+ * of the signed `validators` array. It binds every listed operator to the URL it is reachable at, so a creator cannot
61
+ * pair a victim operator with another URL.
62
+ */
63
+ function computeBridgeEndpointsHash(endpoints) {
64
+ if (!Array.isArray(endpoints)) throw new Error("endpoints is not an array");
65
+ return `0x${require_utils.bytesToHex(require_sha3.keccak_256(concat(...endpoints.map((e) => keccakUtf8(String(e))))))}`;
66
+ }
67
+ function computeBridgeMembershipDigest(m) {
68
+ if (!Array.isArray(m.validators)) throw new Error("validators is not an array");
69
+ const validators = require_sha3.keccak_256(concat(...m.validators.map((a, i) => addressWord(a, `validators[${i}]`))));
70
+ return digestOf(require_sha3.keccak_256(concat(MEMBERSHIP_TYPEHASH, keccakUtf8(m.ocapChainId), keccakUtf8(m.bridge), uintWord(m.epoch, 64, "epoch"), validators, uintWord(m.threshold, 32, "threshold"), uintWord(m.activeFrom, 64, "activeFrom"), uintWord(m.voucherValidity, 64, "voucherValidity"), bytes32Word(m.endpointsHash, "endpointsHash"), uintWord(m.action, 8, "action"))));
71
+ }
72
+ function computeBridgeOwnerAttestationDigest(m) {
73
+ return digestOf(require_sha3.keccak_256(concat(ATTESTATION_TYPEHASH, keccakUtf8(m.ocapChainId), bytes32Word(m.salt, "salt"), keccakUtf8(m.ocapToken), uintWord(m.ethChainId, 256, "ethChainId"), addressWord(m.gateway, "gateway"), addressWord(m.ethToken, "ethToken"))));
74
+ }
75
+ /** Ethereum address (lowercase 0x) of an uncompressed (64/65 bytes) or compressed secp256k1 public key. */
76
+ function ethAddressOfPublicKey(pk) {
77
+ const bytes = (0, _ocap_util.toUint8Array)(pk);
78
+ return `0x${require_utils.bytesToHex(require_sha3.keccak_256(bytes.byteLength === 64 ? bytes : bytes.byteLength === 65 ? bytes.slice(1) : require_secp256k1.secp256k1.Point.fromBytes(bytes).toBytes(false).slice(1)).slice(12))}`;
79
+ }
80
+ /**
81
+ * Recover the signer of a canonical 65-byte `r || s || v` signature (`v` in {27, 28}, low-S). Returns null on anything
82
+ * else, so a malleable or malformed signature never recovers to an address.
83
+ */
84
+ function recoverBridgeSigner(digest, signature) {
85
+ if (typeof signature !== "string" || !/^0x[0-9a-fA-F]{130}$/.test(signature)) return null;
86
+ const hex = signature.slice(2);
87
+ const v = Number.parseInt(hex.slice(128, 130), 16);
88
+ if (v !== 27 && v !== 28) return null;
89
+ try {
90
+ const sig = require_secp256k1.secp256k1.Signature.fromHex(hex.slice(0, 128), "compact").addRecoveryBit(v - 27);
91
+ if (sig.hasHighS()) return null;
92
+ const publicKey = sig.recoverPublicKey(digest).toBytes(false);
93
+ return {
94
+ address: ethAddressOfPublicKey(publicKey),
95
+ publicKey
96
+ };
97
+ } catch {
98
+ return null;
99
+ }
100
+ }
101
+ /** Sign a governance digest with a secp256k1 secret key; returns the 65-byte `0x{r}{s}{v}` signature. */
102
+ function signBridgeDigest(digest, sk) {
103
+ const recovered = require_secp256k1.secp256k1.sign(digest, (0, _ocap_util.toUint8Array)(sk), {
104
+ prehash: false,
105
+ format: "recovered"
106
+ });
107
+ const sig = require_secp256k1.secp256k1.Signature.fromBytes(recovered, "recovered");
108
+ const v = (27 + sig.recovery).toString(16).padStart(2, "0");
109
+ return `0x${sig.toHex("compact")}${v}`;
110
+ }
111
+ const toHexDigest = (digest) => `0x${require_utils.bytesToHex(digest)}`;
112
+ /**
113
+ * keccak256 of `utf8(prefix) || words`: the key preimage helper for the `arc-bridge:*` evidence keys. Every dynamic part
114
+ * is a fixed-width word (uint256 / address / bytes32) or the trailing DID string, so two different tuples never share a
115
+ * preimage. Returns a `0x` + 64 hex string (the evidence table key shape).
116
+ */
117
+ function bridgeEvidenceKey(prefix, parts) {
118
+ const chunks = [utf8(prefix)];
119
+ parts.forEach((p, i) => {
120
+ if ("uint" in p) chunks.push(uintWord(p.uint, 256, `part[${i}]`));
121
+ else if ("address" in p) chunks.push(addressWord(p.address, `part[${i}]`));
122
+ else if ("bytes32" in p) chunks.push(bytes32Word(p.bytes32, `part[${i}]`));
123
+ else {
124
+ if (i !== parts.length - 1) throw new Error("text part must be last");
125
+ chunks.push(utf8(p.text));
126
+ }
127
+ });
128
+ return `0x${require_utils.bytesToHex(require_sha3.keccak_256(concat(...chunks)))}`;
129
+ }
130
+ /**
131
+ * Evidence keys of a bridge release (`deposit_token_v2` kind 1/2/3) are SELF-IDENTIFYING: a 3-character tag (`rt:` tombstone, `rb:` bucket) and the
132
+ * first 63 hex digits of the keccak digest of the `bridgeEvidenceKey` preimage, 66 characters in total.
133
+ *
134
+ * Legacy rollup v1 protocols store evidence rows at a caller-chosen key validated only by `patterns.txHash`
135
+ * (`^(0x)?[0-9a-fA-F]{64}$`). `r` and `:` are not hex digits, so no key a v1 tx (or any other `txHash`-validated input) can
136
+ * carry ever lands in this key space, and the gate can tell a release row by its key alone. 66 characters is exactly the
137
+ * width of a `0x` + 64 hex key, so every statedb backend that stores today's evidence keys stores these. The `:` also
138
+ * keeps the key from ever parsing as a DID (base58 has no `:`). 252 bits of keccak keep collision resistance at 2^126.
139
+ */
140
+ const BRIDGE_RELEASE_TOMBSTONE_TAG = "rt:";
141
+ const BRIDGE_RELEASE_BUCKET_TAG = "rb:";
142
+ const RELEASE_TOMBSTONE_DOMAIN = "arc-bridge:release:";
143
+ const RELEASE_BUCKET_DOMAIN = "arc-bridge:release-bucket:";
144
+ /** a canonical release key: tag + 63 lowercase hex */
145
+ const BRIDGE_RELEASE_KEY_PATTERN = /^r[tb]:[0-9a-f]{63}$/;
146
+ const releaseKey = (tag, domain, parts) => `${tag}${bridgeEvidenceKey(domain, parts).slice(2, 65)}`;
147
+ /**
148
+ * Tombstone key of a release: `rt:` + keccak256("arc-bridge:release:" || uint kind || bytes32 evidence || uint ordinal ||
149
+ * bridge). `evidence` is a `0x` bytes32 (lowercased here); `bridge` the canonical bridge address.
150
+ */
151
+ function bridgeReleaseTombstoneKey(bridge, kind, evidence, ordinal) {
152
+ return releaseKey(BRIDGE_RELEASE_TOMBSTONE_TAG, RELEASE_TOMBSTONE_DOMAIN, [
153
+ { uint: kind },
154
+ { bytes32: String(evidence).toLowerCase() },
155
+ { uint: ordinal },
156
+ { text: bridge }
157
+ ]);
158
+ }
159
+ /** Key of slot `slot` of ring `ring` (0 = deposit, 1 = refund) of `bridge`: `rb:` + keccak256("arc-bridge:release-bucket:" || uint ring || uint slot || bridge). */
160
+ function bridgeReleaseBucketKey(bridge, ring, slot) {
161
+ return releaseKey(BRIDGE_RELEASE_BUCKET_TAG, RELEASE_BUCKET_DOMAIN, [
162
+ { uint: ring },
163
+ { uint: slot },
164
+ { text: bridge }
165
+ ]);
166
+ }
167
+ /** Whether `key` is a canonical release key (tombstone or bucket). */
168
+ const isBridgeReleaseKey = (key) => typeof key === "string" && BRIDGE_RELEASE_KEY_PATTERN.test(key);
169
+ /**
170
+ * Whether `key` is in the release key space in ANY spelling (case, surrounding whitespace): what the gate refuses to any
171
+ * tx type but a bridge release.
172
+ */
173
+ const inBridgeReleaseKeySpace = (key) => typeof key === "string" && /^r[tb]:/i.test(key.trim());
174
+
175
+ //#endregion
176
+ exports.BRIDGE_GOV_DOMAIN_NAME = BRIDGE_GOV_DOMAIN_NAME;
177
+ exports.BRIDGE_GOV_DOMAIN_VERSION = BRIDGE_GOV_DOMAIN_VERSION;
178
+ exports.BRIDGE_MEMBERSHIP_ACTION = BRIDGE_MEMBERSHIP_ACTION;
179
+ exports.BRIDGE_MEMBERSHIP_TYPE_STRING = BRIDGE_MEMBERSHIP_TYPE_STRING;
180
+ exports.BRIDGE_OWNER_ATTESTATION_TYPE_STRING = BRIDGE_OWNER_ATTESTATION_TYPE_STRING;
181
+ exports.BRIDGE_RELEASE_BUCKET_TAG = BRIDGE_RELEASE_BUCKET_TAG;
182
+ exports.BRIDGE_RELEASE_KEY_PATTERN = BRIDGE_RELEASE_KEY_PATTERN;
183
+ exports.BRIDGE_RELEASE_TOMBSTONE_TAG = BRIDGE_RELEASE_TOMBSTONE_TAG;
184
+ exports.bridgeEvidenceKey = bridgeEvidenceKey;
185
+ exports.bridgeReleaseBucketKey = bridgeReleaseBucketKey;
186
+ exports.bridgeReleaseTombstoneKey = bridgeReleaseTombstoneKey;
187
+ exports.computeBridgeEndpointsHash = computeBridgeEndpointsHash;
188
+ exports.computeBridgeMembershipDigest = computeBridgeMembershipDigest;
189
+ exports.computeBridgeOwnerAttestationDigest = computeBridgeOwnerAttestationDigest;
190
+ exports.ethAddressOfPublicKey = ethAddressOfPublicKey;
191
+ exports.inBridgeReleaseKeySpace = inBridgeReleaseKeySpace;
192
+ exports.isBridgeReleaseKey = isBridgeReleaseKey;
193
+ exports.recoverBridgeSigner = recoverBridgeSigner;
194
+ exports.signBridgeDigest = signBridgeDigest;
195
+ exports.toHexDigest = toHexDigest;
@@ -0,0 +1,116 @@
1
+ import { BytesType } from "@ocap/util";
2
+
3
+ //#region src/bridge-governance/membership.d.ts
4
+
5
+ /**
6
+ * EIP-712 structs the on-chain bridge governance (bridge/docs/ocap-protocols.md §v2.2) verifies on the OCAP side:
7
+ * `BridgeMembership` (operator consent / join / leave) and `BridgeOwnerAttestation` (Ethereum owner proof).
8
+ *
9
+ * This is a port of `membership.ts` in `@arcblock/bridge-types` (bridge/types/src/membership.ts). Core packages cannot
10
+ * depend on the private bridge workspace, so the logic is duplicated on purpose and a parity test
11
+ * (core/mcrypto/tests/bridge-governance.spec.ts) runs this port against the vector file
12
+ * bridge/types/vectors/membership.json, which is generated from viem (what wallets run). Change both together.
13
+ *
14
+ * Domain: `{ name: "ArcBridgeOcap", version: "1" }` with NO chainId / verifyingContract; the OCAP chain and the bridge
15
+ * are carried inside the struct (`ocapChainId`, `bridge`), so an approval cannot be replayed across chains or bridges.
16
+ */
17
+ declare const BRIDGE_GOV_DOMAIN_NAME = "ArcBridgeOcap";
18
+ declare const BRIDGE_GOV_DOMAIN_VERSION = "1";
19
+ declare const BRIDGE_MEMBERSHIP_TYPE_STRING = "BridgeMembership(string ocapChainId,string bridge,uint64 epoch,address[] validators,uint32 threshold,uint64 activeFrom,uint64 voucherValidity,bytes32 endpointsHash,uint8 action)";
20
+ declare const BRIDGE_OWNER_ATTESTATION_TYPE_STRING = "BridgeOwnerAttestation(string ocapChainId,bytes32 salt,string ocapToken,uint256 ethChainId,address gateway,address ethToken)";
21
+ /** `action` of a BridgeMembership: CREATE = epoch 1 consent, JOIN / LEAVE = epoch change. */
22
+ declare const BRIDGE_MEMBERSHIP_ACTION: {
23
+ readonly CREATE: 0;
24
+ readonly JOIN: 1;
25
+ readonly LEAVE: 2;
26
+ };
27
+ interface BridgeMembershipMessage {
28
+ ocapChainId: string;
29
+ bridge: string;
30
+ epoch: bigint | number | string;
31
+ /** Strictly ascending (numeric) and unique: the signer signs exactly this order. */
32
+ validators: string[];
33
+ threshold: number;
34
+ activeFrom: bigint | number | string;
35
+ voucherValidity: bigint | number | string;
36
+ /** `computeBridgeEndpointsHash` of the endpoints of `validators`, in the same order */
37
+ endpointsHash: string;
38
+ action: number;
39
+ }
40
+ interface BridgeOwnerAttestationMessage {
41
+ ocapChainId: string;
42
+ salt: string;
43
+ ocapToken: string;
44
+ ethChainId: bigint | number | string;
45
+ gateway: string;
46
+ ethToken: string;
47
+ }
48
+ /**
49
+ * `keccak256(keccak256(endpoint_0) || keccak256(endpoint_1) || ...)` over the endpoints of the validators in the order
50
+ * of the signed `validators` array. It binds every listed operator to the URL it is reachable at, so a creator cannot
51
+ * pair a victim operator with another URL.
52
+ */
53
+ declare function computeBridgeEndpointsHash(endpoints: string[]): string;
54
+ declare function computeBridgeMembershipDigest(m: BridgeMembershipMessage): Uint8Array;
55
+ declare function computeBridgeOwnerAttestationDigest(m: BridgeOwnerAttestationMessage): Uint8Array;
56
+ /** Ethereum address (lowercase 0x) of an uncompressed (64/65 bytes) or compressed secp256k1 public key. */
57
+ declare function ethAddressOfPublicKey(pk: BytesType): string;
58
+ interface RecoveredBridgeSigner {
59
+ /** lowercase 0x address */
60
+ address: string;
61
+ /** 65-byte uncompressed public key, 0x04 prefixed */
62
+ publicKey: Uint8Array;
63
+ }
64
+ /**
65
+ * Recover the signer of a canonical 65-byte `r || s || v` signature (`v` in {27, 28}, low-S). Returns null on anything
66
+ * else, so a malleable or malformed signature never recovers to an address.
67
+ */
68
+ declare function recoverBridgeSigner(digest: Uint8Array, signature: string): RecoveredBridgeSigner | null;
69
+ /** Sign a governance digest with a secp256k1 secret key; returns the 65-byte `0x{r}{s}{v}` signature. */
70
+ declare function signBridgeDigest(digest: Uint8Array, sk: BytesType): string;
71
+ declare const toHexDigest: (digest: Uint8Array) => string;
72
+ type BridgeKeyPart = {
73
+ uint: bigint | number | string;
74
+ } | {
75
+ address: string;
76
+ } | {
77
+ bytes32: string;
78
+ } | {
79
+ text: string;
80
+ };
81
+ /**
82
+ * keccak256 of `utf8(prefix) || words`: the key preimage helper for the `arc-bridge:*` evidence keys. Every dynamic part
83
+ * is a fixed-width word (uint256 / address / bytes32) or the trailing DID string, so two different tuples never share a
84
+ * preimage. Returns a `0x` + 64 hex string (the evidence table key shape).
85
+ */
86
+ declare function bridgeEvidenceKey(prefix: string, parts: BridgeKeyPart[]): string;
87
+ /**
88
+ * Evidence keys of a bridge release (`deposit_token_v2` kind 1/2/3) are SELF-IDENTIFYING: a 3-character tag (`rt:` tombstone, `rb:` bucket) and the
89
+ * first 63 hex digits of the keccak digest of the `bridgeEvidenceKey` preimage, 66 characters in total.
90
+ *
91
+ * Legacy rollup v1 protocols store evidence rows at a caller-chosen key validated only by `patterns.txHash`
92
+ * (`^(0x)?[0-9a-fA-F]{64}$`). `r` and `:` are not hex digits, so no key a v1 tx (or any other `txHash`-validated input) can
93
+ * carry ever lands in this key space, and the gate can tell a release row by its key alone. 66 characters is exactly the
94
+ * width of a `0x` + 64 hex key, so every statedb backend that stores today's evidence keys stores these. The `:` also
95
+ * keeps the key from ever parsing as a DID (base58 has no `:`). 252 bits of keccak keep collision resistance at 2^126.
96
+ */
97
+ declare const BRIDGE_RELEASE_TOMBSTONE_TAG = "rt:";
98
+ declare const BRIDGE_RELEASE_BUCKET_TAG = "rb:";
99
+ /** a canonical release key: tag + 63 lowercase hex */
100
+ declare const BRIDGE_RELEASE_KEY_PATTERN: RegExp;
101
+ /**
102
+ * Tombstone key of a release: `rt:` + keccak256("arc-bridge:release:" || uint kind || bytes32 evidence || uint ordinal ||
103
+ * bridge). `evidence` is a `0x` bytes32 (lowercased here); `bridge` the canonical bridge address.
104
+ */
105
+ declare function bridgeReleaseTombstoneKey(bridge: string, kind: number | bigint | string, evidence: string, ordinal: number | bigint | string): string;
106
+ /** Key of slot `slot` of ring `ring` (0 = deposit, 1 = refund) of `bridge`: `rb:` + keccak256("arc-bridge:release-bucket:" || uint ring || uint slot || bridge). */
107
+ declare function bridgeReleaseBucketKey(bridge: string, ring: number, slot: number): string;
108
+ /** Whether `key` is a canonical release key (tombstone or bucket). */
109
+ declare const isBridgeReleaseKey: (key: unknown) => boolean;
110
+ /**
111
+ * Whether `key` is in the release key space in ANY spelling (case, surrounding whitespace): what the gate refuses to any
112
+ * tx type but a bridge release.
113
+ */
114
+ declare const inBridgeReleaseKeySpace: (key: unknown) => boolean;
115
+ //#endregion
116
+ export { BRIDGE_GOV_DOMAIN_NAME, BRIDGE_GOV_DOMAIN_VERSION, BRIDGE_MEMBERSHIP_ACTION, BRIDGE_MEMBERSHIP_TYPE_STRING, BRIDGE_OWNER_ATTESTATION_TYPE_STRING, BRIDGE_RELEASE_BUCKET_TAG, BRIDGE_RELEASE_KEY_PATTERN, BRIDGE_RELEASE_TOMBSTONE_TAG, BridgeKeyPart, BridgeMembershipMessage, BridgeOwnerAttestationMessage, RecoveredBridgeSigner, bridgeEvidenceKey, bridgeReleaseBucketKey, bridgeReleaseTombstoneKey, computeBridgeEndpointsHash, computeBridgeMembershipDigest, computeBridgeOwnerAttestationDigest, ethAddressOfPublicKey, inBridgeReleaseKeySpace, isBridgeReleaseKey, recoverBridgeSigner, signBridgeDigest, toHexDigest };