@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,353 @@
|
|
|
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_keys = require('./keys.cjs');
|
|
4
|
+
const require_bridge_governance_strict_json = require('./strict-json.cjs');
|
|
5
|
+
const require_bridge_governance_evm_abi = require('./evm-abi.cjs');
|
|
6
|
+
|
|
7
|
+
//#region src/bridge-governance/evm-proposals.ts
|
|
8
|
+
const DEPLOYMENT_KEYS = new Set([
|
|
9
|
+
"chainId",
|
|
10
|
+
"token",
|
|
11
|
+
"gateway",
|
|
12
|
+
"validatorSet",
|
|
13
|
+
"signerManager",
|
|
14
|
+
"vault",
|
|
15
|
+
"vaultSignerManager"
|
|
16
|
+
]);
|
|
17
|
+
const REFUND_CONTEXT_KEYS = new Set(["depositTxHash", "originalDepositor"]);
|
|
18
|
+
const EVM_PROPOSAL_KEYS = new Set([
|
|
19
|
+
"version",
|
|
20
|
+
"plane",
|
|
21
|
+
"ocapChainId",
|
|
22
|
+
"ocapBridge",
|
|
23
|
+
"deployment",
|
|
24
|
+
"target",
|
|
25
|
+
"action",
|
|
26
|
+
"nonce",
|
|
27
|
+
"createdAt",
|
|
28
|
+
"expiresAt",
|
|
29
|
+
"summary",
|
|
30
|
+
"linkedTxHash",
|
|
31
|
+
"refundContext"
|
|
32
|
+
]);
|
|
33
|
+
const GATEWAY_PARAMS_KEYS = new Set([
|
|
34
|
+
"minDeposit",
|
|
35
|
+
"midThreshold",
|
|
36
|
+
"largeThreshold",
|
|
37
|
+
"dailyCap",
|
|
38
|
+
"recipientDailyCap",
|
|
39
|
+
"smallDailyCap"
|
|
40
|
+
]);
|
|
41
|
+
const WITHDRAW_VOUCHER_KEYS = new Set([
|
|
42
|
+
"ocapTxHash",
|
|
43
|
+
"to",
|
|
44
|
+
"amount",
|
|
45
|
+
"validAfter",
|
|
46
|
+
"expiresAt",
|
|
47
|
+
"epoch"
|
|
48
|
+
]);
|
|
49
|
+
const CERT_KEYS = new Set([
|
|
50
|
+
"target",
|
|
51
|
+
"selector",
|
|
52
|
+
"paramsHash",
|
|
53
|
+
"nonce",
|
|
54
|
+
"proposalHash",
|
|
55
|
+
"expiresAt"
|
|
56
|
+
]);
|
|
57
|
+
const EVM_ACTION_ALLOWED_KEYS = {
|
|
58
|
+
unpause: new Set(["kind"]),
|
|
59
|
+
setParams: new Set(["kind", "params"]),
|
|
60
|
+
setVault: new Set(["kind", "vault"]),
|
|
61
|
+
claimLarge: new Set([
|
|
62
|
+
"kind",
|
|
63
|
+
"voucher",
|
|
64
|
+
"gatewayChainId"
|
|
65
|
+
]),
|
|
66
|
+
rotate: new Set([
|
|
67
|
+
"kind",
|
|
68
|
+
"validators",
|
|
69
|
+
"threshold"
|
|
70
|
+
]),
|
|
71
|
+
setSentinels: new Set(["kind", "sentinels"]),
|
|
72
|
+
addSigner: new Set(["kind", "signer"]),
|
|
73
|
+
removeSigner: new Set(["kind", "signer"]),
|
|
74
|
+
replaceSeed: new Set([
|
|
75
|
+
"kind",
|
|
76
|
+
"oldSeed",
|
|
77
|
+
"newSeed"
|
|
78
|
+
]),
|
|
79
|
+
setThresholds: new Set([
|
|
80
|
+
"kind",
|
|
81
|
+
"threshold",
|
|
82
|
+
"seedThreshold"
|
|
83
|
+
]),
|
|
84
|
+
setDelay: new Set([
|
|
85
|
+
"kind",
|
|
86
|
+
"target",
|
|
87
|
+
"selector",
|
|
88
|
+
"delay"
|
|
89
|
+
]),
|
|
90
|
+
increaseAllowance: new Set([
|
|
91
|
+
"kind",
|
|
92
|
+
"spender",
|
|
93
|
+
"amount"
|
|
94
|
+
]),
|
|
95
|
+
decreaseAllowance: new Set([
|
|
96
|
+
"kind",
|
|
97
|
+
"spender",
|
|
98
|
+
"amount"
|
|
99
|
+
]),
|
|
100
|
+
transferToken: new Set([
|
|
101
|
+
"kind",
|
|
102
|
+
"erc20",
|
|
103
|
+
"to",
|
|
104
|
+
"amount"
|
|
105
|
+
])
|
|
106
|
+
};
|
|
107
|
+
function normalizeDeployment(raw, parseDec) {
|
|
108
|
+
const rec = require_bridge_governance_keys.assertPlainObject(raw, "deployment");
|
|
109
|
+
require_bridge_governance_keys.assertAllowedKeys(rec, DEPLOYMENT_KEYS, "deployment");
|
|
110
|
+
const out = {
|
|
111
|
+
chainId: (parseDec ? require_bridge_governance_keys.parseDecimalBigInt : require_bridge_governance_keys.assertBigIntRange)(rec.chainId, "deployment.chainId", 1n, require_bridge_governance_keys.MAX_U256),
|
|
112
|
+
gateway: require_bridge_governance_keys.checkedNonZeroAddress(rec.gateway, "deployment.gateway"),
|
|
113
|
+
validatorSet: require_bridge_governance_keys.checkedNonZeroAddress(rec.validatorSet, "deployment.validatorSet"),
|
|
114
|
+
signerManager: require_bridge_governance_keys.checkedNonZeroAddress(rec.signerManager, "deployment.signerManager")
|
|
115
|
+
};
|
|
116
|
+
if (rec.token !== void 0) out.token = require_bridge_governance_keys.checkedNonZeroAddress(rec.token, "deployment.token");
|
|
117
|
+
if (rec.vault !== void 0) out.vault = require_bridge_governance_keys.checkedNonZeroAddress(rec.vault, "deployment.vault");
|
|
118
|
+
if (rec.vaultSignerManager !== void 0) out.vaultSignerManager = require_bridge_governance_keys.checkedNonZeroAddress(rec.vaultSignerManager, "deployment.vaultSignerManager");
|
|
119
|
+
require_bridge_governance_evm_abi.assertDistinctDeploymentAddresses(out);
|
|
120
|
+
return out;
|
|
121
|
+
}
|
|
122
|
+
function normalizeEvmAction(raw, parseDec) {
|
|
123
|
+
const rec = require_bridge_governance_keys.assertPlainObject(raw, "action");
|
|
124
|
+
if (typeof rec.kind !== "string" || !Object.prototype.hasOwnProperty.call(require_bridge_governance_evm_abi.GOVERNED_FUNCTIONS, rec.kind)) throw new Error(`unknown governed action ${String(rec.kind)}`);
|
|
125
|
+
const kind = rec.kind;
|
|
126
|
+
require_bridge_governance_keys.assertAllowedKeys(rec, EVM_ACTION_ALLOWED_KEYS[kind], `action(${kind})`);
|
|
127
|
+
const numFn = parseDec ? require_bridge_governance_keys.parseDecimalBigInt : require_bridge_governance_keys.assertBigIntRange;
|
|
128
|
+
switch (kind) {
|
|
129
|
+
case "unpause": return { kind: "unpause" };
|
|
130
|
+
case "setParams": {
|
|
131
|
+
const pRec = require_bridge_governance_keys.assertPlainObject(rec.params, "action.params");
|
|
132
|
+
require_bridge_governance_keys.assertAllowedKeys(pRec, GATEWAY_PARAMS_KEYS, "action.params");
|
|
133
|
+
return {
|
|
134
|
+
kind: "setParams",
|
|
135
|
+
params: {
|
|
136
|
+
minDeposit: numFn(pRec.minDeposit, "setParams.params.minDeposit", 0n, require_bridge_governance_keys.MAX_U256),
|
|
137
|
+
midThreshold: numFn(pRec.midThreshold, "setParams.params.midThreshold", 1n, require_bridge_governance_keys.MAX_U256),
|
|
138
|
+
largeThreshold: numFn(pRec.largeThreshold, "setParams.params.largeThreshold", 1n, require_bridge_governance_keys.MAX_U256),
|
|
139
|
+
dailyCap: numFn(pRec.dailyCap, "setParams.params.dailyCap", 1n, require_bridge_governance_keys.MAX_U256),
|
|
140
|
+
recipientDailyCap: numFn(pRec.recipientDailyCap, "setParams.params.recipientDailyCap", 1n, require_bridge_governance_keys.MAX_U256),
|
|
141
|
+
smallDailyCap: numFn(pRec.smallDailyCap, "setParams.params.smallDailyCap", 1n, require_bridge_governance_keys.MAX_U256)
|
|
142
|
+
}
|
|
143
|
+
};
|
|
144
|
+
}
|
|
145
|
+
case "setVault": return {
|
|
146
|
+
kind: "setVault",
|
|
147
|
+
vault: require_bridge_governance_keys.checksumEthAddress(rec.vault, "setVault.vault")
|
|
148
|
+
};
|
|
149
|
+
case "claimLarge": {
|
|
150
|
+
const vRec = require_bridge_governance_keys.assertPlainObject(rec.voucher, "action.voucher");
|
|
151
|
+
require_bridge_governance_keys.assertAllowedKeys(vRec, WITHDRAW_VOUCHER_KEYS, "action.voucher");
|
|
152
|
+
return {
|
|
153
|
+
kind: "claimLarge",
|
|
154
|
+
voucher: {
|
|
155
|
+
ocapTxHash: require_bridge_governance_keys.checkedBytes32(vRec.ocapTxHash, "claimLarge.voucher.ocapTxHash"),
|
|
156
|
+
to: require_bridge_governance_keys.checksumEthAddress(vRec.to, "claimLarge.voucher.to"),
|
|
157
|
+
amount: numFn(vRec.amount, "claimLarge.voucher.amount", 1n, require_bridge_governance_keys.MAX_U256),
|
|
158
|
+
validAfter: numFn(vRec.validAfter, "claimLarge.voucher.validAfter", 0n, require_bridge_governance_keys.MAX_U64),
|
|
159
|
+
expiresAt: numFn(vRec.expiresAt, "claimLarge.voucher.expiresAt", 1n, require_bridge_governance_keys.MAX_U64),
|
|
160
|
+
epoch: numFn(vRec.epoch, "claimLarge.voucher.epoch", 1n, require_bridge_governance_keys.MAX_U64)
|
|
161
|
+
},
|
|
162
|
+
gatewayChainId: numFn(rec.gatewayChainId, "claimLarge.gatewayChainId", 1n, require_bridge_governance_keys.MAX_U256)
|
|
163
|
+
};
|
|
164
|
+
}
|
|
165
|
+
case "rotate":
|
|
166
|
+
if (!Array.isArray(rec.validators)) throw new Error("rotate.validators must be an array");
|
|
167
|
+
return {
|
|
168
|
+
kind: "rotate",
|
|
169
|
+
validators: rec.validators.map((v, i) => require_bridge_governance_keys.checksumEthAddress(v, `rotate.validators[${i}]`)),
|
|
170
|
+
threshold: numFn(rec.threshold, "rotate.threshold", 1n, require_bridge_governance_keys.MAX_U256)
|
|
171
|
+
};
|
|
172
|
+
case "setSentinels":
|
|
173
|
+
if (!Array.isArray(rec.sentinels)) throw new Error("setSentinels.sentinels must be an array");
|
|
174
|
+
return {
|
|
175
|
+
kind: "setSentinels",
|
|
176
|
+
sentinels: rec.sentinels.map((s, i) => require_bridge_governance_keys.checksumEthAddress(s, `setSentinels.sentinels[${i}]`))
|
|
177
|
+
};
|
|
178
|
+
case "addSigner": return {
|
|
179
|
+
kind: "addSigner",
|
|
180
|
+
signer: require_bridge_governance_keys.checksumEthAddress(rec.signer, "addSigner.signer")
|
|
181
|
+
};
|
|
182
|
+
case "removeSigner": return {
|
|
183
|
+
kind: "removeSigner",
|
|
184
|
+
signer: require_bridge_governance_keys.checksumEthAddress(rec.signer, "removeSigner.signer")
|
|
185
|
+
};
|
|
186
|
+
case "replaceSeed": return {
|
|
187
|
+
kind: "replaceSeed",
|
|
188
|
+
oldSeed: require_bridge_governance_keys.checksumEthAddress(rec.oldSeed, "replaceSeed.oldSeed"),
|
|
189
|
+
newSeed: require_bridge_governance_keys.checksumEthAddress(rec.newSeed, "replaceSeed.newSeed")
|
|
190
|
+
};
|
|
191
|
+
case "setThresholds": return {
|
|
192
|
+
kind: "setThresholds",
|
|
193
|
+
threshold: numFn(rec.threshold, "setThresholds.threshold", 1n, require_bridge_governance_keys.MAX_U256),
|
|
194
|
+
seedThreshold: numFn(rec.seedThreshold, "setThresholds.seedThreshold", 1n, require_bridge_governance_keys.MAX_U256)
|
|
195
|
+
};
|
|
196
|
+
case "setDelay": return {
|
|
197
|
+
kind: "setDelay",
|
|
198
|
+
target: require_bridge_governance_keys.checksumEthAddress(rec.target, "setDelay.target"),
|
|
199
|
+
selector: require_bridge_governance_keys.checkedBytes4(rec.selector, "setDelay.selector"),
|
|
200
|
+
delay: numFn(rec.delay, "setDelay.delay", 0n, require_bridge_governance_keys.MAX_U64)
|
|
201
|
+
};
|
|
202
|
+
case "increaseAllowance": return {
|
|
203
|
+
kind: "increaseAllowance",
|
|
204
|
+
spender: require_bridge_governance_keys.checksumEthAddress(rec.spender, "increaseAllowance.spender"),
|
|
205
|
+
amount: numFn(rec.amount, "increaseAllowance.amount", 1n, require_bridge_governance_keys.MAX_U256)
|
|
206
|
+
};
|
|
207
|
+
case "decreaseAllowance": return {
|
|
208
|
+
kind: "decreaseAllowance",
|
|
209
|
+
spender: require_bridge_governance_keys.checksumEthAddress(rec.spender, "decreaseAllowance.spender"),
|
|
210
|
+
amount: numFn(rec.amount, "decreaseAllowance.amount", 1n, require_bridge_governance_keys.MAX_U256)
|
|
211
|
+
};
|
|
212
|
+
case "transferToken": return {
|
|
213
|
+
kind: "transferToken",
|
|
214
|
+
erc20: require_bridge_governance_keys.checksumEthAddress(rec.erc20, "transferToken.erc20"),
|
|
215
|
+
to: require_bridge_governance_keys.checksumEthAddress(rec.to, "transferToken.to"),
|
|
216
|
+
amount: numFn(rec.amount, "transferToken.amount", 0n, require_bridge_governance_keys.MAX_U256)
|
|
217
|
+
};
|
|
218
|
+
}
|
|
219
|
+
}
|
|
220
|
+
function claimLargeCertExpiresAt(voucherExpiresAt, nowSec, delaySec) {
|
|
221
|
+
const vExp = require_bridge_governance_keys.assertBigIntRange(voucherExpiresAt, "voucherExpiresAt", 1n, require_bridge_governance_keys.MAX_U64);
|
|
222
|
+
const stdExp = require_bridge_governance_evm_abi.defaultCertExpiresAt(nowSec, delaySec);
|
|
223
|
+
if (vExp <= nowSec + delaySec) throw new Error("voucher expires at or before governance timelock eta");
|
|
224
|
+
return vExp < stdExp ? vExp : stdExp;
|
|
225
|
+
}
|
|
226
|
+
function validateEvmProposalInternal(raw, parseDec) {
|
|
227
|
+
const rec = require_bridge_governance_keys.assertPlainObject(raw, "EvmGovernanceProposal");
|
|
228
|
+
require_bridge_governance_keys.assertAllowedKeys(rec, EVM_PROPOSAL_KEYS, "EvmGovernanceProposal");
|
|
229
|
+
if (rec.version !== 1) throw new Error("EvmGovernanceProposal.version must be 1");
|
|
230
|
+
if (rec.plane !== "ethereum") throw new Error("EvmGovernanceProposal.plane must be 'ethereum'");
|
|
231
|
+
const numFn = parseDec ? require_bridge_governance_keys.parseDecimalBigInt : require_bridge_governance_keys.assertBigIntRange;
|
|
232
|
+
const ocapChainId = require_bridge_governance_keys.assertSafeChainId(rec.ocapChainId, "ocapChainId");
|
|
233
|
+
const ocapBridge = require_bridge_governance_keys.assertBareBridgeDid(rec.ocapBridge, "ocapBridge");
|
|
234
|
+
const deployment = normalizeDeployment(rec.deployment, parseDec);
|
|
235
|
+
const target = require_bridge_governance_keys.checkedNonZeroAddress(rec.target, "target");
|
|
236
|
+
const action = normalizeEvmAction(rec.action, parseDec);
|
|
237
|
+
const nonce = numFn(rec.nonce, "nonce", 0n, require_bridge_governance_keys.MAX_U256);
|
|
238
|
+
const createdAt = numFn(rec.createdAt, "createdAt", 0n, require_bridge_governance_keys.MAX_U64);
|
|
239
|
+
const expiresAt = numFn(rec.expiresAt, "expiresAt", 1n, require_bridge_governance_keys.MAX_U64);
|
|
240
|
+
if (expiresAt <= createdAt) throw new Error("expiresAt must be strictly greater than createdAt");
|
|
241
|
+
const summary = require_bridge_governance_keys.assertBoundedPlainText(rec.summary, "summary", require_bridge_governance_keys.MAX_PROPOSAL_SUMMARY_BYTES);
|
|
242
|
+
const linkedTxHash = rec.linkedTxHash !== void 0 ? require_bridge_governance_keys.checkedBytes32(rec.linkedTxHash, "linkedTxHash") : void 0;
|
|
243
|
+
if (action.kind === "claimLarge") {
|
|
244
|
+
if (expiresAt > action.voucher.expiresAt) throw new Error("claimLarge proposal expiresAt must not exceed action.voucher.expiresAt");
|
|
245
|
+
if (linkedTxHash !== void 0 && linkedTxHash !== action.voucher.ocapTxHash) throw new Error("claimLarge linkedTxHash must match action.voucher.ocapTxHash");
|
|
246
|
+
}
|
|
247
|
+
let refundContext;
|
|
248
|
+
if (rec.refundContext !== void 0) {
|
|
249
|
+
if (action.kind !== "transferToken") throw new Error("refundContext is only permitted on transferToken proposals");
|
|
250
|
+
const rcRec = require_bridge_governance_keys.assertPlainObject(rec.refundContext, "refundContext");
|
|
251
|
+
require_bridge_governance_keys.assertAllowedKeys(rcRec, REFUND_CONTEXT_KEYS, "refundContext");
|
|
252
|
+
const depositTxHash = require_bridge_governance_keys.checkedBytes32(rcRec.depositTxHash, "refundContext.depositTxHash");
|
|
253
|
+
const originalDepositor = require_bridge_governance_keys.checkedNonZeroAddress(rcRec.originalDepositor, "refundContext.originalDepositor");
|
|
254
|
+
if (originalDepositor !== action.to) throw new Error("refundContext.originalDepositor must equal transferToken action.to");
|
|
255
|
+
if (linkedTxHash !== void 0 && linkedTxHash !== depositTxHash) throw new Error("linkedTxHash must match refundContext.depositTxHash");
|
|
256
|
+
refundContext = {
|
|
257
|
+
depositTxHash,
|
|
258
|
+
originalDepositor
|
|
259
|
+
};
|
|
260
|
+
}
|
|
261
|
+
require_bridge_governance_evm_abi.validateGovernedRequest({
|
|
262
|
+
deployment,
|
|
263
|
+
action,
|
|
264
|
+
target,
|
|
265
|
+
nonce,
|
|
266
|
+
proposalHash: require_bridge_governance_keys.ZERO_BYTES32,
|
|
267
|
+
expiresAt
|
|
268
|
+
});
|
|
269
|
+
const out = {
|
|
270
|
+
version: 1,
|
|
271
|
+
plane: "ethereum",
|
|
272
|
+
ocapChainId,
|
|
273
|
+
ocapBridge,
|
|
274
|
+
deployment,
|
|
275
|
+
target,
|
|
276
|
+
action,
|
|
277
|
+
nonce,
|
|
278
|
+
createdAt,
|
|
279
|
+
expiresAt,
|
|
280
|
+
summary
|
|
281
|
+
};
|
|
282
|
+
if (linkedTxHash !== void 0) out.linkedTxHash = linkedTxHash;
|
|
283
|
+
if (refundContext !== void 0) out.refundContext = refundContext;
|
|
284
|
+
return out;
|
|
285
|
+
}
|
|
286
|
+
function validateEvmProposal(proposal) {
|
|
287
|
+
return validateEvmProposalInternal(proposal, false);
|
|
288
|
+
}
|
|
289
|
+
/** Validates an `EvmGovernanceProposal` accepting either `bigint` or canonical decimal strings for numeric fields. */
|
|
290
|
+
function coerceEvmProposal(raw) {
|
|
291
|
+
return validateEvmProposalInternal(raw, true);
|
|
292
|
+
}
|
|
293
|
+
function serializeEvmProposal(proposal) {
|
|
294
|
+
const json = require_bridge_governance_keys.canonicalJson(require_bridge_governance_keys.toJsonSafeValue(validateEvmProposal(proposal)));
|
|
295
|
+
if (require_bridge_governance_keys.utf8ByteLength(json) > require_bridge_governance_keys.MAX_PROPOSAL_JSON_BYTES) throw new Error(`serialized EvmGovernanceProposal exceeds ${require_bridge_governance_keys.MAX_PROPOSAL_JSON_BYTES} bytes`);
|
|
296
|
+
return json;
|
|
297
|
+
}
|
|
298
|
+
function parseEvmProposal(json) {
|
|
299
|
+
const s = require_bridge_governance_keys.assertWellFormedString(json, "proposal JSON");
|
|
300
|
+
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`);
|
|
301
|
+
return validateEvmProposalInternal(require_bridge_governance_strict_json.parseStrictJson(s), true);
|
|
302
|
+
}
|
|
303
|
+
function computeEvmProposalHash(proposal) {
|
|
304
|
+
const canonical = serializeEvmProposal(proposal);
|
|
305
|
+
return `0x${require_utils.bytesToHex(require_sha3.keccak_256(require_utils.concatBytes(require_utils.utf8ToBytes(require_bridge_governance_keys.EVM_PROPOSAL_HASH_PREFIX), require_utils.utf8ToBytes(canonical))))}`;
|
|
306
|
+
}
|
|
307
|
+
function certRequestFromProposal(proposal) {
|
|
308
|
+
const canonical = validateEvmProposal(proposal);
|
|
309
|
+
return {
|
|
310
|
+
deployment: canonical.deployment,
|
|
311
|
+
action: canonical.action,
|
|
312
|
+
target: canonical.target,
|
|
313
|
+
nonce: canonical.nonce,
|
|
314
|
+
proposalHash: computeEvmProposalHash(canonical),
|
|
315
|
+
expiresAt: canonical.expiresAt
|
|
316
|
+
};
|
|
317
|
+
}
|
|
318
|
+
function buildCertFromProposal(proposal) {
|
|
319
|
+
return require_bridge_governance_evm_abi.buildGovernanceCert(certRequestFromProposal(proposal));
|
|
320
|
+
}
|
|
321
|
+
function verifyProposalMatchesCert(proposal, cert, expected) {
|
|
322
|
+
if (!expected || typeof expected !== "object") throw new Error("expected deployment context is required");
|
|
323
|
+
require_bridge_governance_keys.assertAllowedKeys(require_bridge_governance_keys.assertPlainObject(cert, "cert"), CERT_KEYS, "cert");
|
|
324
|
+
const normCert = {
|
|
325
|
+
target: require_bridge_governance_keys.checkedNonZeroAddress(cert.target, "cert.target"),
|
|
326
|
+
selector: require_bridge_governance_keys.checkedBytes4(cert.selector, "cert.selector"),
|
|
327
|
+
paramsHash: require_bridge_governance_keys.checkedBytes32(cert.paramsHash, "cert.paramsHash"),
|
|
328
|
+
nonce: require_bridge_governance_keys.parseDecimalBigInt(cert.nonce, "cert.nonce", 0n, require_bridge_governance_keys.MAX_U256),
|
|
329
|
+
proposalHash: require_bridge_governance_keys.checkedBytes32(cert.proposalHash, "cert.proposalHash"),
|
|
330
|
+
expiresAt: require_bridge_governance_keys.parseDecimalBigInt(cert.expiresAt, "cert.expiresAt", 1n, require_bridge_governance_keys.MAX_U64)
|
|
331
|
+
};
|
|
332
|
+
const canonical = validateEvmProposal(proposal);
|
|
333
|
+
const isBareDep = "chainId" in expected && "gateway" in expected;
|
|
334
|
+
const expectedDep = normalizeDeployment(isBareDep ? expected : expected.deployment, true);
|
|
335
|
+
if (canonical.deployment.chainId !== expectedDep.chainId || canonical.deployment.gateway !== expectedDep.gateway || canonical.deployment.validatorSet !== expectedDep.validatorSet || canonical.deployment.signerManager !== expectedDep.signerManager || canonical.deployment.token !== expectedDep.token || canonical.deployment.vault !== expectedDep.vault || canonical.deployment.vaultSignerManager !== expectedDep.vaultSignerManager) throw new Error("proposal.deployment does not match expected trusted deployment");
|
|
336
|
+
if (!isBareDep) {
|
|
337
|
+
if (expected.ocapChainId !== void 0 && canonical.ocapChainId !== require_bridge_governance_keys.assertSafeChainId(expected.ocapChainId)) throw new Error("proposal.ocapChainId does not match expected");
|
|
338
|
+
if (expected.ocapBridge !== void 0 && canonical.ocapBridge !== require_bridge_governance_keys.assertBareBridgeDid(expected.ocapBridge)) throw new Error("proposal.ocapBridge does not match expected");
|
|
339
|
+
}
|
|
340
|
+
const derived = buildCertFromProposal(canonical);
|
|
341
|
+
if (normCert.target !== derived.target || normCert.selector !== derived.selector || normCert.paramsHash !== derived.paramsHash || normCert.nonce !== derived.nonce || normCert.proposalHash !== derived.proposalHash || normCert.expiresAt !== derived.expiresAt) throw new Error("GovernanceCert fields do not match recomputed EvmGovernanceProposal parameters");
|
|
342
|
+
}
|
|
343
|
+
|
|
344
|
+
//#endregion
|
|
345
|
+
exports.buildCertFromProposal = buildCertFromProposal;
|
|
346
|
+
exports.certRequestFromProposal = certRequestFromProposal;
|
|
347
|
+
exports.claimLargeCertExpiresAt = claimLargeCertExpiresAt;
|
|
348
|
+
exports.coerceEvmProposal = coerceEvmProposal;
|
|
349
|
+
exports.computeEvmProposalHash = computeEvmProposalHash;
|
|
350
|
+
exports.parseEvmProposal = parseEvmProposal;
|
|
351
|
+
exports.serializeEvmProposal = serializeEvmProposal;
|
|
352
|
+
exports.validateEvmProposal = validateEvmProposal;
|
|
353
|
+
exports.verifyProposalMatchesCert = verifyProposalMatchesCert;
|
|
@@ -0,0 +1,39 @@
|
|
|
1
|
+
import { CertRequest, EvmDeployment, GovernanceCert, GovernedAction } from "./evm-abi.cjs";
|
|
2
|
+
|
|
3
|
+
//#region src/bridge-governance/evm-proposals.d.ts
|
|
4
|
+
interface RefundContext {
|
|
5
|
+
depositTxHash: string;
|
|
6
|
+
originalDepositor: string;
|
|
7
|
+
}
|
|
8
|
+
interface EvmGovernanceProposal {
|
|
9
|
+
version: 1;
|
|
10
|
+
plane: 'ethereum';
|
|
11
|
+
ocapChainId: string;
|
|
12
|
+
ocapBridge: string;
|
|
13
|
+
deployment: EvmDeployment;
|
|
14
|
+
target: string;
|
|
15
|
+
action: GovernedAction;
|
|
16
|
+
nonce: bigint;
|
|
17
|
+
createdAt: bigint;
|
|
18
|
+
expiresAt: bigint;
|
|
19
|
+
summary: string;
|
|
20
|
+
linkedTxHash?: string;
|
|
21
|
+
refundContext?: RefundContext;
|
|
22
|
+
}
|
|
23
|
+
interface ExpectedEvmProposalContext {
|
|
24
|
+
deployment: EvmDeployment;
|
|
25
|
+
ocapChainId?: string;
|
|
26
|
+
ocapBridge?: string;
|
|
27
|
+
}
|
|
28
|
+
declare function claimLargeCertExpiresAt(voucherExpiresAt: bigint, nowSec: bigint, delaySec: bigint): bigint;
|
|
29
|
+
declare function validateEvmProposal(proposal: EvmGovernanceProposal): EvmGovernanceProposal;
|
|
30
|
+
/** Validates an `EvmGovernanceProposal` accepting either `bigint` or canonical decimal strings for numeric fields. */
|
|
31
|
+
declare function coerceEvmProposal(raw: unknown): EvmGovernanceProposal;
|
|
32
|
+
declare function serializeEvmProposal(proposal: EvmGovernanceProposal): string;
|
|
33
|
+
declare function parseEvmProposal(json: string): EvmGovernanceProposal;
|
|
34
|
+
declare function computeEvmProposalHash(proposal: EvmGovernanceProposal): string;
|
|
35
|
+
declare function certRequestFromProposal(proposal: EvmGovernanceProposal): CertRequest;
|
|
36
|
+
declare function buildCertFromProposal(proposal: EvmGovernanceProposal): GovernanceCert;
|
|
37
|
+
declare function verifyProposalMatchesCert(proposal: EvmGovernanceProposal, cert: GovernanceCert, expected: EvmDeployment | ExpectedEvmProposalContext): void;
|
|
38
|
+
//#endregion
|
|
39
|
+
export { EvmGovernanceProposal, ExpectedEvmProposalContext, RefundContext, buildCertFromProposal, certRequestFromProposal, claimLargeCertExpiresAt, coerceEvmProposal, computeEvmProposalHash, parseEvmProposal, serializeEvmProposal, validateEvmProposal, verifyProposalMatchesCert };
|
|
@@ -0,0 +1,130 @@
|
|
|
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
|
+
|
|
8
|
+
//#region src/bridge-governance/evm-sync.ts
|
|
9
|
+
const BRIDGE_EVM_GOV_SYNC_DOMAIN_NAME = require_bridge_governance_evm_abi.ARC_BRIDGE_EIP712_NAME;
|
|
10
|
+
const BRIDGE_EVM_GOV_SYNC_DOMAIN_VERSION = require_bridge_governance_evm_abi.ARC_BRIDGE_EIP712_VERSION;
|
|
11
|
+
const BRIDGE_EVM_GOV_SYNC_TYPE_STRING = "BridgeEvmGovernanceSync(string bridge,uint64 version,bytes32 configHash,uint64 expiresAt)";
|
|
12
|
+
const EIP712_PREFIX = new Uint8Array([25, 1]);
|
|
13
|
+
const SYNC_DOMAIN_TYPE_HASH = require_sha3.keccak_256(require_utils.utf8ToBytes("EIP712Domain(string name,string version,bytes32 salt)"));
|
|
14
|
+
const SYNC_NAME_HASH = require_sha3.keccak_256(require_utils.utf8ToBytes(BRIDGE_EVM_GOV_SYNC_DOMAIN_NAME));
|
|
15
|
+
const SYNC_VERSION_HASH = require_sha3.keccak_256(require_utils.utf8ToBytes(BRIDGE_EVM_GOV_SYNC_DOMAIN_VERSION));
|
|
16
|
+
const SYNC_TYPE_HASH = require_sha3.keccak_256(require_utils.utf8ToBytes(BRIDGE_EVM_GOV_SYNC_TYPE_STRING));
|
|
17
|
+
const ROSTER_ENTRY_KEYS = new Set([
|
|
18
|
+
"address",
|
|
19
|
+
"signers",
|
|
20
|
+
"seeds",
|
|
21
|
+
"threshold",
|
|
22
|
+
"seedThreshold"
|
|
23
|
+
]);
|
|
24
|
+
const ROSTER_CONFIG_KEYS = new Set([
|
|
25
|
+
"version",
|
|
26
|
+
"signerManager",
|
|
27
|
+
"vaultSignerManager"
|
|
28
|
+
]);
|
|
29
|
+
const EVM_GOV_SYNC_MSG_KEYS = new Set([
|
|
30
|
+
"bridge",
|
|
31
|
+
"version",
|
|
32
|
+
"configHash",
|
|
33
|
+
"expiresAt"
|
|
34
|
+
]);
|
|
35
|
+
function uint64Word(val, name) {
|
|
36
|
+
require_bridge_governance_keys.assertBigIntRange(val, name, 1n, require_bridge_governance_keys.MAX_U64);
|
|
37
|
+
return require_utils.hexToBytes(val.toString(16).padStart(64, "0"));
|
|
38
|
+
}
|
|
39
|
+
function normalizeSignerManagerRoster(raw, name) {
|
|
40
|
+
const rec = require_bridge_governance_keys.assertPlainObject(raw, name);
|
|
41
|
+
require_bridge_governance_keys.assertAllowedKeys(rec, ROSTER_ENTRY_KEYS, name);
|
|
42
|
+
const address = require_bridge_governance_keys.checkedNonZeroAddress(rec.address, `${name}.address`);
|
|
43
|
+
if (!Array.isArray(rec.signers) || rec.signers.length === 0 || rec.signers.length > require_bridge_governance_keys.MAX_EVM_SIGNERS) throw new Error(`${name}.signers must contain 1..${require_bridge_governance_keys.MAX_EVM_SIGNERS} addresses`);
|
|
44
|
+
const signers = require_bridge_governance_keys.sortStrictChecksumAddresses(rec.signers, `${name}.signers`);
|
|
45
|
+
const signerSet = new Set(signers);
|
|
46
|
+
if (!Array.isArray(rec.seeds) || rec.seeds.length === 0 || rec.seeds.length > signers.length) throw new Error(`${name}.seeds must contain 1..${signers.length} addresses`);
|
|
47
|
+
const seeds = require_bridge_governance_keys.sortStrictChecksumAddresses(rec.seeds, `${name}.seeds`);
|
|
48
|
+
for (const seed of seeds) if (!signerSet.has(seed)) throw new Error(`${name}.seeds member ${seed} is not in ${name}.signers`);
|
|
49
|
+
const threshold = require_bridge_governance_keys.assertSafeUint(rec.threshold, `${name}.threshold`, 1, signers.length);
|
|
50
|
+
const seedThreshold = require_bridge_governance_keys.assertSafeUint(rec.seedThreshold, `${name}.seedThreshold`, 1, seeds.length);
|
|
51
|
+
if (seedThreshold > threshold) throw new Error(`${name}.seedThreshold cannot exceed ${name}.threshold`);
|
|
52
|
+
return {
|
|
53
|
+
address,
|
|
54
|
+
signers,
|
|
55
|
+
seeds,
|
|
56
|
+
threshold,
|
|
57
|
+
seedThreshold
|
|
58
|
+
};
|
|
59
|
+
}
|
|
60
|
+
/**
|
|
61
|
+
* Validates and canonicalizes an `EvmGovernanceRosterConfig`:
|
|
62
|
+
* - EIP-55 checksummed addresses, strictly ascending unique `signers` (`1..32`) and `seeds` (`1..signers.length`, subset of `signers`)
|
|
63
|
+
* - `1 <= threshold <= signers.length`, `1 <= seedThreshold <= seeds.length`, `seedThreshold <= threshold`
|
|
64
|
+
* - `Number.isSafeInteger(version) && version >= 1`
|
|
65
|
+
* - Enforces `< 2 KB` serialized JSON cap (`MAX_EVM_GOV_ROSTER_JSON_BYTES`).
|
|
66
|
+
*/
|
|
67
|
+
function validateEvmGovernanceRosterConfig(cfg) {
|
|
68
|
+
const rec = require_bridge_governance_keys.assertPlainObject(cfg, "EvmGovernanceRosterConfig");
|
|
69
|
+
require_bridge_governance_keys.assertAllowedKeys(rec, ROSTER_CONFIG_KEYS, "EvmGovernanceRosterConfig");
|
|
70
|
+
const version = require_bridge_governance_keys.assertSafeUint(rec.version, "EvmGovernanceRosterConfig.version", 1, Number.MAX_SAFE_INTEGER);
|
|
71
|
+
const signerManager = normalizeSignerManagerRoster(rec.signerManager, "signerManager");
|
|
72
|
+
const vaultSignerManager = rec.vaultSignerManager === null ? null : normalizeSignerManagerRoster(rec.vaultSignerManager, "vaultSignerManager");
|
|
73
|
+
if (vaultSignerManager !== null && signerManager.address === vaultSignerManager.address && require_bridge_governance_keys.canonicalJson(signerManager) !== require_bridge_governance_keys.canonicalJson(vaultSignerManager)) throw new Error("shared signerManager and vaultSignerManager address must carry identical rosters");
|
|
74
|
+
const normalized = {
|
|
75
|
+
version,
|
|
76
|
+
signerManager,
|
|
77
|
+
vaultSignerManager
|
|
78
|
+
};
|
|
79
|
+
if (require_bridge_governance_keys.utf8ByteLength(require_bridge_governance_keys.canonicalJson(normalized)) >= require_bridge_governance_keys.MAX_EVM_GOV_ROSTER_JSON_BYTES) throw new Error(`EvmGovernanceRosterConfig exceeds ${require_bridge_governance_keys.MAX_EVM_GOV_ROSTER_JSON_BYTES} byte limit`);
|
|
80
|
+
return normalized;
|
|
81
|
+
}
|
|
82
|
+
function serializeEvmGovernanceRosterConfig(cfg) {
|
|
83
|
+
return require_bridge_governance_keys.canonicalJson(validateEvmGovernanceRosterConfig(cfg));
|
|
84
|
+
}
|
|
85
|
+
function parseEvmGovernanceRosterConfig(json) {
|
|
86
|
+
const s = require_bridge_governance_keys.assertWellFormedString(json, "EvmGovernanceRosterConfig JSON");
|
|
87
|
+
if (require_bridge_governance_keys.utf8ByteLength(s) >= require_bridge_governance_keys.MAX_EVM_GOV_ROSTER_JSON_BYTES) throw new Error(`EvmGovernanceRosterConfig JSON exceeds ${require_bridge_governance_keys.MAX_EVM_GOV_ROSTER_JSON_BYTES} bytes`);
|
|
88
|
+
return validateEvmGovernanceRosterConfig(require_bridge_governance_strict_json.parseStrictJson(s));
|
|
89
|
+
}
|
|
90
|
+
function computeEvmGovernanceConfigHash(cfg) {
|
|
91
|
+
const canonical = serializeEvmGovernanceRosterConfig(cfg);
|
|
92
|
+
return `0x${require_utils.bytesToHex(require_sha3.keccak_256(require_utils.concatBytes(require_utils.utf8ToBytes(require_bridge_governance_keys.EVM_GOV_CONFIG_HASH_PREFIX), require_utils.utf8ToBytes(canonical))))}`;
|
|
93
|
+
}
|
|
94
|
+
function computeBridgeEvmGovernanceSyncDigest(ocapChainId, message) {
|
|
95
|
+
const chainId = require_bridge_governance_keys.assertSafeChainId(ocapChainId, "ocapChainId");
|
|
96
|
+
require_bridge_governance_keys.assertAllowedKeys(require_bridge_governance_keys.assertPlainObject(message, "BridgeEvmGovernanceSync"), EVM_GOV_SYNC_MSG_KEYS, "BridgeEvmGovernanceSync");
|
|
97
|
+
const bridge = require_bridge_governance_keys.assertBareBridgeDid(message.bridge, "BridgeEvmGovernanceSync.bridge");
|
|
98
|
+
const versionWord = uint64Word(message.version, "BridgeEvmGovernanceSync.version");
|
|
99
|
+
const configHashBytes = require_utils.hexToBytes(require_bridge_governance_keys.checkedBytes32(message.configHash, "BridgeEvmGovernanceSync.configHash").slice(2));
|
|
100
|
+
const expiresAtWord = uint64Word(message.expiresAt, "BridgeEvmGovernanceSync.expiresAt");
|
|
101
|
+
return require_sha3.keccak_256(require_utils.concatBytes(EIP712_PREFIX, require_sha3.keccak_256(require_utils.concatBytes(SYNC_DOMAIN_TYPE_HASH, SYNC_NAME_HASH, SYNC_VERSION_HASH, require_sha3.keccak_256(require_utils.utf8ToBytes(chainId)))), require_sha3.keccak_256(require_utils.concatBytes(SYNC_TYPE_HASH, require_sha3.keccak_256(require_utils.utf8ToBytes(bridge)), versionWord, configHashBytes, expiresAtWord))));
|
|
102
|
+
}
|
|
103
|
+
function bridgeEvmGovernanceSyncDigest(ocapChainId, message) {
|
|
104
|
+
return `0x${require_utils.bytesToHex(computeBridgeEvmGovernanceSyncDigest(ocapChainId, message))}`;
|
|
105
|
+
}
|
|
106
|
+
function recoverBridgeEvmGovernanceSyncSigner(ocapChainId, message, sig) {
|
|
107
|
+
const signature = require_bridge_governance_evm_abi.normalizeEcdsaSignature(sig);
|
|
108
|
+
const recovered = require_bridge_governance_membership.recoverBridgeSigner(computeBridgeEvmGovernanceSyncDigest(ocapChainId, message), signature);
|
|
109
|
+
if (!recovered) throw new Error("failed to recover BridgeEvmGovernanceSync signer");
|
|
110
|
+
return {
|
|
111
|
+
signer: require_bridge_governance_keys.checkedNonZeroAddress(recovered.address, "recovered signer"),
|
|
112
|
+
signature
|
|
113
|
+
};
|
|
114
|
+
}
|
|
115
|
+
function signBridgeEvmGovernanceSync(ocapChainId, message, privateKey) {
|
|
116
|
+
return require_bridge_governance_membership.signBridgeDigest(computeBridgeEvmGovernanceSyncDigest(ocapChainId, message), privateKey);
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
//#endregion
|
|
120
|
+
exports.BRIDGE_EVM_GOV_SYNC_DOMAIN_NAME = BRIDGE_EVM_GOV_SYNC_DOMAIN_NAME;
|
|
121
|
+
exports.BRIDGE_EVM_GOV_SYNC_DOMAIN_VERSION = BRIDGE_EVM_GOV_SYNC_DOMAIN_VERSION;
|
|
122
|
+
exports.BRIDGE_EVM_GOV_SYNC_TYPE_STRING = BRIDGE_EVM_GOV_SYNC_TYPE_STRING;
|
|
123
|
+
exports.bridgeEvmGovernanceSyncDigest = bridgeEvmGovernanceSyncDigest;
|
|
124
|
+
exports.computeBridgeEvmGovernanceSyncDigest = computeBridgeEvmGovernanceSyncDigest;
|
|
125
|
+
exports.computeEvmGovernanceConfigHash = computeEvmGovernanceConfigHash;
|
|
126
|
+
exports.parseEvmGovernanceRosterConfig = parseEvmGovernanceRosterConfig;
|
|
127
|
+
exports.recoverBridgeEvmGovernanceSyncSigner = recoverBridgeEvmGovernanceSyncSigner;
|
|
128
|
+
exports.serializeEvmGovernanceRosterConfig = serializeEvmGovernanceRosterConfig;
|
|
129
|
+
exports.signBridgeEvmGovernanceSync = signBridgeEvmGovernanceSync;
|
|
130
|
+
exports.validateEvmGovernanceRosterConfig = validateEvmGovernanceRosterConfig;
|
|
@@ -0,0 +1,45 @@
|
|
|
1
|
+
//#region src/bridge-governance/evm-sync.d.ts
|
|
2
|
+
interface EvmSignerManagerRoster {
|
|
3
|
+
address: string;
|
|
4
|
+
/** Strictly ascending EIP-55 checksummed non-zero Ethereum addresses (`1..32`). */
|
|
5
|
+
signers: string[];
|
|
6
|
+
/** Strictly ascending EIP-55 checksummed subset of `signers` (`1..signers.length`). */
|
|
7
|
+
seeds: string[];
|
|
8
|
+
threshold: number;
|
|
9
|
+
seedThreshold: number;
|
|
10
|
+
}
|
|
11
|
+
interface EvmGovernanceRosterConfig {
|
|
12
|
+
version: number;
|
|
13
|
+
signerManager: EvmSignerManagerRoster;
|
|
14
|
+
/** Dedicated or shared `SignerManagerV2` roster for `Vault` (`null` only when bridge has no vault). */
|
|
15
|
+
vaultSignerManager: EvmSignerManagerRoster | null;
|
|
16
|
+
}
|
|
17
|
+
declare const BRIDGE_EVM_GOV_SYNC_DOMAIN_NAME = "ArcBridge";
|
|
18
|
+
declare const BRIDGE_EVM_GOV_SYNC_DOMAIN_VERSION = "1";
|
|
19
|
+
declare const BRIDGE_EVM_GOV_SYNC_TYPE_STRING = "BridgeEvmGovernanceSync(string bridge,uint64 version,bytes32 configHash,uint64 expiresAt)";
|
|
20
|
+
interface BridgeEvmGovernanceSyncMessage {
|
|
21
|
+
bridge: string;
|
|
22
|
+
version: bigint;
|
|
23
|
+
configHash: string;
|
|
24
|
+
expiresAt: bigint;
|
|
25
|
+
}
|
|
26
|
+
/**
|
|
27
|
+
* Validates and canonicalizes an `EvmGovernanceRosterConfig`:
|
|
28
|
+
* - EIP-55 checksummed addresses, strictly ascending unique `signers` (`1..32`) and `seeds` (`1..signers.length`, subset of `signers`)
|
|
29
|
+
* - `1 <= threshold <= signers.length`, `1 <= seedThreshold <= seeds.length`, `seedThreshold <= threshold`
|
|
30
|
+
* - `Number.isSafeInteger(version) && version >= 1`
|
|
31
|
+
* - Enforces `< 2 KB` serialized JSON cap (`MAX_EVM_GOV_ROSTER_JSON_BYTES`).
|
|
32
|
+
*/
|
|
33
|
+
declare function validateEvmGovernanceRosterConfig(cfg: unknown): EvmGovernanceRosterConfig;
|
|
34
|
+
declare function serializeEvmGovernanceRosterConfig(cfg: EvmGovernanceRosterConfig): string;
|
|
35
|
+
declare function parseEvmGovernanceRosterConfig(json: string): EvmGovernanceRosterConfig;
|
|
36
|
+
declare function computeEvmGovernanceConfigHash(cfg: EvmGovernanceRosterConfig): string;
|
|
37
|
+
declare function computeBridgeEvmGovernanceSyncDigest(ocapChainId: string, message: BridgeEvmGovernanceSyncMessage): Uint8Array;
|
|
38
|
+
declare function bridgeEvmGovernanceSyncDigest(ocapChainId: string, message: BridgeEvmGovernanceSyncMessage): string;
|
|
39
|
+
declare function recoverBridgeEvmGovernanceSyncSigner(ocapChainId: string, message: BridgeEvmGovernanceSyncMessage, sig: string): {
|
|
40
|
+
signer: string;
|
|
41
|
+
signature: string;
|
|
42
|
+
};
|
|
43
|
+
declare function signBridgeEvmGovernanceSync(ocapChainId: string, message: BridgeEvmGovernanceSyncMessage, privateKey: Uint8Array): string;
|
|
44
|
+
//#endregion
|
|
45
|
+
export { BRIDGE_EVM_GOV_SYNC_DOMAIN_NAME, BRIDGE_EVM_GOV_SYNC_DOMAIN_VERSION, BRIDGE_EVM_GOV_SYNC_TYPE_STRING, BridgeEvmGovernanceSyncMessage, EvmGovernanceRosterConfig, EvmSignerManagerRoster, bridgeEvmGovernanceSyncDigest, computeBridgeEvmGovernanceSyncDigest, computeEvmGovernanceConfigHash, parseEvmGovernanceRosterConfig, recoverBridgeEvmGovernanceSyncSigner, serializeEvmGovernanceRosterConfig, signBridgeEvmGovernanceSync, validateEvmGovernanceRosterConfig };
|