@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,179 @@
1
+ //#region src/bridge-governance/evm-abi.d.ts
2
+ declare const SECP256K1_N = 115792089237316195423570985008687907852837564279074904382605163141518161494337n;
3
+ declare const SECP256K1_HALF_N = 57896044618658097711785492504343953926418782139537452191302581570759080747168n;
4
+ declare const ARC_BRIDGE_EIP712_NAME = "ArcBridge";
5
+ declare const ARC_BRIDGE_EIP712_VERSION = "1";
6
+ declare const GOVERNANCE_CERT_TYPE_STRING = "GovernanceCert(address target,bytes4 selector,bytes32 paramsHash,uint256 nonce,bytes32 proposalHash,uint64 expiresAt)";
7
+ interface EvmGatewayParams {
8
+ minDeposit: bigint;
9
+ midThreshold: bigint;
10
+ largeThreshold: bigint;
11
+ dailyCap: bigint;
12
+ recipientDailyCap: bigint;
13
+ smallDailyCap: bigint;
14
+ }
15
+ interface EvmWithdrawVoucher {
16
+ ocapTxHash: string;
17
+ to: string;
18
+ amount: bigint;
19
+ validAfter: bigint;
20
+ expiresAt: bigint;
21
+ epoch: bigint;
22
+ }
23
+ type GovernedAction = {
24
+ kind: 'unpause';
25
+ } | {
26
+ kind: 'setParams';
27
+ params: EvmGatewayParams;
28
+ } | {
29
+ kind: 'setVault';
30
+ vault: string;
31
+ } | {
32
+ kind: 'claimLarge';
33
+ voucher: EvmWithdrawVoucher;
34
+ gatewayChainId: bigint;
35
+ } | {
36
+ kind: 'rotate';
37
+ validators: string[];
38
+ threshold: bigint;
39
+ } | {
40
+ kind: 'setSentinels';
41
+ sentinels: string[];
42
+ } | {
43
+ kind: 'addSigner';
44
+ signer: string;
45
+ } | {
46
+ kind: 'removeSigner';
47
+ signer: string;
48
+ } | {
49
+ kind: 'replaceSeed';
50
+ oldSeed: string;
51
+ newSeed: string;
52
+ } | {
53
+ kind: 'setThresholds';
54
+ threshold: bigint;
55
+ seedThreshold: bigint;
56
+ } | {
57
+ kind: 'setDelay';
58
+ target: string;
59
+ selector: string;
60
+ delay: bigint;
61
+ } | {
62
+ kind: 'increaseAllowance';
63
+ spender: string;
64
+ amount: bigint;
65
+ } | {
66
+ kind: 'decreaseAllowance';
67
+ spender: string;
68
+ amount: bigint;
69
+ } | {
70
+ kind: 'transferToken';
71
+ erc20: string;
72
+ to: string;
73
+ amount: bigint;
74
+ };
75
+ type GovernedContract = 'gateway' | 'validatorSet' | 'signerManager' | 'vault';
76
+ declare const GOVERNED_FUNCTIONS: {
77
+ readonly unpause: {
78
+ readonly contract: "gateway";
79
+ readonly signature: "unpause(bytes32)";
80
+ };
81
+ readonly setParams: {
82
+ readonly contract: "gateway";
83
+ readonly signature: "setParams(bytes32,(uint256,uint256,uint256,uint256,uint256,uint256))";
84
+ };
85
+ readonly setVault: {
86
+ readonly contract: "gateway";
87
+ readonly signature: "setVault(bytes32,address)";
88
+ };
89
+ readonly claimLarge: {
90
+ readonly contract: "gateway";
91
+ readonly signature: "claimLarge((bytes32,address,uint256,uint64,uint64,uint64),bytes[],(address,bytes4,bytes32,bytes32,uint64),bytes[],bytes32)";
92
+ };
93
+ readonly rotate: {
94
+ readonly contract: "validatorSet";
95
+ readonly signature: "rotate(bytes32,address[],uint256)";
96
+ };
97
+ readonly setSentinels: {
98
+ readonly contract: "validatorSet";
99
+ readonly signature: "setSentinels(bytes32,address[])";
100
+ };
101
+ readonly addSigner: {
102
+ readonly contract: "signerManager";
103
+ readonly signature: "addSigner(bytes32,address)";
104
+ };
105
+ readonly removeSigner: {
106
+ readonly contract: "signerManager";
107
+ readonly signature: "removeSigner(bytes32,address)";
108
+ };
109
+ readonly replaceSeed: {
110
+ readonly contract: "signerManager";
111
+ readonly signature: "replaceSeed(bytes32,address,address)";
112
+ };
113
+ readonly setThresholds: {
114
+ readonly contract: "signerManager";
115
+ readonly signature: "setThresholds(bytes32,uint256,uint256)";
116
+ };
117
+ readonly setDelay: {
118
+ readonly contract: "signerManager";
119
+ readonly signature: "setDelay(bytes32,address,bytes4,uint64)";
120
+ };
121
+ readonly increaseAllowance: {
122
+ readonly contract: "vault";
123
+ readonly signature: "increaseAllowance(bytes32,address,uint256)";
124
+ };
125
+ readonly decreaseAllowance: {
126
+ readonly contract: "vault";
127
+ readonly signature: "decreaseAllowance(bytes32,address,uint256)";
128
+ };
129
+ readonly transferToken: {
130
+ readonly contract: "vault";
131
+ readonly signature: "transferToken(bytes32,address,address,uint256)";
132
+ };
133
+ };
134
+ interface EvmDeployment {
135
+ chainId: bigint;
136
+ token?: string;
137
+ gateway: string;
138
+ validatorSet: string;
139
+ signerManager: string;
140
+ vault?: string;
141
+ vaultSignerManager?: string;
142
+ }
143
+ interface GovernanceCert {
144
+ target: string;
145
+ selector: string;
146
+ paramsHash: string;
147
+ nonce: bigint;
148
+ proposalHash: string;
149
+ expiresAt: bigint;
150
+ }
151
+ interface CertRequest {
152
+ deployment: EvmDeployment;
153
+ action: GovernedAction;
154
+ target: string;
155
+ nonce: bigint;
156
+ proposalHash: string;
157
+ expiresAt: bigint;
158
+ }
159
+ declare function selectorOf(kind: GovernedAction['kind']): string;
160
+ declare function computeWithdrawVoucherDigest(chainId: bigint, verifyingContract: string, v: EvmWithdrawVoucher): string;
161
+ declare function paramsHashOf(action: GovernedAction, target: string): string;
162
+ declare function normalizeEcdsaSignature(sig: string): string;
163
+ declare function orderGovernanceSignatures(entries: ReadonlyArray<{
164
+ signer: string;
165
+ signature: string;
166
+ }>): string[];
167
+ declare function assertDistinctDeploymentAddresses(d: EvmDeployment): void;
168
+ declare function signerManagerFor(d: EvmDeployment, target: string): string;
169
+ declare function defaultCertExpiresAt(nowSec: bigint, delaySec: bigint, executionWindowSec?: bigint): bigint;
170
+ declare function validateGovernedRequest(r: CertRequest): void;
171
+ declare function buildGovernanceCert(r: CertRequest): GovernanceCert;
172
+ declare function computeGovernanceCertDigest(deployment: EvmDeployment, cert: GovernanceCert): Uint8Array;
173
+ declare function recoverGovernanceCertSigner(deployment: EvmDeployment, cert: GovernanceCert, sig: string): {
174
+ signer: string;
175
+ signature: string;
176
+ };
177
+ declare function signGovernanceCert(deployment: EvmDeployment, cert: GovernanceCert, privateKey: Uint8Array): string;
178
+ //#endregion
179
+ export { ARC_BRIDGE_EIP712_NAME, ARC_BRIDGE_EIP712_VERSION, CertRequest, EvmDeployment, EvmGatewayParams, EvmWithdrawVoucher, GOVERNANCE_CERT_TYPE_STRING, GOVERNED_FUNCTIONS, GovernanceCert, GovernedAction, GovernedContract, SECP256K1_HALF_N, SECP256K1_N, assertDistinctDeploymentAddresses, buildGovernanceCert, computeGovernanceCertDigest, computeWithdrawVoucherDigest, defaultCertExpiresAt, normalizeEcdsaSignature, orderGovernanceSignatures, paramsHashOf, recoverGovernanceCertSigner, selectorOf, signGovernanceCert, signerManagerFor, validateGovernedRequest };
@@ -0,0 +1,344 @@
1
+ import { recoverBridgeSigner, signBridgeDigest } from "./membership.mjs";
2
+ import { MAX_EVM_SIGNERS, MAX_U256, MAX_U64, ZERO_ADDRESS, assertBigIntRange, checkedBytes32, checkedBytes4, checkedNonZeroAddress, checksumEthAddress } from "./keys.mjs";
3
+ import { keccak_256 } from "@noble/hashes/sha3.js";
4
+ import { bytesToHex, concatBytes, hexToBytes, utf8ToBytes } from "@noble/hashes/utils.js";
5
+
6
+ //#region src/bridge-governance/evm-abi.ts
7
+ const SECP256K1_N = 115792089237316195423570985008687907852837564279074904382605163141518161494337n;
8
+ const SECP256K1_HALF_N = 57896044618658097711785492504343953926418782139537452191302581570759080747168n;
9
+ const ARC_BRIDGE_EIP712_NAME = "ArcBridge";
10
+ const ARC_BRIDGE_EIP712_VERSION = "1";
11
+ const EIP712_PREFIX = new Uint8Array([25, 1]);
12
+ const EVM_DOMAIN_TYPE_HASH = keccak_256(utf8ToBytes("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"));
13
+ const ARC_BRIDGE_NAME_HASH = keccak_256(utf8ToBytes(ARC_BRIDGE_EIP712_NAME));
14
+ const ARC_BRIDGE_VERSION_HASH = keccak_256(utf8ToBytes(ARC_BRIDGE_EIP712_VERSION));
15
+ const WITHDRAW_VOUCHER_TYPE_HASH = keccak_256(utf8ToBytes("WithdrawVoucher(bytes32 ocapTxHash,address to,uint256 amount,uint64 validAfter,uint64 expiresAt,uint64 epoch)"));
16
+ const GOVERNANCE_CERT_TYPE_STRING = "GovernanceCert(address target,bytes4 selector,bytes32 paramsHash,uint256 nonce,bytes32 proposalHash,uint64 expiresAt)";
17
+ const GOVERNANCE_CERT_TYPE_HASH = keccak_256(utf8ToBytes(GOVERNANCE_CERT_TYPE_STRING));
18
+ const MAX_ROLLING_CAP_EXCLUSIVE = 1n << 200n;
19
+ const MAX_EVM_DELAY_SEC = 30n * 86400n;
20
+ const DEFAULT_EXECUTION_WINDOW_SEC = 7n * 86400n;
21
+ const GOVERNED_FUNCTIONS = {
22
+ unpause: {
23
+ contract: "gateway",
24
+ signature: "unpause(bytes32)"
25
+ },
26
+ setParams: {
27
+ contract: "gateway",
28
+ signature: "setParams(bytes32,(uint256,uint256,uint256,uint256,uint256,uint256))"
29
+ },
30
+ setVault: {
31
+ contract: "gateway",
32
+ signature: "setVault(bytes32,address)"
33
+ },
34
+ claimLarge: {
35
+ contract: "gateway",
36
+ signature: "claimLarge((bytes32,address,uint256,uint64,uint64,uint64),bytes[],(address,bytes4,bytes32,bytes32,uint64),bytes[],bytes32)"
37
+ },
38
+ rotate: {
39
+ contract: "validatorSet",
40
+ signature: "rotate(bytes32,address[],uint256)"
41
+ },
42
+ setSentinels: {
43
+ contract: "validatorSet",
44
+ signature: "setSentinels(bytes32,address[])"
45
+ },
46
+ addSigner: {
47
+ contract: "signerManager",
48
+ signature: "addSigner(bytes32,address)"
49
+ },
50
+ removeSigner: {
51
+ contract: "signerManager",
52
+ signature: "removeSigner(bytes32,address)"
53
+ },
54
+ replaceSeed: {
55
+ contract: "signerManager",
56
+ signature: "replaceSeed(bytes32,address,address)"
57
+ },
58
+ setThresholds: {
59
+ contract: "signerManager",
60
+ signature: "setThresholds(bytes32,uint256,uint256)"
61
+ },
62
+ setDelay: {
63
+ contract: "signerManager",
64
+ signature: "setDelay(bytes32,address,bytes4,uint64)"
65
+ },
66
+ increaseAllowance: {
67
+ contract: "vault",
68
+ signature: "increaseAllowance(bytes32,address,uint256)"
69
+ },
70
+ decreaseAllowance: {
71
+ contract: "vault",
72
+ signature: "decreaseAllowance(bytes32,address,uint256)"
73
+ },
74
+ transferToken: {
75
+ contract: "vault",
76
+ signature: "transferToken(bytes32,address,address,uint256)"
77
+ }
78
+ };
79
+ function uintWord(val, max, name) {
80
+ assertBigIntRange(val, name, 0n, max);
81
+ return hexToBytes(val.toString(16).padStart(64, "0"));
82
+ }
83
+ function addrWord(val, name) {
84
+ return hexToBytes(checksumEthAddress(val, name).slice(2).toLowerCase().padStart(64, "0"));
85
+ }
86
+ function b32Word(val, name) {
87
+ return hexToBytes(checkedBytes32(val, name).slice(2));
88
+ }
89
+ function b4WordRightPadded(val, name) {
90
+ return hexToBytes(checkedBytes4(val, name).slice(2).padEnd(64, "0"));
91
+ }
92
+ function evmDomainSeparator(chainId, verifyingContract) {
93
+ return keccak_256(concatBytes(EVM_DOMAIN_TYPE_HASH, ARC_BRIDGE_NAME_HASH, ARC_BRIDGE_VERSION_HASH, uintWord(chainId, MAX_U256, "domain.chainId"), addrWord(verifyingContract, "domain.verifyingContract")));
94
+ }
95
+ function selectorOf(kind) {
96
+ const sig = GOVERNED_FUNCTIONS[kind]?.signature;
97
+ if (!sig) throw new Error(`unknown governed action ${String(kind)}`);
98
+ return `0x${bytesToHex(keccak_256(utf8ToBytes(sig)).subarray(0, 4))}`;
99
+ }
100
+ function computeWithdrawVoucherDigest(chainId, verifyingContract, v) {
101
+ const structHash = keccak_256(concatBytes(WITHDRAW_VOUCHER_TYPE_HASH, b32Word(v.ocapTxHash, "voucher.ocapTxHash"), addrWord(v.to, "voucher.to"), uintWord(v.amount, MAX_U256, "voucher.amount"), uintWord(v.validAfter, MAX_U64, "voucher.validAfter"), uintWord(v.expiresAt, MAX_U64, "voucher.expiresAt"), uintWord(v.epoch, MAX_U64, "voucher.epoch")));
102
+ return `0x${bytesToHex(keccak_256(concatBytes(EIP712_PREFIX, evmDomainSeparator(chainId, verifyingContract), structHash)))}`;
103
+ }
104
+ function paramsHashOf(action, target) {
105
+ if (!action || typeof action !== "object") throw new Error("invalid governed action");
106
+ const checkedTarget = checksumEthAddress(target, "target");
107
+ switch (action.kind) {
108
+ case "unpause": return `0x${bytesToHex(keccak_256(utf8ToBytes("unpause")))}`;
109
+ case "setParams": {
110
+ const p = action.params;
111
+ if (!p || typeof p !== "object") throw new Error("setParams: missing params");
112
+ return `0x${bytesToHex(keccak_256(concatBytes(uintWord(p.minDeposit, MAX_U256, "setParams.params.minDeposit"), uintWord(p.midThreshold, MAX_U256, "setParams.params.midThreshold"), uintWord(p.largeThreshold, MAX_U256, "setParams.params.largeThreshold"), uintWord(p.dailyCap, MAX_U256, "setParams.params.dailyCap"), uintWord(p.recipientDailyCap, MAX_U256, "setParams.params.recipientDailyCap"), uintWord(p.smallDailyCap, MAX_U256, "setParams.params.smallDailyCap"))))}`;
113
+ }
114
+ case "setVault": return `0x${bytesToHex(keccak_256(addrWord(action.vault, "setVault.vault")))}`;
115
+ case "claimLarge": {
116
+ const chainId = assertBigIntRange(action.gatewayChainId, "claimLarge.gatewayChainId", 1n, MAX_U256);
117
+ if (!action.voucher || typeof action.voucher !== "object") throw new Error("claimLarge: missing voucher");
118
+ return computeWithdrawVoucherDigest(chainId, checkedTarget, action.voucher);
119
+ }
120
+ case "rotate":
121
+ if (!Array.isArray(action.validators)) throw new Error("rotate.validators must be an array");
122
+ return `0x${bytesToHex(keccak_256(concatBytes(...[
123
+ uintWord(64n, MAX_U256, "offset"),
124
+ uintWord(action.threshold, MAX_U256, "rotate.threshold"),
125
+ uintWord(BigInt(action.validators.length), MAX_U256, "rotate.validators.length"),
126
+ ...action.validators.map((v, i) => addrWord(v, `rotate.validators[${i}]`))
127
+ ])))}`;
128
+ case "setSentinels":
129
+ if (!Array.isArray(action.sentinels)) throw new Error("setSentinels.sentinels must be an array");
130
+ return `0x${bytesToHex(keccak_256(concatBytes(...[
131
+ uintWord(32n, MAX_U256, "offset"),
132
+ uintWord(BigInt(action.sentinels.length), MAX_U256, "setSentinels.sentinels.length"),
133
+ ...action.sentinels.map((s, i) => addrWord(s, `setSentinels.sentinels[${i}]`))
134
+ ])))}`;
135
+ case "addSigner":
136
+ case "removeSigner": return `0x${bytesToHex(keccak_256(addrWord(action.signer, `${action.kind}.signer`)))}`;
137
+ case "replaceSeed": return `0x${bytesToHex(keccak_256(concatBytes(addrWord(action.oldSeed, "replaceSeed.oldSeed"), addrWord(action.newSeed, "replaceSeed.newSeed"))))}`;
138
+ case "setThresholds": return `0x${bytesToHex(keccak_256(concatBytes(uintWord(action.threshold, MAX_U256, "setThresholds.threshold"), uintWord(action.seedThreshold, MAX_U256, "setThresholds.seedThreshold"))))}`;
139
+ case "setDelay": return `0x${bytesToHex(keccak_256(concatBytes(addrWord(action.target, "setDelay.target"), b4WordRightPadded(action.selector, "setDelay.selector"), uintWord(action.delay, MAX_U64, "setDelay.delay"))))}`;
140
+ case "increaseAllowance":
141
+ case "decreaseAllowance": return `0x${bytesToHex(keccak_256(concatBytes(addrWord(action.spender, `${action.kind}.spender`), uintWord(action.amount, MAX_U256, `${action.kind}.amount`))))}`;
142
+ case "transferToken": return `0x${bytesToHex(keccak_256(concatBytes(addrWord(action.erc20, "transferToken.erc20"), addrWord(action.to, "transferToken.to"), uintWord(action.amount, MAX_U256, "transferToken.amount"))))}`;
143
+ default: throw new Error(`unknown governed action ${String(action.kind)}`);
144
+ }
145
+ }
146
+ function normalizeEcdsaSignature(sig) {
147
+ if (typeof sig !== "string" || !/^0x[0-9a-fA-F]{130}$/.test(sig)) throw new Error("ECDSA signature must be a 65-byte 0x hex string");
148
+ const lower = sig.slice(2).toLowerCase();
149
+ const r = BigInt(`0x${lower.slice(0, 64)}`);
150
+ const s = BigInt(`0x${lower.slice(64, 128)}`);
151
+ const rawV = Number.parseInt(lower.slice(128, 130), 16);
152
+ const v = rawV === 0 || rawV === 1 ? rawV + 27 : rawV;
153
+ if (v !== 27 && v !== 28) throw new Error(`invalid ECDSA recovery id v=${rawV}`);
154
+ if (r < 1n || r >= SECP256K1_N) throw new Error("ECDSA signature r out of range");
155
+ if (s < 1n || s > SECP256K1_HALF_N) throw new Error("ECDSA signature s is zero or high-s malleable");
156
+ return `0x${lower.slice(0, 128)}${v.toString(16).padStart(2, "0")}`;
157
+ }
158
+ function orderGovernanceSignatures(entries) {
159
+ if (entries.length === 0) throw new Error("governance signature list cannot be empty");
160
+ const normalized = entries.map((e, i) => ({
161
+ signer: checkedNonZeroAddress(e.signer, `entries[${i}].signer`),
162
+ signature: normalizeEcdsaSignature(e.signature)
163
+ }));
164
+ normalized.sort((a, b) => BigInt(a.signer) < BigInt(b.signer) ? -1 : BigInt(a.signer) > BigInt(b.signer) ? 1 : 0);
165
+ for (let i = 1; i < normalized.length; i++) if (normalized[i]?.signer === normalized[i - 1]?.signer) throw new Error(`duplicate governance signature for signer ${normalized[i]?.signer}`);
166
+ return normalized.map((e) => e.signature);
167
+ }
168
+ function assertDistinctDeploymentAddresses(d) {
169
+ const gateway = checkedNonZeroAddress(d.gateway, "deployment.gateway");
170
+ const validatorSet = checkedNonZeroAddress(d.validatorSet, "deployment.validatorSet");
171
+ const signerManager = checkedNonZeroAddress(d.signerManager, "deployment.signerManager");
172
+ const token = d.token !== void 0 ? checkedNonZeroAddress(d.token, "deployment.token") : void 0;
173
+ const vault = d.vault !== void 0 ? checkedNonZeroAddress(d.vault, "deployment.vault") : void 0;
174
+ const vaultSm = d.vaultSignerManager !== void 0 ? checkedNonZeroAddress(d.vaultSignerManager, "deployment.vaultSignerManager") : void 0;
175
+ const primaryRoles = [
176
+ ["gateway", gateway],
177
+ ["validatorSet", validatorSet],
178
+ ["signerManager", signerManager]
179
+ ];
180
+ if (token !== void 0) primaryRoles.push(["token", token]);
181
+ if (vault !== void 0) primaryRoles.push(["vault", vault]);
182
+ const seen = /* @__PURE__ */ new Map();
183
+ for (const [role, addr] of primaryRoles) {
184
+ const prev = seen.get(addr);
185
+ if (prev) throw new Error(`deployment.${role} (${addr}) collides with deployment.${prev}`);
186
+ seen.set(addr, role);
187
+ }
188
+ if (vaultSm !== void 0) {
189
+ const prev = seen.get(vaultSm);
190
+ if (prev !== void 0 && prev !== "signerManager") throw new Error(`deployment.vaultSignerManager (${vaultSm}) collides with deployment.${prev}`);
191
+ }
192
+ }
193
+ function signerManagerFor(d, target) {
194
+ assertDistinctDeploymentAddresses(d);
195
+ const t = checksumEthAddress(target, "target");
196
+ const gateway = checksumEthAddress(d.gateway, "deployment.gateway");
197
+ const validatorSet = checksumEthAddress(d.validatorSet, "deployment.validatorSet");
198
+ const signerManager = checksumEthAddress(d.signerManager, "deployment.signerManager");
199
+ if (t === gateway || t === validatorSet || t === signerManager) return signerManager;
200
+ if (d.vault && t === checksumEthAddress(d.vault, "deployment.vault")) {
201
+ if (!d.vaultSignerManager) throw new Error("deployment missing vaultSignerManager for vault target");
202
+ return checksumEthAddress(d.vaultSignerManager, "deployment.vaultSignerManager");
203
+ }
204
+ if (d.vaultSignerManager && t === checksumEthAddress(d.vaultSignerManager, "deployment.vaultSignerManager")) return checksumEthAddress(d.vaultSignerManager, "deployment.vaultSignerManager");
205
+ throw new Error(`unknown governed target ${t}`);
206
+ }
207
+ function defaultCertExpiresAt(nowSec, delaySec, executionWindowSec = DEFAULT_EXECUTION_WINDOW_SEC) {
208
+ assertBigIntRange(nowSec, "nowSec", 0n, MAX_U64);
209
+ assertBigIntRange(delaySec, "delaySec", 0n, MAX_U64);
210
+ assertBigIntRange(executionWindowSec, "executionWindowSec", 1n, MAX_U64);
211
+ const expiresAt = nowSec + delaySec + executionWindowSec;
212
+ if (expiresAt > MAX_U64) throw new Error("expiresAt out of range");
213
+ return expiresAt;
214
+ }
215
+ function validateGovernedRequest(r) {
216
+ if (!r || typeof r !== "object" || !r.deployment || typeof r.deployment !== "object") throw new Error("invalid certificate request");
217
+ assertBigIntRange(r.deployment.chainId, "deployment.chainId", 1n, MAX_U256);
218
+ assertDistinctDeploymentAddresses(r.deployment);
219
+ const depGateway = checkedNonZeroAddress(r.deployment.gateway, "deployment.gateway");
220
+ const depValidatorSet = checkedNonZeroAddress(r.deployment.validatorSet, "deployment.validatorSet");
221
+ const depSignerManager = checkedNonZeroAddress(r.deployment.signerManager, "deployment.signerManager");
222
+ const depToken = r.deployment.token !== void 0 ? checkedNonZeroAddress(r.deployment.token, "deployment.token") : void 0;
223
+ const depVault = r.deployment.vault !== void 0 ? checkedNonZeroAddress(r.deployment.vault, "deployment.vault") : void 0;
224
+ const depVaultSm = r.deployment.vaultSignerManager !== void 0 ? checkedNonZeroAddress(r.deployment.vaultSignerManager, "deployment.vaultSignerManager") : void 0;
225
+ const a = r.action;
226
+ if (!a || typeof a !== "object" || !Object.prototype.hasOwnProperty.call(GOVERNED_FUNCTIONS, a.kind)) throw new Error(`unknown governed action ${String(a?.kind)}`);
227
+ const contract = GOVERNED_FUNCTIONS[a.kind].contract;
228
+ const target = checkedNonZeroAddress(r.target, "target");
229
+ if (contract === "gateway" || contract === "validatorSet") {
230
+ const expected = contract === "gateway" ? depGateway : depValidatorSet;
231
+ if (target !== expected) throw new Error(`${a.kind} must target the ${contract} ${expected}`);
232
+ } else if (contract === "vault") {
233
+ if (!depVault || !depVaultSm) throw new Error(`${a.kind} requires deployment.vault and deployment.vaultSignerManager`);
234
+ if (target !== depVault) throw new Error(`${a.kind} must target the vault ${depVault}`);
235
+ } else if (target !== depSignerManager && target !== depVaultSm) throw new Error(`${a.kind} must target a deployment signerManager`);
236
+ assertBigIntRange(r.nonce, "nonce", 0n, MAX_U256);
237
+ assertBigIntRange(r.expiresAt, "expiresAt", 1n, MAX_U64);
238
+ checkedBytes32(r.proposalHash, "proposalHash");
239
+ switch (a.kind) {
240
+ case "unpause": break;
241
+ case "setParams": {
242
+ const p = a.params;
243
+ assertBigIntRange(p.minDeposit, "setParams.params.minDeposit", 0n, MAX_U256);
244
+ const mid = assertBigIntRange(p.midThreshold, "setParams.params.midThreshold", 1n, MAX_U256);
245
+ const large = assertBigIntRange(p.largeThreshold, "setParams.params.largeThreshold", 1n, MAX_U256);
246
+ const daily = assertBigIntRange(p.dailyCap, "setParams.params.dailyCap", 1n, MAX_ROLLING_CAP_EXCLUSIVE - 1n);
247
+ const recCap = assertBigIntRange(p.recipientDailyCap, "setParams.params.recipientDailyCap", 1n, MAX_U256);
248
+ const small = assertBigIntRange(p.smallDailyCap, "setParams.params.smallDailyCap", 1n, MAX_U256);
249
+ if (mid > large || recCap > daily || small > daily) throw new Error("setParams: invalid threshold or dailyCap bounds");
250
+ break;
251
+ }
252
+ case "setVault": {
253
+ const next = checksumEthAddress(a.vault, "setVault.vault");
254
+ if (next === ZERO_ADDRESS || next === depGateway || next === depVault || next === depToken || next === depSignerManager || next === depVaultSm || next === depValidatorSet) throw new Error("setVault: vault must not be zero address or an existing protocol contract");
255
+ break;
256
+ }
257
+ case "claimLarge": {
258
+ if (assertBigIntRange(a.gatewayChainId, "claimLarge.gatewayChainId", 1n, MAX_U256) !== r.deployment.chainId) throw new Error("voucher chain mismatch");
259
+ checkedBytes32(a.voucher.ocapTxHash, "claimLarge.voucher.ocapTxHash");
260
+ const to = checksumEthAddress(a.voucher.to, "claimLarge.voucher.to");
261
+ if (to === ZERO_ADDRESS || to === depGateway || to === depVault || to === depToken) throw new Error("claimLarge.voucher.to must not be zero address, gateway, vault, or token");
262
+ assertBigIntRange(a.voucher.amount, "claimLarge.voucher.amount", 1n, MAX_U256);
263
+ if (assertBigIntRange(a.voucher.validAfter, "claimLarge.voucher.validAfter", 0n, MAX_U64) >= assertBigIntRange(a.voucher.expiresAt, "claimLarge.voucher.expiresAt", 1n, MAX_U64)) throw new Error("claimLarge.voucher.validAfter must be less than expiresAt");
264
+ assertBigIntRange(a.voucher.epoch, "claimLarge.voucher.epoch", 1n, MAX_U64);
265
+ break;
266
+ }
267
+ case "rotate": {
268
+ if (!Array.isArray(a.validators) || a.validators.length === 0 || a.validators.length > MAX_EVM_SIGNERS) throw new Error("rotate: duplicate validators or bad threshold");
269
+ const addrs = a.validators.map((v, i) => checksumEthAddress(v, `rotate.validators[${i}]`));
270
+ if (addrs.includes(ZERO_ADDRESS) || new Set(addrs).size !== addrs.length || a.threshold < 1n || a.threshold > BigInt(addrs.length)) throw new Error("rotate: duplicate validators or bad threshold");
271
+ break;
272
+ }
273
+ case "setSentinels": {
274
+ if (!Array.isArray(a.sentinels) || a.sentinels.length === 0) throw new Error("setSentinels: sentinels must not be empty");
275
+ const addrs = a.sentinels.map((s, i) => checksumEthAddress(s, `setSentinels.sentinels[${i}]`));
276
+ if (addrs.includes(ZERO_ADDRESS) || new Set(addrs).size !== addrs.length) throw new Error("setSentinels: duplicate or zero sentinel address");
277
+ break;
278
+ }
279
+ case "addSigner":
280
+ case "removeSigner":
281
+ checkedNonZeroAddress(a.signer, `${a.kind}.signer`);
282
+ break;
283
+ case "replaceSeed":
284
+ if (checkedNonZeroAddress(a.oldSeed, "replaceSeed.oldSeed") === checkedNonZeroAddress(a.newSeed, "replaceSeed.newSeed")) throw new Error("replaceSeed: oldSeed and newSeed must be distinct");
285
+ break;
286
+ case "setThresholds":
287
+ if (a.threshold < 1n || a.threshold > BigInt(MAX_EVM_SIGNERS) || a.seedThreshold < 1n || a.threshold < a.seedThreshold) throw new Error("setThresholds: seedThreshold must be between 1 and threshold (<= 32)");
288
+ break;
289
+ case "setDelay": {
290
+ checkedBytes4(a.selector, "setDelay.selector");
291
+ assertBigIntRange(a.delay, "setDelay.delay", 0n, MAX_EVM_DELAY_SEC);
292
+ const governingSm = signerManagerFor(r.deployment, a.target);
293
+ if (governingSm !== target) throw new Error(`setDelay for ${a.target} must target its governing signerManager ${governingSm}`);
294
+ break;
295
+ }
296
+ case "increaseAllowance":
297
+ case "decreaseAllowance": {
298
+ const spender = checksumEthAddress(a.spender, `${a.kind}.spender`);
299
+ if (spender === ZERO_ADDRESS || spender === target || spender === depVault || spender === depToken || spender === depSignerManager || spender === depVaultSm || spender === depValidatorSet) throw new Error(`${a.kind}: invalid spender address`);
300
+ assertBigIntRange(a.amount, `${a.kind}.amount`, 1n, MAX_U256);
301
+ break;
302
+ }
303
+ case "transferToken": {
304
+ const erc20 = checksumEthAddress(a.erc20, "transferToken.erc20");
305
+ const to = checksumEthAddress(a.to, "transferToken.to");
306
+ if (erc20 === ZERO_ADDRESS || erc20 === target || erc20 === depVault || erc20 === depGateway || erc20 === depSignerManager || erc20 === depVaultSm || erc20 === depValidatorSet) throw new Error("transferToken: invalid erc20 address");
307
+ if (to === ZERO_ADDRESS || to === target || to === depVault || to === depGateway || to === depToken || to === depSignerManager || to === depVaultSm || to === depValidatorSet) throw new Error("transferToken: invalid recipient address");
308
+ assertBigIntRange(a.amount, "transferToken.amount", 1n, MAX_U256);
309
+ break;
310
+ }
311
+ }
312
+ }
313
+ function buildGovernanceCert(r) {
314
+ validateGovernedRequest(r);
315
+ const target = checkedNonZeroAddress(r.target, "target");
316
+ return {
317
+ target,
318
+ selector: selectorOf(r.action.kind),
319
+ paramsHash: paramsHashOf(r.action, target),
320
+ nonce: r.nonce,
321
+ proposalHash: checkedBytes32(r.proposalHash, "proposalHash"),
322
+ expiresAt: r.expiresAt
323
+ };
324
+ }
325
+ function computeGovernanceCertDigest(deployment, cert) {
326
+ const verifyingContract = signerManagerFor(deployment, cert.target);
327
+ const structHash = keccak_256(concatBytes(GOVERNANCE_CERT_TYPE_HASH, addrWord(cert.target, "cert.target"), b4WordRightPadded(cert.selector, "cert.selector"), b32Word(cert.paramsHash, "cert.paramsHash"), uintWord(cert.nonce, MAX_U256, "cert.nonce"), b32Word(cert.proposalHash, "cert.proposalHash"), uintWord(cert.expiresAt, MAX_U64, "cert.expiresAt")));
328
+ return keccak_256(concatBytes(EIP712_PREFIX, evmDomainSeparator(deployment.chainId, verifyingContract), structHash));
329
+ }
330
+ function recoverGovernanceCertSigner(deployment, cert, sig) {
331
+ const signature = normalizeEcdsaSignature(sig);
332
+ const recovered = recoverBridgeSigner(computeGovernanceCertDigest(deployment, cert), signature);
333
+ if (!recovered) throw new Error("failed to recover GovernanceCert signer");
334
+ return {
335
+ signer: checkedNonZeroAddress(recovered.address, "recovered signer"),
336
+ signature
337
+ };
338
+ }
339
+ function signGovernanceCert(deployment, cert, privateKey) {
340
+ return signBridgeDigest(computeGovernanceCertDigest(deployment, cert), privateKey);
341
+ }
342
+
343
+ //#endregion
344
+ export { ARC_BRIDGE_EIP712_NAME, ARC_BRIDGE_EIP712_VERSION, GOVERNANCE_CERT_TYPE_STRING, GOVERNED_FUNCTIONS, SECP256K1_HALF_N, SECP256K1_N, assertDistinctDeploymentAddresses, buildGovernanceCert, computeGovernanceCertDigest, computeWithdrawVoucherDigest, defaultCertExpiresAt, normalizeEcdsaSignature, orderGovernanceSignatures, paramsHashOf, recoverGovernanceCertSigner, selectorOf, signGovernanceCert, signerManagerFor, validateGovernedRequest };
@@ -0,0 +1,39 @@
1
+ import { CertRequest, EvmDeployment, GovernanceCert, GovernedAction } from "./evm-abi.mjs";
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 };