@ocap/mcrypto 1.31.9 → 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.
- package/esm/bridge-governance/evm-abi.d.mts +179 -0
- package/esm/bridge-governance/evm-abi.mjs +344 -0
- package/esm/bridge-governance/evm-proposals.d.mts +39 -0
- package/esm/bridge-governance/evm-proposals.mjs +345 -0
- package/esm/bridge-governance/evm-sync.d.mts +45 -0
- package/esm/bridge-governance/evm-sync.mjs +120 -0
- package/esm/bridge-governance/index.d.mts +8 -0
- package/esm/bridge-governance/index.mjs +9 -0
- package/esm/bridge-governance/keys.d.mts +60 -0
- package/esm/bridge-governance/keys.mjs +224 -0
- package/esm/bridge-governance/membership.d.mts +116 -0
- package/esm/bridge-governance/membership.mjs +175 -0
- package/esm/bridge-governance/ocap-proposals.d.mts +132 -0
- package/esm/bridge-governance/ocap-proposals.mjs +481 -0
- package/esm/bridge-governance/strict-json.d.mts +8 -0
- package/esm/bridge-governance/strict-json.mjs +102 -0
- package/esm/bridge-governance.d.mts +9 -116
- package/esm/bridge-governance.mjs +8 -174
- package/esm/envelope.mjs +28 -1
- package/esm/index.d.mts +10 -2
- package/esm/index.mjs +8 -2
- package/esm/signer/ethereum.mjs +2 -2
- package/esm/signer/secp256k1.d.mts +5 -0
- package/esm/signer/secp256k1.mjs +18 -0
- package/lib/_vendor/@noble/hashes/utils.cjs +19 -1
- package/lib/bridge-governance/evm-abi.cjs +362 -0
- package/lib/bridge-governance/evm-abi.d.cts +179 -0
- package/lib/bridge-governance/evm-proposals.cjs +353 -0
- package/lib/bridge-governance/evm-proposals.d.cts +39 -0
- package/lib/bridge-governance/evm-sync.cjs +130 -0
- package/lib/bridge-governance/evm-sync.d.cts +45 -0
- package/lib/bridge-governance/index.cjs +129 -0
- package/lib/bridge-governance/index.d.cts +8 -0
- package/lib/bridge-governance/keys.cjs +273 -0
- package/lib/bridge-governance/keys.d.cts +60 -0
- package/lib/bridge-governance/membership.cjs +195 -0
- package/lib/bridge-governance/membership.d.cts +116 -0
- package/lib/bridge-governance/ocap-proposals.cjs +491 -0
- package/lib/bridge-governance/ocap-proposals.d.cts +132 -0
- package/lib/bridge-governance/strict-json.cjs +103 -0
- package/lib/bridge-governance/strict-json.d.cts +8 -0
- package/lib/bridge-governance.cjs +128 -194
- package/lib/bridge-governance.d.cts +8 -116
- package/lib/envelope.cjs +28 -1
- package/lib/index.cjs +128 -21
- package/lib/index.d.cts +9 -2
- package/lib/signer/secp256k1.cjs +18 -0
- package/lib/signer/secp256k1.d.cts +5 -0
- package/package.json +2 -2
|
@@ -0,0 +1,491 @@
|
|
|
1
|
+
const require_utils = require('../_vendor/@noble/hashes/utils.cjs');
|
|
2
|
+
const require_sha3 = require('../_vendor/@noble/hashes/sha3.cjs');
|
|
3
|
+
const require_bridge_governance_membership = require('./membership.cjs');
|
|
4
|
+
const require_bridge_governance_keys = require('./keys.cjs');
|
|
5
|
+
const require_bridge_governance_strict_json = require('./strict-json.cjs');
|
|
6
|
+
const require_bridge_governance_evm_abi = require('./evm-abi.cjs');
|
|
7
|
+
const require_bridge_governance_evm_sync = require('./evm-sync.cjs');
|
|
8
|
+
|
|
9
|
+
//#region src/bridge-governance/ocap-proposals.ts
|
|
10
|
+
const BARE_DID_RE = /^z[1-9A-HJ-NP-Za-km-z]{20,60}$/;
|
|
11
|
+
const LOCKSTEP_KEYS = [
|
|
12
|
+
"txFrom",
|
|
13
|
+
"frozenNonce",
|
|
14
|
+
"signerRoster",
|
|
15
|
+
"unsignedTxBytesHex",
|
|
16
|
+
"challenge"
|
|
17
|
+
];
|
|
18
|
+
const SINGLE_META_KEYS = [
|
|
19
|
+
"txFrom",
|
|
20
|
+
"frozenNonce",
|
|
21
|
+
"unsignedTxBytesHex",
|
|
22
|
+
"challenge"
|
|
23
|
+
];
|
|
24
|
+
const SIGNER_ROSTER_ENTRY_KEYS = new Set(["signer", "pk"]);
|
|
25
|
+
const OCAP_PROPOSAL_KEYS = new Set([
|
|
26
|
+
"version",
|
|
27
|
+
"plane",
|
|
28
|
+
"ocapChainId",
|
|
29
|
+
"ocapBridge",
|
|
30
|
+
"createdAt",
|
|
31
|
+
"expiresAt",
|
|
32
|
+
"summary",
|
|
33
|
+
"action"
|
|
34
|
+
]);
|
|
35
|
+
const OCAP_PROPOSE_OWNER_KEYS = new Set([
|
|
36
|
+
"newOwner",
|
|
37
|
+
"newOwnerPk",
|
|
38
|
+
"endpoint"
|
|
39
|
+
]);
|
|
40
|
+
const OCAP_PATCH_BIGINT_KEYS = [
|
|
41
|
+
"minDeposit",
|
|
42
|
+
"minWithdraw",
|
|
43
|
+
"maxWithdraw",
|
|
44
|
+
"releaseDailyCap",
|
|
45
|
+
"refundDailyCap"
|
|
46
|
+
];
|
|
47
|
+
const OCAP_PATCH_ALLOWED_KEYS = new Set([
|
|
48
|
+
...OCAP_PATCH_BIGINT_KEYS,
|
|
49
|
+
"releaseGrace",
|
|
50
|
+
"refundDelay",
|
|
51
|
+
"pausers",
|
|
52
|
+
"cancelPendingEpoch",
|
|
53
|
+
"proposeOwner",
|
|
54
|
+
"cancelOwnerProposal",
|
|
55
|
+
"evmGovernance"
|
|
56
|
+
]);
|
|
57
|
+
const OCAP_ACTION_ALLOWED_KEYS = {
|
|
58
|
+
join_rollup: new Set([
|
|
59
|
+
"kind",
|
|
60
|
+
"validator",
|
|
61
|
+
"endpoint",
|
|
62
|
+
"epoch",
|
|
63
|
+
"validators",
|
|
64
|
+
"endpoints",
|
|
65
|
+
"threshold",
|
|
66
|
+
"activeFrom",
|
|
67
|
+
"voucherValidity"
|
|
68
|
+
]),
|
|
69
|
+
leave_rollup: new Set([
|
|
70
|
+
"kind",
|
|
71
|
+
"validator",
|
|
72
|
+
"epoch",
|
|
73
|
+
"validators",
|
|
74
|
+
"endpoints",
|
|
75
|
+
"threshold",
|
|
76
|
+
"activeFrom",
|
|
77
|
+
"voucherValidity"
|
|
78
|
+
]),
|
|
79
|
+
pause_rollup: new Set([
|
|
80
|
+
"kind",
|
|
81
|
+
"mode",
|
|
82
|
+
"reason",
|
|
83
|
+
...LOCKSTEP_KEYS
|
|
84
|
+
]),
|
|
85
|
+
resume_rollup: new Set([
|
|
86
|
+
"kind",
|
|
87
|
+
"reason",
|
|
88
|
+
...LOCKSTEP_KEYS
|
|
89
|
+
]),
|
|
90
|
+
close_rollup: new Set([
|
|
91
|
+
"kind",
|
|
92
|
+
"depositCutoffEthBlock",
|
|
93
|
+
"reason",
|
|
94
|
+
...LOCKSTEP_KEYS
|
|
95
|
+
]),
|
|
96
|
+
update_rollup: new Set([
|
|
97
|
+
"kind",
|
|
98
|
+
"patch",
|
|
99
|
+
...LOCKSTEP_KEYS
|
|
100
|
+
]),
|
|
101
|
+
migrate_rollup: new Set([
|
|
102
|
+
"kind",
|
|
103
|
+
"migrateKind",
|
|
104
|
+
"nextVault",
|
|
105
|
+
"step",
|
|
106
|
+
"targetBridge",
|
|
107
|
+
"reason",
|
|
108
|
+
...LOCKSTEP_KEYS
|
|
109
|
+
])
|
|
110
|
+
};
|
|
111
|
+
const OCAP_PAUSE_LONE_KEYS = new Set([
|
|
112
|
+
"kind",
|
|
113
|
+
"mode",
|
|
114
|
+
"reason",
|
|
115
|
+
...SINGLE_META_KEYS
|
|
116
|
+
]);
|
|
117
|
+
const OCAP_PAUSE_QUORUM_KEYS = new Set([
|
|
118
|
+
"kind",
|
|
119
|
+
"mode",
|
|
120
|
+
"reason",
|
|
121
|
+
...LOCKSTEP_KEYS
|
|
122
|
+
]);
|
|
123
|
+
const OCAP_MIGRATE_VAULT_KEYS = new Set([
|
|
124
|
+
"kind",
|
|
125
|
+
"migrateKind",
|
|
126
|
+
"nextVault",
|
|
127
|
+
"reason",
|
|
128
|
+
...LOCKSTEP_KEYS
|
|
129
|
+
]);
|
|
130
|
+
const OCAP_MIGRATE_RESERVE_QUORUM_KEYS = new Set([
|
|
131
|
+
"kind",
|
|
132
|
+
"migrateKind",
|
|
133
|
+
"step",
|
|
134
|
+
"targetBridge",
|
|
135
|
+
"reason",
|
|
136
|
+
...LOCKSTEP_KEYS
|
|
137
|
+
]);
|
|
138
|
+
const OCAP_MIGRATE_RESERVE_CANCEL_KEYS = new Set([
|
|
139
|
+
"kind",
|
|
140
|
+
"migrateKind",
|
|
141
|
+
"step",
|
|
142
|
+
"targetBridge",
|
|
143
|
+
"reason",
|
|
144
|
+
...SINGLE_META_KEYS
|
|
145
|
+
]);
|
|
146
|
+
function normalizeBareActorAddress(val, name) {
|
|
147
|
+
const raw = require_bridge_governance_keys.assertTrimmedSingleLine(val, name, 128, true);
|
|
148
|
+
if (/^did:abt:/i.test(raw)) throw new Error(`${name} must not carry a did:abt: prefix`);
|
|
149
|
+
if (/^0x[0-9a-fA-F]{40}$/.test(raw)) return require_bridge_governance_keys.checkedNonZeroAddress(raw, name);
|
|
150
|
+
if (BARE_DID_RE.test(raw)) return raw;
|
|
151
|
+
throw new Error(`${name} must be a non-zero Ethereum address or bare base58btc DID`);
|
|
152
|
+
}
|
|
153
|
+
function normalizeSignerRoster(val, name) {
|
|
154
|
+
if (!Array.isArray(val) || val.length === 0 || val.length > require_bridge_governance_keys.MAX_OCAP_VALIDATORS + 1) throw new Error(`${name} must contain 1..${require_bridge_governance_keys.MAX_OCAP_VALIDATORS + 1} signer entries`);
|
|
155
|
+
const seen = /* @__PURE__ */ new Set();
|
|
156
|
+
return val.map((item, i) => {
|
|
157
|
+
const rec = require_bridge_governance_keys.assertPlainObject(item, `${name}[${i}]`);
|
|
158
|
+
require_bridge_governance_keys.assertAllowedKeys(rec, SIGNER_ROSTER_ENTRY_KEYS, `${name}[${i}]`);
|
|
159
|
+
const signer = require_bridge_governance_keys.checkedNonZeroAddress(rec.signer, `${name}[${i}].signer`);
|
|
160
|
+
const pk = require_bridge_governance_keys.normalizeUncompressedSecp256k1Pk(require_bridge_governance_keys.assertWellFormedString(rec.pk, `${name}[${i}].pk`));
|
|
161
|
+
if (require_bridge_governance_keys.ethAddressFromUncompressedPk(pk) !== signer) throw new Error(`${name}[${i}].pk does not match Ethereum signer ${signer}`);
|
|
162
|
+
const dedup = signer.toLowerCase();
|
|
163
|
+
if (seen.has(dedup)) throw new Error(`duplicate signer in ${name}`);
|
|
164
|
+
seen.add(dedup);
|
|
165
|
+
return {
|
|
166
|
+
signer,
|
|
167
|
+
pk
|
|
168
|
+
};
|
|
169
|
+
});
|
|
170
|
+
}
|
|
171
|
+
function normalizeLockstep(rec, prefix, parseDec) {
|
|
172
|
+
const numFn = parseDec ? require_bridge_governance_keys.parseDecimalBigInt : require_bridge_governance_keys.assertBigIntRange;
|
|
173
|
+
const txFrom = require_bridge_governance_keys.checkedNonZeroAddress(rec.txFrom, `${prefix}.txFrom`);
|
|
174
|
+
const frozenNonce = numFn(rec.frozenNonce, `${prefix}.frozenNonce`, 0n, require_bridge_governance_keys.MAX_U256);
|
|
175
|
+
const signerRoster = normalizeSignerRoster(rec.signerRoster, `${prefix}.signerRoster`);
|
|
176
|
+
if (!signerRoster.some((e) => e.signer === txFrom)) throw new Error(`${prefix}.txFrom (${txFrom}) must be included in ${prefix}.signerRoster`);
|
|
177
|
+
const out = {
|
|
178
|
+
txFrom,
|
|
179
|
+
frozenNonce,
|
|
180
|
+
signerRoster
|
|
181
|
+
};
|
|
182
|
+
if (rec.unsignedTxBytesHex !== void 0) out.unsignedTxBytesHex = require_bridge_governance_keys.checkedNonEmptyHex(rec.unsignedTxBytesHex, `${prefix}.unsignedTxBytesHex`, 16384);
|
|
183
|
+
if (rec.challenge !== void 0) out.challenge = require_bridge_governance_keys.checkedBytes32(rec.challenge, `${prefix}.challenge`);
|
|
184
|
+
if (out.unsignedTxBytesHex !== void 0 && out.challenge !== void 0) {
|
|
185
|
+
if (`0x${require_utils.bytesToHex(require_sha3.keccak_256(require_utils.hexToBytes(out.unsignedTxBytesHex.slice(2))))}` !== out.challenge) throw new Error(`${prefix}.challenge does not match keccak256(${prefix}.unsignedTxBytesHex)`);
|
|
186
|
+
}
|
|
187
|
+
return out;
|
|
188
|
+
}
|
|
189
|
+
function normalizeSingleMeta(rec, prefix, parseDec) {
|
|
190
|
+
const numFn = parseDec ? require_bridge_governance_keys.parseDecimalBigInt : require_bridge_governance_keys.assertBigIntRange;
|
|
191
|
+
const out = {};
|
|
192
|
+
if (rec.txFrom !== void 0) out.txFrom = normalizeBareActorAddress(rec.txFrom, `${prefix}.txFrom`);
|
|
193
|
+
if (rec.frozenNonce !== void 0) out.frozenNonce = numFn(rec.frozenNonce, `${prefix}.frozenNonce`, 0n, require_bridge_governance_keys.MAX_U256);
|
|
194
|
+
if (rec.unsignedTxBytesHex !== void 0) out.unsignedTxBytesHex = require_bridge_governance_keys.checkedNonEmptyHex(rec.unsignedTxBytesHex, `${prefix}.unsignedTxBytesHex`, 16384);
|
|
195
|
+
if (rec.challenge !== void 0) out.challenge = require_bridge_governance_keys.checkedBytes32(rec.challenge, `${prefix}.challenge`);
|
|
196
|
+
if (out.unsignedTxBytesHex !== void 0 && out.challenge !== void 0 && out.txFrom !== void 0 && out.txFrom.startsWith("0x")) {
|
|
197
|
+
if (`0x${require_utils.bytesToHex(require_sha3.keccak_256(require_utils.hexToBytes(out.unsignedTxBytesHex.slice(2))))}` !== out.challenge) throw new Error(`${prefix}.challenge does not match keccak256(${prefix}.unsignedTxBytesHex)`);
|
|
198
|
+
}
|
|
199
|
+
return out;
|
|
200
|
+
}
|
|
201
|
+
function normalizeEpochFields(kind, validator, rec, parseDec, joinEndpoint) {
|
|
202
|
+
const numFn = parseDec ? require_bridge_governance_keys.parseDecimalBigInt : require_bridge_governance_keys.assertBigIntRange;
|
|
203
|
+
const epoch = numFn(rec.epoch, `${kind}.epoch`, 2n, require_bridge_governance_keys.MAX_SAFE_BIGINT);
|
|
204
|
+
const activeFrom = numFn(rec.activeFrom, `${kind}.activeFrom`, 1n, require_bridge_governance_keys.MAX_SAFE_BIGINT);
|
|
205
|
+
const voucherValidity = numFn(rec.voucherValidity, `${kind}.voucherValidity`, 1n, BigInt(require_bridge_governance_keys.MAX_OCAP_DELAY_SEC));
|
|
206
|
+
if (!Array.isArray(rec.validators) || rec.validators.length < require_bridge_governance_keys.MIN_OCAP_VALIDATORS || rec.validators.length > require_bridge_governance_keys.MAX_OCAP_VALIDATORS) throw new Error(`${kind}.validators must contain ${require_bridge_governance_keys.MIN_OCAP_VALIDATORS}..${require_bridge_governance_keys.MAX_OCAP_VALIDATORS} addresses`);
|
|
207
|
+
const validators = rec.validators.map((v, i) => require_bridge_governance_keys.checkedNonZeroAddress(v, `${kind}.validators[${i}]`));
|
|
208
|
+
for (let i = 1; i < validators.length; i++) if (BigInt(validators[i]) <= BigInt(validators[i - 1])) throw new Error(`${kind}.validators must be strictly ascending without duplicates`);
|
|
209
|
+
if (!Array.isArray(rec.endpoints) || rec.endpoints.length !== validators.length) throw new Error(`${kind}.endpoints must align 1:1 with validators`);
|
|
210
|
+
const endpoints = rec.endpoints.map((e, i) => require_bridge_governance_keys.assertHttpUrl(e, `${kind}.endpoints[${i}]`));
|
|
211
|
+
const idx = validators.indexOf(validator);
|
|
212
|
+
if (kind === "join_rollup") {
|
|
213
|
+
if (idx === -1) throw new Error("join_rollup.validators must include join_rollup.validator");
|
|
214
|
+
if (endpoints[idx] !== joinEndpoint) throw new Error("join_rollup.endpoints mismatch at validator index");
|
|
215
|
+
} else if (idx !== -1) throw new Error("leave_rollup.validators must not include leave_rollup.validator");
|
|
216
|
+
const threshold = require_bridge_governance_keys.assertSafeUint(rec.threshold, `${kind}.threshold`, 1, validators.length);
|
|
217
|
+
if (2 * threshold <= validators.length) throw new Error(`${kind}.threshold must represent a strict majority`);
|
|
218
|
+
return {
|
|
219
|
+
epoch,
|
|
220
|
+
validators,
|
|
221
|
+
endpoints,
|
|
222
|
+
threshold,
|
|
223
|
+
activeFrom,
|
|
224
|
+
voucherValidity
|
|
225
|
+
};
|
|
226
|
+
}
|
|
227
|
+
function normalizeOcapPatch(rawPatch, parseDec) {
|
|
228
|
+
const rec = require_bridge_governance_keys.assertPlainObject(rawPatch, "update_rollup.patch");
|
|
229
|
+
require_bridge_governance_keys.assertAllowedKeys(rec, OCAP_PATCH_ALLOWED_KEYS, "update_rollup.patch");
|
|
230
|
+
const numFn = parseDec ? require_bridge_governance_keys.parseDecimalBigInt : require_bridge_governance_keys.assertBigIntRange;
|
|
231
|
+
const out = {};
|
|
232
|
+
for (const k of OCAP_PATCH_BIGINT_KEYS) if (rec[k] !== void 0) out[k] = numFn(rec[k], `patch.${k}`, 1n, require_bridge_governance_keys.MAX_U256);
|
|
233
|
+
if (out.minWithdraw !== void 0 && out.maxWithdraw !== void 0 && out.maxWithdraw < out.minWithdraw) throw new Error("patch.maxWithdraw must be >= patch.minWithdraw");
|
|
234
|
+
if (rec.releaseGrace !== void 0) out.releaseGrace = require_bridge_governance_keys.assertSafeUint(rec.releaseGrace, "patch.releaseGrace", 0, require_bridge_governance_keys.MAX_OCAP_DELAY_SEC);
|
|
235
|
+
if (rec.refundDelay !== void 0) out.refundDelay = require_bridge_governance_keys.assertSafeUint(rec.refundDelay, "patch.refundDelay", 0, require_bridge_governance_keys.MAX_OCAP_DELAY_SEC);
|
|
236
|
+
if (rec.pausers !== void 0) {
|
|
237
|
+
if (!Array.isArray(rec.pausers) || rec.pausers.length > require_bridge_governance_keys.MAX_OCAP_PAUSERS) throw new Error(`patch.pausers must be an array of at most ${require_bridge_governance_keys.MAX_OCAP_PAUSERS} addresses`);
|
|
238
|
+
const seen = /* @__PURE__ */ new Set();
|
|
239
|
+
out.pausers = rec.pausers.map((p, i) => {
|
|
240
|
+
const addr = normalizeBareActorAddress(p, `patch.pausers[${i}]`);
|
|
241
|
+
const lower = addr.toLowerCase();
|
|
242
|
+
if (seen.has(lower)) throw new Error("duplicate signer in patch.pausers");
|
|
243
|
+
seen.add(lower);
|
|
244
|
+
return addr;
|
|
245
|
+
});
|
|
246
|
+
}
|
|
247
|
+
if (rec.cancelPendingEpoch !== void 0) {
|
|
248
|
+
if (rec.cancelPendingEpoch !== true) throw new Error("patch.cancelPendingEpoch must be true");
|
|
249
|
+
out.cancelPendingEpoch = true;
|
|
250
|
+
}
|
|
251
|
+
if (rec.proposeOwner !== void 0) {
|
|
252
|
+
const poRec = require_bridge_governance_keys.assertPlainObject(rec.proposeOwner, "patch.proposeOwner");
|
|
253
|
+
require_bridge_governance_keys.assertAllowedKeys(poRec, OCAP_PROPOSE_OWNER_KEYS, "patch.proposeOwner");
|
|
254
|
+
const newOwner = require_bridge_governance_keys.checkedNonZeroAddress(poRec.newOwner, "patch.proposeOwner.newOwner");
|
|
255
|
+
const newOwnerPk = require_bridge_governance_keys.normalizeUncompressedSecp256k1Pk(require_bridge_governance_keys.assertWellFormedString(poRec.newOwnerPk, "patch.proposeOwner.newOwnerPk"));
|
|
256
|
+
if (require_bridge_governance_keys.ethAddressFromUncompressedPk(newOwnerPk) !== newOwner) throw new Error("patch.proposeOwner.newOwnerPk does not match patch.proposeOwner.newOwner");
|
|
257
|
+
out.proposeOwner = {
|
|
258
|
+
newOwner,
|
|
259
|
+
newOwnerPk,
|
|
260
|
+
endpoint: require_bridge_governance_keys.assertHttpUrl(poRec.endpoint, "patch.proposeOwner.endpoint")
|
|
261
|
+
};
|
|
262
|
+
}
|
|
263
|
+
if (rec.cancelOwnerProposal !== void 0) {
|
|
264
|
+
if (rec.cancelOwnerProposal !== true) throw new Error("patch.cancelOwnerProposal must be true");
|
|
265
|
+
out.cancelOwnerProposal = true;
|
|
266
|
+
}
|
|
267
|
+
if (rec.evmGovernance !== void 0) out.evmGovernance = require_bridge_governance_evm_sync.validateEvmGovernanceRosterConfig(rec.evmGovernance);
|
|
268
|
+
const keys = Object.keys(out);
|
|
269
|
+
if (keys.length === 0) throw new Error("update_rollup.patch must specify at least one field");
|
|
270
|
+
if ((out.proposeOwner !== void 0 || out.cancelOwnerProposal !== void 0) && keys.length !== 1) throw new Error("proposeOwner and cancelOwnerProposal cannot be combined with other patch keys");
|
|
271
|
+
return out;
|
|
272
|
+
}
|
|
273
|
+
function normalizeOcapAction(raw, parseDec) {
|
|
274
|
+
const rec = require_bridge_governance_keys.assertPlainObject(raw, "action");
|
|
275
|
+
if (typeof rec.kind !== "string" || !Object.prototype.hasOwnProperty.call(OCAP_ACTION_ALLOWED_KEYS, rec.kind)) throw new Error(`unknown OCAP governed action ${String(rec.kind)}`);
|
|
276
|
+
const kind = rec.kind;
|
|
277
|
+
require_bridge_governance_keys.assertAllowedKeys(rec, OCAP_ACTION_ALLOWED_KEYS[kind], `action(${kind})`);
|
|
278
|
+
const numFn = parseDec ? require_bridge_governance_keys.parseDecimalBigInt : require_bridge_governance_keys.assertBigIntRange;
|
|
279
|
+
switch (kind) {
|
|
280
|
+
case "join_rollup": {
|
|
281
|
+
const validator = require_bridge_governance_keys.checkedNonZeroAddress(rec.validator, "join_rollup.validator");
|
|
282
|
+
const endpoint = require_bridge_governance_keys.assertHttpUrl(rec.endpoint, "join_rollup.endpoint");
|
|
283
|
+
return {
|
|
284
|
+
kind,
|
|
285
|
+
validator,
|
|
286
|
+
endpoint,
|
|
287
|
+
...normalizeEpochFields(kind, validator, rec, parseDec, endpoint)
|
|
288
|
+
};
|
|
289
|
+
}
|
|
290
|
+
case "leave_rollup": {
|
|
291
|
+
const validator = require_bridge_governance_keys.checkedNonZeroAddress(rec.validator, "leave_rollup.validator");
|
|
292
|
+
return {
|
|
293
|
+
kind,
|
|
294
|
+
validator,
|
|
295
|
+
...normalizeEpochFields(kind, validator, rec, parseDec)
|
|
296
|
+
};
|
|
297
|
+
}
|
|
298
|
+
case "pause_rollup": {
|
|
299
|
+
const reason = require_bridge_governance_keys.assertBoundedPlainText(rec.reason, "pause_rollup.reason", require_bridge_governance_keys.MAX_PROPOSAL_SUMMARY_BYTES);
|
|
300
|
+
if (rec.mode === "lone") {
|
|
301
|
+
require_bridge_governance_keys.assertAllowedKeys(rec, OCAP_PAUSE_LONE_KEYS, "action(pause_rollup:lone)");
|
|
302
|
+
return {
|
|
303
|
+
kind,
|
|
304
|
+
mode: "lone",
|
|
305
|
+
reason,
|
|
306
|
+
...normalizeSingleMeta(rec, "pause_rollup", parseDec)
|
|
307
|
+
};
|
|
308
|
+
}
|
|
309
|
+
if (rec.mode === "quorum") {
|
|
310
|
+
require_bridge_governance_keys.assertAllowedKeys(rec, OCAP_PAUSE_QUORUM_KEYS, "action(pause_rollup:quorum)");
|
|
311
|
+
return {
|
|
312
|
+
kind,
|
|
313
|
+
mode: "quorum",
|
|
314
|
+
reason,
|
|
315
|
+
...normalizeLockstep(rec, "pause_rollup", parseDec)
|
|
316
|
+
};
|
|
317
|
+
}
|
|
318
|
+
throw new Error("pause_rollup.mode must be 'lone' or 'quorum'");
|
|
319
|
+
}
|
|
320
|
+
case "resume_rollup": return {
|
|
321
|
+
kind,
|
|
322
|
+
reason: require_bridge_governance_keys.assertBoundedPlainText(rec.reason, "resume_rollup.reason", require_bridge_governance_keys.MAX_PROPOSAL_SUMMARY_BYTES),
|
|
323
|
+
...normalizeLockstep(rec, "resume_rollup", parseDec)
|
|
324
|
+
};
|
|
325
|
+
case "close_rollup": return {
|
|
326
|
+
kind,
|
|
327
|
+
depositCutoffEthBlock: numFn(rec.depositCutoffEthBlock, "close_rollup.depositCutoffEthBlock", 0n, require_bridge_governance_keys.MAX_U256),
|
|
328
|
+
reason: require_bridge_governance_keys.assertBoundedPlainText(rec.reason, "close_rollup.reason", require_bridge_governance_keys.MAX_PROPOSAL_SUMMARY_BYTES),
|
|
329
|
+
...normalizeLockstep(rec, "close_rollup", parseDec)
|
|
330
|
+
};
|
|
331
|
+
case "update_rollup": {
|
|
332
|
+
const patch = normalizeOcapPatch(rec.patch, parseDec);
|
|
333
|
+
const lockstep = normalizeLockstep(rec, "update_rollup", parseDec);
|
|
334
|
+
if (patch.cancelOwnerProposal === true && lockstep.signerRoster.length !== 1) throw new Error("update_rollup(cancelOwnerProposal) requires a single-owner signerRoster");
|
|
335
|
+
return {
|
|
336
|
+
kind,
|
|
337
|
+
patch,
|
|
338
|
+
...lockstep
|
|
339
|
+
};
|
|
340
|
+
}
|
|
341
|
+
case "migrate_rollup": {
|
|
342
|
+
const reason = require_bridge_governance_keys.assertBoundedPlainText(rec.reason, "migrate_rollup.reason", require_bridge_governance_keys.MAX_PROPOSAL_SUMMARY_BYTES);
|
|
343
|
+
if (rec.migrateKind === "vault") {
|
|
344
|
+
require_bridge_governance_keys.assertAllowedKeys(rec, OCAP_MIGRATE_VAULT_KEYS, "action(migrate_rollup:vault)");
|
|
345
|
+
return {
|
|
346
|
+
kind,
|
|
347
|
+
migrateKind: "vault",
|
|
348
|
+
nextVault: require_bridge_governance_keys.checkedNonZeroAddress(rec.nextVault, "migrate_rollup.nextVault"),
|
|
349
|
+
reason,
|
|
350
|
+
...normalizeLockstep(rec, "migrate_rollup", parseDec)
|
|
351
|
+
};
|
|
352
|
+
}
|
|
353
|
+
if (rec.migrateKind === "reserve") {
|
|
354
|
+
const targetBridge = require_bridge_governance_keys.assertBareBridgeDid(rec.targetBridge, "migrate_rollup.targetBridge");
|
|
355
|
+
if (rec.step === "cancel") {
|
|
356
|
+
require_bridge_governance_keys.assertAllowedKeys(rec, OCAP_MIGRATE_RESERVE_CANCEL_KEYS, "action(migrate_rollup:reserve:cancel)");
|
|
357
|
+
return {
|
|
358
|
+
kind,
|
|
359
|
+
migrateKind: "reserve",
|
|
360
|
+
step: "cancel",
|
|
361
|
+
targetBridge,
|
|
362
|
+
reason,
|
|
363
|
+
...normalizeSingleMeta(rec, "migrate_rollup", parseDec)
|
|
364
|
+
};
|
|
365
|
+
}
|
|
366
|
+
if (rec.step === "announce" || rec.step === "execute") {
|
|
367
|
+
require_bridge_governance_keys.assertAllowedKeys(rec, OCAP_MIGRATE_RESERVE_QUORUM_KEYS, `action(migrate_rollup:reserve:${rec.step})`);
|
|
368
|
+
return {
|
|
369
|
+
kind,
|
|
370
|
+
migrateKind: "reserve",
|
|
371
|
+
step: rec.step,
|
|
372
|
+
targetBridge,
|
|
373
|
+
reason,
|
|
374
|
+
...normalizeLockstep(rec, "migrate_rollup", parseDec)
|
|
375
|
+
};
|
|
376
|
+
}
|
|
377
|
+
throw new Error("migrate_rollup.step must be 'announce', 'execute', or 'cancel'");
|
|
378
|
+
}
|
|
379
|
+
throw new Error("migrate_rollup.migrateKind must be 'vault' or 'reserve'");
|
|
380
|
+
}
|
|
381
|
+
}
|
|
382
|
+
}
|
|
383
|
+
function validateOcapProposalInternal(raw, parseDec) {
|
|
384
|
+
const rec = require_bridge_governance_keys.assertPlainObject(raw, "OcapGovernanceProposal");
|
|
385
|
+
require_bridge_governance_keys.assertAllowedKeys(rec, OCAP_PROPOSAL_KEYS, "OcapGovernanceProposal");
|
|
386
|
+
if (rec.version !== 1) throw new Error("OcapGovernanceProposal.version must be 1");
|
|
387
|
+
if (rec.plane !== "ocap") throw new Error("OcapGovernanceProposal.plane must be 'ocap'");
|
|
388
|
+
const numFn = parseDec ? require_bridge_governance_keys.parseDecimalBigInt : require_bridge_governance_keys.assertBigIntRange;
|
|
389
|
+
const ocapChainId = require_bridge_governance_keys.assertSafeChainId(rec.ocapChainId, "ocapChainId");
|
|
390
|
+
const ocapBridge = require_bridge_governance_keys.assertBareBridgeDid(rec.ocapBridge, "ocapBridge");
|
|
391
|
+
const createdAt = numFn(rec.createdAt, "createdAt", 0n, require_bridge_governance_keys.MAX_U64);
|
|
392
|
+
const expiresAt = numFn(rec.expiresAt, "expiresAt", 1n, require_bridge_governance_keys.MAX_U64);
|
|
393
|
+
if (expiresAt <= createdAt) throw new Error("expiresAt must be strictly greater than createdAt");
|
|
394
|
+
const summary = require_bridge_governance_keys.assertBoundedPlainText(rec.summary, "summary", require_bridge_governance_keys.MAX_PROPOSAL_SUMMARY_BYTES);
|
|
395
|
+
const action = normalizeOcapAction(rec.action, parseDec);
|
|
396
|
+
if (action.kind === "migrate_rollup" && action.migrateKind === "reserve" && action.targetBridge === ocapBridge) throw new Error("migrate_rollup.targetBridge cannot equal source ocapBridge");
|
|
397
|
+
return {
|
|
398
|
+
version: 1,
|
|
399
|
+
plane: "ocap",
|
|
400
|
+
ocapChainId,
|
|
401
|
+
ocapBridge,
|
|
402
|
+
createdAt,
|
|
403
|
+
expiresAt,
|
|
404
|
+
summary,
|
|
405
|
+
action
|
|
406
|
+
};
|
|
407
|
+
}
|
|
408
|
+
function validateOcapProposal(proposal) {
|
|
409
|
+
return validateOcapProposalInternal(proposal, false);
|
|
410
|
+
}
|
|
411
|
+
function coerceOcapProposal(raw) {
|
|
412
|
+
return validateOcapProposalInternal(raw, true);
|
|
413
|
+
}
|
|
414
|
+
function serializeOcapProposal(proposal) {
|
|
415
|
+
const json = require_bridge_governance_keys.canonicalJson(require_bridge_governance_keys.toJsonSafeValue(validateOcapProposal(proposal)));
|
|
416
|
+
if (require_bridge_governance_keys.utf8ByteLength(json) > require_bridge_governance_keys.MAX_PROPOSAL_JSON_BYTES) throw new Error(`serialized OcapGovernanceProposal exceeds ${require_bridge_governance_keys.MAX_PROPOSAL_JSON_BYTES} bytes`);
|
|
417
|
+
return json;
|
|
418
|
+
}
|
|
419
|
+
function parseOcapProposal(json) {
|
|
420
|
+
const s = require_bridge_governance_keys.assertWellFormedString(json, "proposal JSON");
|
|
421
|
+
if (require_bridge_governance_keys.utf8ByteLength(s) > require_bridge_governance_keys.MAX_PROPOSAL_JSON_BYTES) throw new Error(`proposal JSON exceeds ${require_bridge_governance_keys.MAX_PROPOSAL_JSON_BYTES} bytes`);
|
|
422
|
+
return validateOcapProposalInternal(require_bridge_governance_strict_json.parseStrictJson(s), true);
|
|
423
|
+
}
|
|
424
|
+
function computeOcapProposalId(proposal) {
|
|
425
|
+
const canonical = serializeOcapProposal(proposal);
|
|
426
|
+
return `0x${require_utils.bytesToHex(require_sha3.keccak_256(require_utils.concatBytes(require_utils.utf8ToBytes(require_bridge_governance_keys.OCAP_PROPOSAL_HASH_PREFIX), require_utils.utf8ToBytes(canonical))))}`;
|
|
427
|
+
}
|
|
428
|
+
function membershipFromOcapProposal(proposal) {
|
|
429
|
+
const canonical = validateOcapProposal(proposal);
|
|
430
|
+
const { action } = canonical;
|
|
431
|
+
if (action.kind !== "join_rollup" && action.kind !== "leave_rollup") throw new Error(`membershipFromOcapProposal requires join_rollup or leave_rollup, got ${action.kind}`);
|
|
432
|
+
return {
|
|
433
|
+
ocapChainId: canonical.ocapChainId,
|
|
434
|
+
bridge: canonical.ocapBridge,
|
|
435
|
+
epoch: action.epoch,
|
|
436
|
+
validators: action.validators,
|
|
437
|
+
threshold: action.threshold,
|
|
438
|
+
activeFrom: action.activeFrom,
|
|
439
|
+
voucherValidity: action.voucherValidity,
|
|
440
|
+
endpointsHash: require_bridge_governance_membership.computeBridgeEndpointsHash(action.endpoints),
|
|
441
|
+
action: action.kind === "join_rollup" ? require_bridge_governance_membership.BRIDGE_MEMBERSHIP_ACTION.JOIN : require_bridge_governance_membership.BRIDGE_MEMBERSHIP_ACTION.LEAVE
|
|
442
|
+
};
|
|
443
|
+
}
|
|
444
|
+
function recoverOcapMembershipProposalSigner(proposal, sig) {
|
|
445
|
+
const signature = require_bridge_governance_evm_abi.normalizeEcdsaSignature(sig);
|
|
446
|
+
const recovered = require_bridge_governance_membership.recoverBridgeSigner(require_bridge_governance_membership.computeBridgeMembershipDigest(membershipFromOcapProposal(proposal)), signature);
|
|
447
|
+
if (!recovered) throw new Error("failed to recover BridgeMembership signer");
|
|
448
|
+
return {
|
|
449
|
+
signer: require_bridge_governance_keys.checkedNonZeroAddress(recovered.address, "recovered signer"),
|
|
450
|
+
signature
|
|
451
|
+
};
|
|
452
|
+
}
|
|
453
|
+
const ARCBLOCK_TX_DOMAIN_SEP = require_sha3.keccak_256(require_utils.concatBytes(require_sha3.keccak_256(require_utils.utf8ToBytes("EIP712Domain(string name,string version)")), require_sha3.keccak_256(require_utils.utf8ToBytes("ArcBlock")), require_sha3.keccak_256(require_utils.utf8ToBytes("1"))));
|
|
454
|
+
const ARCBLOCK_TX_TYPE_HASH = require_sha3.keccak_256(require_utils.utf8ToBytes("ArcBlockTransaction(string chainId,string action,string from,string nonce,string challenge)"));
|
|
455
|
+
function computeArcBlockTxEip712Digest(fields) {
|
|
456
|
+
const challenge = require_bridge_governance_keys.checkedBytes32(fields.challenge, "challenge");
|
|
457
|
+
const structHash = require_sha3.keccak_256(require_utils.concatBytes(ARCBLOCK_TX_TYPE_HASH, require_sha3.keccak_256(require_utils.utf8ToBytes(fields.chainId)), require_sha3.keccak_256(require_utils.utf8ToBytes(fields.action)), require_sha3.keccak_256(require_utils.utf8ToBytes(fields.from)), require_sha3.keccak_256(require_utils.utf8ToBytes(fields.nonce)), require_sha3.keccak_256(require_utils.utf8ToBytes(challenge))));
|
|
458
|
+
return require_sha3.keccak_256(require_utils.concatBytes(new Uint8Array([25, 1]), ARCBLOCK_TX_DOMAIN_SEP, structHash));
|
|
459
|
+
}
|
|
460
|
+
function formatArcBlockTxEip191Text(fields) {
|
|
461
|
+
const challenge = require_bridge_governance_keys.checkedBytes32(fields.challenge, "challenge");
|
|
462
|
+
return `ArcBlock Transaction v1\nChain: ${fields.chainId}\nAction: ${fields.action}\nSigner: ${fields.from}\nNonce: ${fields.nonce}\nChallenge: ${challenge}`;
|
|
463
|
+
}
|
|
464
|
+
function computeArcBlockTxEip191Digest(fields) {
|
|
465
|
+
const body = require_utils.utf8ToBytes(formatArcBlockTxEip191Text(fields));
|
|
466
|
+
return require_sha3.keccak_256(require_utils.concatBytes(require_utils.utf8ToBytes(`\x19Ethereum Signed Message:\n${body.byteLength}`), body));
|
|
467
|
+
}
|
|
468
|
+
function recoverArcBlockTxEnvelopeSigner(fields, sig, envelope = "eip712") {
|
|
469
|
+
const signature = require_bridge_governance_evm_abi.normalizeEcdsaSignature(sig);
|
|
470
|
+
const recovered = require_bridge_governance_membership.recoverBridgeSigner(envelope === "eip191" ? computeArcBlockTxEip191Digest(fields) : computeArcBlockTxEip712Digest(fields), signature);
|
|
471
|
+
if (!recovered) throw new Error("failed to recover ArcBlockTransaction signer");
|
|
472
|
+
const publicKeyHex = `0x${require_utils.bytesToHex(recovered.publicKey.subarray(1))}`;
|
|
473
|
+
return {
|
|
474
|
+
signer: require_bridge_governance_keys.checkedNonZeroAddress(recovered.address, "recovered signer"),
|
|
475
|
+
publicKeyHex,
|
|
476
|
+
signature
|
|
477
|
+
};
|
|
478
|
+
}
|
|
479
|
+
|
|
480
|
+
//#endregion
|
|
481
|
+
exports.coerceOcapProposal = coerceOcapProposal;
|
|
482
|
+
exports.computeArcBlockTxEip191Digest = computeArcBlockTxEip191Digest;
|
|
483
|
+
exports.computeArcBlockTxEip712Digest = computeArcBlockTxEip712Digest;
|
|
484
|
+
exports.computeOcapProposalId = computeOcapProposalId;
|
|
485
|
+
exports.formatArcBlockTxEip191Text = formatArcBlockTxEip191Text;
|
|
486
|
+
exports.membershipFromOcapProposal = membershipFromOcapProposal;
|
|
487
|
+
exports.parseOcapProposal = parseOcapProposal;
|
|
488
|
+
exports.recoverArcBlockTxEnvelopeSigner = recoverArcBlockTxEnvelopeSigner;
|
|
489
|
+
exports.recoverOcapMembershipProposalSigner = recoverOcapMembershipProposalSigner;
|
|
490
|
+
exports.serializeOcapProposal = serializeOcapProposal;
|
|
491
|
+
exports.validateOcapProposal = validateOcapProposal;
|
|
@@ -0,0 +1,132 @@
|
|
|
1
|
+
import { BridgeMembershipMessage } from "./membership.cjs";
|
|
2
|
+
import { EvmGovernanceRosterConfig } from "./evm-sync.cjs";
|
|
3
|
+
|
|
4
|
+
//#region src/bridge-governance/ocap-proposals.d.ts
|
|
5
|
+
interface OcapSignerRosterEntry {
|
|
6
|
+
signer: string;
|
|
7
|
+
pk: string;
|
|
8
|
+
}
|
|
9
|
+
interface OcapMultiSigLockstep {
|
|
10
|
+
txFrom: string;
|
|
11
|
+
frozenNonce: bigint;
|
|
12
|
+
signerRoster: OcapSignerRosterEntry[];
|
|
13
|
+
unsignedTxBytesHex?: string;
|
|
14
|
+
challenge?: string;
|
|
15
|
+
}
|
|
16
|
+
interface OcapSingleSignerMetadata {
|
|
17
|
+
txFrom?: string;
|
|
18
|
+
frozenNonce?: bigint;
|
|
19
|
+
unsignedTxBytesHex?: string;
|
|
20
|
+
challenge?: string;
|
|
21
|
+
}
|
|
22
|
+
interface OcapProposeOwner {
|
|
23
|
+
newOwner: string;
|
|
24
|
+
newOwnerPk: string;
|
|
25
|
+
endpoint: string;
|
|
26
|
+
}
|
|
27
|
+
interface OcapRollupPatch {
|
|
28
|
+
minDeposit?: bigint;
|
|
29
|
+
minWithdraw?: bigint;
|
|
30
|
+
maxWithdraw?: bigint;
|
|
31
|
+
releaseDailyCap?: bigint;
|
|
32
|
+
refundDailyCap?: bigint;
|
|
33
|
+
releaseGrace?: number;
|
|
34
|
+
refundDelay?: number;
|
|
35
|
+
pausers?: string[];
|
|
36
|
+
cancelPendingEpoch?: true;
|
|
37
|
+
proposeOwner?: OcapProposeOwner;
|
|
38
|
+
cancelOwnerProposal?: true;
|
|
39
|
+
evmGovernance?: EvmGovernanceRosterConfig;
|
|
40
|
+
}
|
|
41
|
+
type OcapGovernedAction = {
|
|
42
|
+
kind: 'join_rollup';
|
|
43
|
+
validator: string;
|
|
44
|
+
endpoint: string;
|
|
45
|
+
epoch: bigint;
|
|
46
|
+
validators: string[];
|
|
47
|
+
endpoints: string[];
|
|
48
|
+
threshold: number;
|
|
49
|
+
activeFrom: bigint;
|
|
50
|
+
voucherValidity: bigint;
|
|
51
|
+
} | {
|
|
52
|
+
kind: 'leave_rollup';
|
|
53
|
+
validator: string;
|
|
54
|
+
epoch: bigint;
|
|
55
|
+
validators: string[];
|
|
56
|
+
endpoints: string[];
|
|
57
|
+
threshold: number;
|
|
58
|
+
activeFrom: bigint;
|
|
59
|
+
voucherValidity: bigint;
|
|
60
|
+
} | ({
|
|
61
|
+
kind: 'pause_rollup';
|
|
62
|
+
mode: 'lone';
|
|
63
|
+
reason: string;
|
|
64
|
+
} & OcapSingleSignerMetadata) | ({
|
|
65
|
+
kind: 'pause_rollup';
|
|
66
|
+
mode: 'quorum';
|
|
67
|
+
reason: string;
|
|
68
|
+
} & OcapMultiSigLockstep) | ({
|
|
69
|
+
kind: 'resume_rollup';
|
|
70
|
+
reason: string;
|
|
71
|
+
} & OcapMultiSigLockstep) | ({
|
|
72
|
+
kind: 'close_rollup';
|
|
73
|
+
depositCutoffEthBlock: bigint;
|
|
74
|
+
reason: string;
|
|
75
|
+
} & OcapMultiSigLockstep) | ({
|
|
76
|
+
kind: 'update_rollup';
|
|
77
|
+
patch: OcapRollupPatch;
|
|
78
|
+
} & OcapMultiSigLockstep) | ({
|
|
79
|
+
kind: 'migrate_rollup';
|
|
80
|
+
migrateKind: 'vault';
|
|
81
|
+
nextVault: string;
|
|
82
|
+
reason: string;
|
|
83
|
+
} & OcapMultiSigLockstep) | ({
|
|
84
|
+
kind: 'migrate_rollup';
|
|
85
|
+
migrateKind: 'reserve';
|
|
86
|
+
step: 'announce' | 'execute';
|
|
87
|
+
targetBridge: string;
|
|
88
|
+
reason: string;
|
|
89
|
+
} & OcapMultiSigLockstep) | ({
|
|
90
|
+
kind: 'migrate_rollup';
|
|
91
|
+
migrateKind: 'reserve';
|
|
92
|
+
step: 'cancel';
|
|
93
|
+
targetBridge: string;
|
|
94
|
+
reason: string;
|
|
95
|
+
} & OcapSingleSignerMetadata);
|
|
96
|
+
interface OcapGovernanceProposal {
|
|
97
|
+
version: 1;
|
|
98
|
+
plane: 'ocap';
|
|
99
|
+
ocapChainId: string;
|
|
100
|
+
ocapBridge: string;
|
|
101
|
+
createdAt: bigint;
|
|
102
|
+
expiresAt: bigint;
|
|
103
|
+
summary: string;
|
|
104
|
+
action: OcapGovernedAction;
|
|
105
|
+
}
|
|
106
|
+
declare function validateOcapProposal(proposal: OcapGovernanceProposal): OcapGovernanceProposal;
|
|
107
|
+
declare function coerceOcapProposal(raw: unknown): OcapGovernanceProposal;
|
|
108
|
+
declare function serializeOcapProposal(proposal: OcapGovernanceProposal): string;
|
|
109
|
+
declare function parseOcapProposal(json: string): OcapGovernanceProposal;
|
|
110
|
+
declare function computeOcapProposalId(proposal: OcapGovernanceProposal): string;
|
|
111
|
+
declare function membershipFromOcapProposal(proposal: OcapGovernanceProposal): BridgeMembershipMessage;
|
|
112
|
+
declare function recoverOcapMembershipProposalSigner(proposal: OcapGovernanceProposal, sig: string): {
|
|
113
|
+
signer: string;
|
|
114
|
+
signature: string;
|
|
115
|
+
};
|
|
116
|
+
interface ArcBlockTransactionEnvelopeFields {
|
|
117
|
+
chainId: string;
|
|
118
|
+
action: string;
|
|
119
|
+
from: string;
|
|
120
|
+
nonce: string;
|
|
121
|
+
challenge: string;
|
|
122
|
+
}
|
|
123
|
+
declare function computeArcBlockTxEip712Digest(fields: ArcBlockTransactionEnvelopeFields): Uint8Array;
|
|
124
|
+
declare function formatArcBlockTxEip191Text(fields: ArcBlockTransactionEnvelopeFields): string;
|
|
125
|
+
declare function computeArcBlockTxEip191Digest(fields: ArcBlockTransactionEnvelopeFields): Uint8Array;
|
|
126
|
+
declare function recoverArcBlockTxEnvelopeSigner(fields: ArcBlockTransactionEnvelopeFields, sig: string, envelope?: 'eip712' | 'eip191'): {
|
|
127
|
+
signer: string;
|
|
128
|
+
publicKeyHex: string;
|
|
129
|
+
signature: string;
|
|
130
|
+
};
|
|
131
|
+
//#endregion
|
|
132
|
+
export { ArcBlockTransactionEnvelopeFields, OcapGovernanceProposal, OcapGovernedAction, OcapMultiSigLockstep, OcapProposeOwner, OcapRollupPatch, OcapSignerRosterEntry, OcapSingleSignerMetadata, coerceOcapProposal, computeArcBlockTxEip191Digest, computeArcBlockTxEip712Digest, computeOcapProposalId, formatArcBlockTxEip191Text, membershipFromOcapProposal, parseOcapProposal, recoverArcBlockTxEnvelopeSigner, recoverOcapMembershipProposalSigner, serializeOcapProposal, validateOcapProposal };
|