primitives: minimiseSignedTopology

Author: attente

packages/wallet/core/src/state/local/index.ts

@@ -313,6 +313,8 @@ export class Provider implements ProviderInterface {
         continue
       }
 
+      const minimalTopology = Config.minimiseSignedTopology(encoded, fromConfig.threshold)
+
       best = {
         nextImageHash: candidate.nextImageHash,
         checkpoint: candidate.config!.checkpoint,
@@ -321,7 +323,7 @@ export class Provider implements ProviderInterface {
           configuration: {
             threshold: fromConfig.threshold,
             checkpoint: fromConfig.checkpoint,
-            topology: encoded,
+            topology: minimalTopology,
           },
         },
       }

packages/wallet/core/src/state/sequence/index.ts

@@ -249,8 +249,9 @@ export class Provider implements ProviderInterface {
         const { configuration } = await Signature.recover(decoded, wallet, 0, Payload.fromConfigUpdate(toImageHash), {
           provider: passkeySignatureValidator,
         })
+        const topology = Config.minimiseSignedTopology(configuration.topology, configuration.threshold)
 
-        return { imageHash: toImageHash, signature: { ...decoded, configuration } }
+        return { imageHash: toImageHash, signature: { ...decoded, configuration: { ...configuration, topology } } }
       }),
     )
   }

packages/wallet/primitives/src/config.ts

@@ -240,6 +240,89 @@ export function getWeight(
   }
 }
 
