MCMS Integration test (#107)

* Integration test - set config

* Polish integration test config encoding

* Refactor mcms signer key handling

* Add setRoot call (no MerkleRoot yet)

* Refactor listAsSnake as asSnakeDataUint fn

* Add mcms lib structure (merkle-proof init)

* Add merkle proof TS fn

* Add and use ocr.Signer to fill signatures

* Finish first chainOfActions test

* Compute root, fix proofLen fn

* Post rebase fix

* Fix mcms isSignatureValid call, Iterator size (bytes addr), and off-chain signed hash encoding

* Fix mcms contract, pass test

Author: krebernisak

contracts/contracts/lib/access/access_control.tolk

@@ -174,7 +174,7 @@ struct AccessControl<T> {
     data: AccessControl_Data;
 
     /// Runtime hooks (extensions)
-    context: T?,
+    context: T?;
     hooks: AccessControl_Hooks<T>?;
 }
 

contracts/contracts/mcms/mcms.tolk

@@ -0,0 +1 @@
+export * as merkleProof from './merkle-proof'

contracts/src/mcms/index.ts

@@ -0,0 +1,166 @@
+import { beginCell, Cell } from '@ton/core'
+import { asSnakeData, uint8ArrayToBigInt } from '../utils'
+
+import { ocr } from '../../wrappers/libraries/ocr'
+import { mcms } from '../../wrappers/mcms'
+
+export const ROOT_METADATA_LEAF_INDEX = 0
+
+export type OpProofs = bigint[][]
+
+export function build(
+  signers: ocr.Signer[],
+  validUntil: bigint,
+  metadata: mcms.RootMetadata,
+  ops: mcms.Op[],
+): [mcms.SetRoot, OpProofs] {
+  const leaves = constructLeaves(ops, metadata)
+
+  const { root, metadataProof, signatures } = constructAnsSignRootAndProof(
+    leaves,
+    validUntil,
+    signers,
+  )
+
+  // Compute proofs for each op
+  const computeProof = (i: number): bigint[] => computeProofForLeaf(leaves, getLeafIndexOfOp(i))
+  const opProofs: OpProofs = Array.from({ length: ops.length }, (_, i) => computeProof(i))
+
+  const encodeProof = (v) => beginCell().storeUint(v, 256)
+  const encodeSignature = (v) => mcms.builder.data.signature.encode(v).asBuilder()
+
+  return [
+    {
+      queryId: 0n,
+      root,
+      validUntil,
+      metadata,
+      metadataProof: asSnakeData<bigint>(metadataProof, encodeProof),
+      signatures: asSnakeData<mcms.Signature>(signatures, encodeSignature),
+    },
+    opProofs,
+  ]
+}
+
+export function computeProofForLeaf(data: bigint[], index: number): bigint[] {
+  // this method assumes that there is an even number of leaves.
+  if (data.length % 2 !== 0) {
+    throw new Error('Invalid proof request: data length must be even')
+  }
+
+  const _proofLen = proofLen(data.length)
+
+  const proof: bigint[] = []
+  while (data.length > 1) {
+    if ((index & 0x1) === 1) {
+      proof.push(data[index - 1])
+    } else {
+      proof.push(data[index + 1])
+    }
+    index = Math.floor(index / 2)
+    data = hashLevel(data)
+  }
+
+  if (proof.length !== _proofLen) {
+    throw new Error(`Invalid proof length: expected ${_proofLen}, got ${proof.length}`)
+  }
+
+  return proof
+}
+
+export const hashLevel = (data: bigint[]): bigint[] => {
+  const newData: bigint[] = []
+  for (let i = 0; i < data.length - 1; i += 2) {
+    newData.push(hashPair(data[i], data[i + 1]))
+  }
+  return newData
+}
+
+// Hashes two 256-bit BigInts, ordering them by value before hashing.
+export function hashPair(a: bigint, b: bigint): bigint {
+  return a < b ? hashInternalNode(a, b) : hashInternalNode(b, a)
+}
+
+// Hashes an internal Merkle node by concatenating two 256-bit BigInts and hashing.
+export function hashInternalNode(left: bigint, right: bigint): bigint {
+  const data = beginCell().storeUint(left, 256).storeUint(right, 256).endCell()
+  return uint8ArrayToBigInt(data.hash())
+}
+
+export function constructLeaves(ops: mcms.Op[], rootMetadata: mcms.RootMetadata): bigint[] {
+  const leaves: bigint[] = new Array(ops.length + 1)
+
+  // Encode rootMetadata as cell and hash
+  const leafMetadata = leafMetadataPreimage(rootMetadata).hash()
+  leaves[ROOT_METADATA_LEAF_INDEX] = uint8ArrayToBigInt(leafMetadata)
+
+  for (let i = 0; i < ops.length; i++) {
+    const leaf = leafOpPreimage(ops[i]).hash()
+    const leafIndex = i >= ROOT_METADATA_LEAF_INDEX ? i + 1 : i
+    leaves[leafIndex] = uint8ArrayToBigInt(leaf)
+  }
+
+  return leaves
+}
+
+export function leafMetadataPreimage(rootMetadata: mcms.RootMetadata): Cell {
+  return beginCell()
+    .storeUint(mcms.MANY_CHAIN_MULTI_SIG_DOMAIN_SEPARATOR_METADATA, 256)
+    .storeBuilder(mcms.builder.data.rootMetadata.encode(rootMetadata).asBuilder())
+    .endCell()
+}
+
+export function leafOpPreimage(op: mcms.Op): Cell {
+  return beginCell()
+    .storeUint(mcms.MANY_CHAIN_MULTI_SIG_DOMAIN_SEPARATOR_OP, 256)
+    .storeRef(mcms.builder.data.op.encode(op)) // Doesn't fit in root cell
+    .endCell()
+}
+
+export function proofLen(leavesLen: number): number {
+  return Math.ceil(Math.log2(leavesLen))
+}
+
+export function getLeafIndexOfOp(opIndex: number): number {
+  return opIndex < ROOT_METADATA_LEAF_INDEX ? opIndex : opIndex + 1
+}
+
+export function constructAnsSignRootAndProof(
+  leaves: bigint[],
+  validUntil: bigint,
+  signers: ocr.Signer[],
+): {
+  root: bigint
+  metadataProof: bigint[]
+  signatures: mcms.Signature[]
+} {
+  const root = computeRoot(leaves)
+  const metadataProof = computeProofForLeaf(leaves, ROOT_METADATA_LEAF_INDEX)
+  const signatures = fillSignatures(root, validUntil, signers)
+  return { root, metadataProof, signatures }
+}
+
+export function computeRoot(leaves: bigint[]): bigint {
+  let currentLayer = leaves
+  while (currentLayer.length > 1) {
+    currentLayer = hashLevel(currentLayer)
+  }
+  return currentLayer[0]
+}
+
+function fillSignatures(root: bigint, validUntil: bigint, signers: ocr.Signer[]): mcms.Signature[] {
+  const signatures: mcms.Signature[] = []
+  const data = beginCell() // TODO: implement as type + CellCodec<T>
+    .storeUint(root, 256)
+    .storeUint(validUntil, 32)
+    .endCell()
+    .hash()
+
+  for (const signer of signers) {
+    const signature = ocr.createSignatureWith(signer, data)
+    // TODO: validate signature
+    signatures.push(signature)
+  }
+
+  return signatures
+}

contracts/src/mcms/merkle-proof.ts

@@ -0,0 +1,13 @@
+import { Dictionary, DictionaryKeyTypes, DictionaryKey, DictionaryValue } from '@ton/core'
+
+export const loadMap = <K extends DictionaryKeyTypes, V>(
+  key: DictionaryKey<K>,
+  value: DictionaryValue<V>,
+  map: Map<K, V>,
+): Dictionary<K, V> => {
+  const dict = Dictionary.empty(key, value)
+  for (const [k, v] of map) {
+    dict.set(k, v)
+  }
+  return dict
+}

contracts/src/utils/dict.ts

@@ -66,6 +66,10 @@ export function fromSnakeData<T>(data: Cell, readerFn: (cs: Slice) => T): T[] {
   return array
 }
 
+export function asSnakeDataUint(data: bigint[] | number[], bits: number): Cell {
+  return asSnakeData(data, (item: bigint | number) => new Builder().storeUint(item, bits))
+}
+
 export function isEmpty(slice: Slice): boolean {
   const remainingBits = slice.remainingBits
   const remainingRefs = slice.remainingRefs

contracts/utils/index.ts contracts/src/utils/index.tscontracts/utils/index.ts renamed to contracts/src/utils/index.ts

@@ -11,7 +11,7 @@ import {
 } from '../../wrappers/ccip/FeeQuoter'
 import { testLog, getExternals } from '../Logs'
 import '@ton/test-utils'
-import { ZERO_ADDRESS } from '../../utils'
+import { ZERO_ADDRESS } from '../../src/utils'
 
 const CHAINSEL_EVM_TEST_90000001 = 909606746561742123n
 const CHAINSEL_TON = 13879075125137744094n

contracts/utils/types.ts contracts/src/utils/types.tscontracts/utils/types.ts renamed to contracts/src/utils/types.ts

@@ -11,7 +11,7 @@ import {
   TimestampedPrice,
 } from '../../wrappers/ccip/FeeQuoter'
 import '@ton/test-utils'
-import { uint8ArrayToBigInt, ZERO_ADDRESS } from '../../utils'
+import { uint8ArrayToBigInt, ZERO_ADDRESS } from '../../src/utils'
 import { KeyPair } from '@ton/crypto'
 import { expectEqualsConfig, generateEd25519KeyPair } from '../libraries/ocr/Helpers'
 import {

contracts/tests/ccip/CCIPRouter.spec.ts

@@ -1,5 +1,5 @@
 import { Blockchain, SandboxContract, TreasuryContract } from '@ton/sandbox'
-import { ZERO_ADDRESS } from '../../../utils'
+import { ZERO_ADDRESS } from '../../../src/utils'
 import {
   createTimestampedPriceValue,
   FeeQuoter,