+type MinimisedTopologyPlan = {
+  weight: bigint
+  topology: Topology
+}
+
+function stripSignedState(leaf: SignerLeaf | SapientSignerLeaf): SignerLeaf | SapientSignerLeaf {
+  const { signed: _signed, signature: _signature, ...rest } = leaf
+  return rest
+}
+
+function buildMinimisedTopologyPlans(topology: Topology): Array<MinimisedTopologyPlan | undefined> {
+  if (isSignedSignerLeaf(topology) || isSignedSapientSignerLeaf(topology)) {
+    return [
+      { weight: 0n, topology: stripSignedState(topology) },
+      { weight: topology.weight, topology },
+    ]
+  }
+
+  if (
+    isSignerLeaf(topology) ||
+    isSapientSignerLeaf(topology) ||
+    isSubdigestLeaf(topology) ||
+    isAnyAddressSubdigestLeaf(topology) ||
+    isNodeLeaf(topology)
+  ) {
+    return [{ weight: 0n, topology }]
+  }
+
+  if (isNestedLeaf(topology)) {
+    return buildMinimisedTopologyPlans(topology.tree).map((plan) => {
+      if (!plan) {
+        return undefined
+      }
+
+      return {
+        weight: plan.weight >= topology.threshold ? topology.weight : 0n,
+        topology: {
+          ...topology,
+          tree: plan.topology,
+        },
+      }
+    })
+  }
+
+  if (isNode(topology)) {
+    const leftPlans = buildMinimisedTopologyPlans(topology[0])
+    const rightPlans = buildMinimisedTopologyPlans(topology[1])
+    const plans = new Array<MinimisedTopologyPlan | undefined>(leftPlans.length + rightPlans.length - 1)
+
+    for (let total = 0; total < plans.length; total++) {
+      const maxLeft = Math.min(total, leftPlans.length - 1)
+      const minLeft = Math.max(0, total - (rightPlans.length - 1))
+
+      // Iterate from right to left so earlier topology positions win ties.
+      for (let leftCount = maxLeft; leftCount >= minLeft; leftCount--) {
+        const leftPlan = leftPlans[leftCount]
+        const rightPlan = rightPlans[total - leftCount]
+
+        if (!leftPlan || !rightPlan) {
+          continue
+        }
+
+        const weight = leftPlan.weight + rightPlan.weight
+        if (!plans[total] || weight > plans[total]!.weight) {
+          plans[total] = {
+            weight,
+            topology: [leftPlan.topology, rightPlan.topology],
+          }
+        }
+      }
+    }
+
+    return plans
+  }
+
+  throw new Error('Invalid topology')
+}
+
+export function minimiseSignedTopology(topology: Topology, threshold: bigint): Topology {
+  const plans = buildMinimisedTopologyPlans(topology)
+  return plans.find((plan) => plan && plan.weight >= threshold)?.topology ?? topology
+}
+
 export function hashConfiguration(topology: Topology | Config): Bytes.Bytes {
   if (isConfig(topology)) {
     let root = hashConfiguration(topology.topology)

packages/wallet/primitives/test/config.test.ts

@@ -24,6 +24,7 @@ import {
   getSigners,
   findSignerLeaf,
   getWeight,
+  minimiseSignedTopology,
   hashConfiguration,
   flatLeavesToTopology,
   configToJson,
@@ -91,6 +92,37 @@ describe('Config', () => {
     checkpointer: testAddress1,
   }
 
+  function signedAddresses(topology: Topology): string[] {
+    if (isNode(topology)) {
+      return [...signedAddresses(topology[0]), ...signedAddresses(topology[1])]
+    }
+
+    if (isNestedLeaf(topology)) {
+      return signedAddresses(topology.tree)
+    }
+
+    if ((isSignerLeaf(topology) || isSapientSignerLeaf(topology)) && topology.signature) {
+      return [topology.address]
+    }
+
+    return []
+  }
+
+  function signSigner(address: string, weight: bigint, nonce: bigint): SignerLeaf {
+    return {
+      type: 'signer',
+      address,
+      weight,
+      signed: true,
+      signature: {
+        type: 'hash',
+        r: nonce,
+        s: nonce + 1n,
+        yParity: 0,
+      },
+    }
+  }
+
   describe('Type Guards', () => {
     describe('isSignerLeaf', () => {
       it('should return true for valid signer leaf', () => {
@@ -417,6 +449,67 @@ describe('Config', () => {
     })
   })
 
+  describe('minimiseSignedTopology', () => {
+    it('should prefer the smallest signature count that still meets threshold', () => {
+      const topology = flatLeavesToTopology([
+        signSigner('0x1000000000000000000000000000000000000001', 4n, 1n),
+        signSigner('0x1000000000000000000000000000000000000002', 4n, 3n),
+        signSigner('0x1000000000000000000000000000000000000003', 4n, 5n),
+        signSigner('0x1000000000000000000000000000000000000004', 6n, 7n),
+        signSigner('0x1000000000000000000000000000000000000005', 6n, 9n),
+      ])
+
+      const result = minimiseSignedTopology(topology, 12n)
+
+      expect(signedAddresses(result)).toEqual([
+        '0x1000000000000000000000000000000000000004',
+        '0x1000000000000000000000000000000000000005',
+      ])
+      expect(getWeight(result, () => false).weight).toBe(12n)
+    })
+
+    it('should keep earlier signers when equal-count solutions tie', () => {
+      const topology = flatLeavesToTopology([
+        signSigner('0x2000000000000000000000000000000000000001', 1n, 11n),
+        signSigner('0x2000000000000000000000000000000000000002', 1n, 13n),
+        signSigner('0x2000000000000000000000000000000000000003', 1n, 15n),
+      ])
+
+      const result = minimiseSignedTopology(topology, 2n)
+
+      expect(signedAddresses(result)).toEqual([
+        '0x2000000000000000000000000000000000000001',
+        '0x2000000000000000000000000000000000000002',
+      ])
+    })
+
+    it('should minimise nested signers while preserving nested thresholds', () => {
+      const nested: NestedLeaf = {
+        type: 'nested',
+        weight: 4n,
+        threshold: 2n,
+        tree: flatLeavesToTopology([
+          signSigner('0x3000000000000000000000000000000000000001', 1n, 21n),
+          signSigner('0x3000000000000000000000000000000000000002', 1n, 23n),
+          signSigner('0x3000000000000000000000000000000000000003', 1n, 25n),
+        ]),
+      }
+      const topology: Topology = [
+        nested,
+        signSigner('0x3000000000000000000000000000000000000004', 3n, 27n),
+      ]
+
+      const result = minimiseSignedTopology(topology, 5n)
+
+      expect(signedAddresses(result)).toEqual([
+        '0x3000000000000000000000000000000000000001',
+        '0x3000000000000000000000000000000000000002',
+        '0x3000000000000000000000000000000000000004',
+      ])
+      expect(getWeight(result, () => false).weight).toBe(7n)
+    })
+  })
+
   describe('hashConfiguration', () => {
     it('should hash signer leaf correctly', () => {
       const hash = hashConfiguration(sampleSignerLeaf)