feat: record core facet deployments in deployment history

- Add txHash field to OnChainContract interface
- Create recordCoreFacetDeployments function to track core facets
- Match deployed facets against artifacts using bytecode comparison
- Record core facet deployment info with diamond proxy as sender
- Add comprehensive tests for core facet recording and verification

Author: hiddentao

src/commands/deploy.ts

@@ -1,5 +1,5 @@
 import { Signer, ZeroAddress, ethers } from 'ethers'
-import { OnChainContract, Target, clearDeploymentRecorder, clearNonceCache, deployContract, deployContract3, execContractMethod, getContractAt, getDeploymentRecorderData, saveDeploymentInfo, setupTarget, setupWallet } from '../shared/chain.js'
+import { OnChainContract, Target, clearDeploymentRecorder, clearNonceCache, deployContract, deployContract3, execContractMethod, getContractAt, getDeploymentRecorderData, recordCoreFacetDeployments, saveDeploymentInfo, setupTarget, setupWallet } from '../shared/chain.js'
 import { Context, getContext } from '../shared/context.js'
 import { FacetCut, FacetCutAction, getFinalizedFacetCuts, resolveClean, resolveUpgrade } from '../shared/diamond.js'
 import { $, loadJson, saveJson } from '../shared/fs.js'
@@ -282,7 +282,19 @@ export const command = () =>
     }
     const diamond = await deployContract3(ctx, 'DiamondProxy', signer, salt32bytes, await signer.getAddress())
     info(`   ...deployed at: ${diamond.address}`)
-    return await getContractAt(ctx, 'IDiamondProxy', signer, diamond.address)
+
+    const proxyInterface = await getContractAt(ctx, 'IDiamondProxy', signer, diamond.address)
+
+    info('Recording core facet deployments...')
+    await recordCoreFacetDeployments(
+      ctx,
+      signer,
+      diamond.address,
+      ctx.config.diamond.coreFacets,
+      diamond.txHash!
+    )
+
+    return proxyInterface
   }
 
 

src/shared/chain.ts

@@ -209,6 +209,7 @@ export interface OnChainContract {
   artifact: ContractArtifact
   address: string
   contract: Contract
+  txHash?: string
 }
 
 export const getContractAt = async (ctx: Context, name: string, signer: Signer, address: string): Promise<OnChainContract> => {
@@ -485,7 +486,11 @@ export const deployContract3 = async (
       },
     })
 
-    return getContractAt(ctx, name, signer, address)
+    const contract = await getContractAt(ctx, name, signer, address)
+    return {
+      ...contract,
+      txHash: receipt.hash,
+    }
   } catch (err: any) {
     return error(`Failed to deploy ${name}: ${err.message}}`)
   }
@@ -629,6 +634,74 @@ interface ContractArtifactPath {
   fullyQualifiedName: string
 }
 
+/**
+ * Record core facet deployments to the deployment recorder.
+ *
+ * Queries the diamond proxy for deployed facets and matches them against
+ * core facet artifacts, adding deployment records for each matched core facet.
+ */
+export const recordCoreFacetDeployments = async (
+  ctx: Context,
+  signer: Signer,
+  proxyAddress: string,
+  coreFacetNames: string[],
+  diamondDeploymentTxHash: string
+): Promise<void> => {
+  trace(`Recording core facet deployments for diamond at ${proxyAddress} ...`)
+
+  // Get the diamond proxy interface to query facets
+  const proxy = await getContractAt(ctx, 'IDiamondProxy', signer, proxyAddress)
+
+  // Query deployed facets
+  const deployedFacets = await getContractValue<{ facetAddress: string; functionSelectors: string[] }[]>(proxy, 'facets', [])
+  trace(`   Found ${deployedFacets.length} deployed facets`)
+
+  // Load core facet artifacts
+  const coreFacetArtifacts: Record<string, ContractArtifact> = {}
+  coreFacetNames.forEach(name => {
+    coreFacetArtifacts[name] = loadContractArtifact(ctx, name)
+  })
+
+  // Fetch bytecode for deployed facets and match with core facets
+  const bytecodeFetcher = new BytecodeFetcher(signer)
+  const facetAddresses = new Set<string>()
+
+  for (const facet of deployedFacets) {
+    const facetAddress = facet.facetAddress
+    if (!facetAddresses.has(facetAddress)) {
+      facetAddresses.add(facetAddress)
+    }
+  }
+
+  trace(`   ${facetAddresses.size} unique facet addresses found`)
+
+  for (const facetAddress of facetAddresses) {
+    const deployedBytecode = await bytecodeFetcher.getBytecode(facetAddress)
+
+    // Find matching core facet artifact
+    for (const [name, artifact] of Object.entries(coreFacetArtifacts)) {
+      if (artifact.deployedBytecode === deployedBytecode) {
+        trace(`   Matched facet at ${facetAddress} with core facet ${name}`)
+
+        deploymentRecorder.push({
+          name,
+          fullyQualifiedName: artifact.fullyQualifiedName,
+          sender: proxyAddress,
+          txHash: diamondDeploymentTxHash,
+          onChain: {
+            address: facetAddress,
+            constructorArgs: [],
+          },
+        })
+
+        break
+      }
+    }
+  }
+
+  trace(`   ...done recording core facet deployments`)
+}
+
 const getAllContractArtifactPaths = (ctx: Context): ContractArtifactPath[] => {
   const files = glob.sync(`${ctx.artifactsPath}/**/*.json`) as string[]
 
@@ -651,7 +724,7 @@ const getAllContractArtifactPaths = (ctx: Context): ContractArtifactPath[] => {
       default:
         error(`Unknown artifacts format: ${ctx.config.artifacts.format}`)
     }
-    
+
     return {
       jsonFilePath,
       fullyQualifiedName,

test/common-deploy-steps.ts

@@ -45,6 +45,23 @@ export const addDeployTestSteps = ({
       expect(obj2).to.have.property('txHash')
       expect(obj2).to.have.property('onChain')
       expect(obj2.onChain).to.have.property('address')
+
+      const coreFacets = ['DiamondCutFacet', 'DiamondLoupeFacet', 'OwnershipFacet']
+      coreFacets.forEach(facetName => {
+        const facet = get(json, 'local.contracts', []).find((a: any) => a.name === facetName) as any
+        expect(facet).to.exist
+        expect(facet).to.have.property('name')
+        expect(facet.name).to.equal(facetName)
+        expect(facet).to.have.property('fullyQualifiedName')
+        expect(facet).to.have.property('sender')
+        expect(facet.sender).to.equal(obj.onChain.address)
+        expect(facet).to.have.property('txHash')
+        expect(facet.txHash).to.equal(obj.txHash)
+        expect(facet).to.have.property('onChain')
+        expect(facet.onChain).to.have.property('address')
+        expect(facet.onChain).to.have.property('constructorArgs')
+        expect(facet.onChain.constructorArgs).to.be.an('array').that.is.empty
+      })
     })
 
     it('and the facets really are deployed', async () => {
@@ -59,6 +76,24 @@ export const addDeployTestSteps = ({
       expect(contract.owner()).to.eventually.eq(walletAddress)
     })
 
+    it('and records core facets with addresses matching the diamond query', async () => {
+      const filePath = join(cwd, 'gemforge.deployments.json')
+      const json = loadJsonFile(filePath)
+
+      const { contract } = await loadDiamondContract(cwd)
+      const deployedFacets = await contract.facets()
+
+      const coreFacets = ['DiamondCutFacet', 'DiamondLoupeFacet', 'OwnershipFacet']
+      coreFacets.forEach(facetName => {
+        const facetRecord = get(json, 'local.contracts', []).find((a: any) => a.name === facetName) as any
+        expect(facetRecord).to.exist
+
+        const deployedFacet = deployedFacets.find((f: any) => f.facetAddress.toLowerCase() === facetRecord.onChain.address.toLowerCase())
+        expect(deployedFacet).to.exist
+        expect(deployedFacet.functionSelectors.length).to.be.greaterThan(0)
+      })
+    })
+
     it('and can handle additions and replacements in a facet', async () => {
       const filePath = join(cwd, 'gemforge.deployments.json')
       const jsonOld = loadJsonFile(filePath)
@@ -226,6 +261,15 @@ export const addDeployTestSteps = ({
         expect(newAddr.toLowerCase()).to.not.equal(oldAddr.toLowerCase())
       })
 
+      const coreFacets = ['DiamondCutFacet', 'DiamondLoupeFacet', 'OwnershipFacet']
+      coreFacets.forEach((name) => {
+        const oldFacet = get(jsonOld, 'local.contracts', []).find((a: any) => a.name === name) as any
+        const newFacet = get(jsonNew, 'local.contracts', []).find((a: any) => a.name === name) as any
+        expect(oldFacet).to.exist
+        expect(newFacet).to.exist
+        expect(newFacet.onChain.address.toLowerCase()).to.not.equal(oldFacet.onChain.address.toLowerCase())
+      })
+
       const { contract } = await loadDiamondContract(cwd)
       const n = await contract.getInt1()
       expect(n.toString()).to.equal('0')
@@ -255,6 +299,15 @@ export const addDeployTestSteps = ({
         expect(newAddr.toLowerCase()).to.equal(oldAddr.toLowerCase())
       })
 
+      const coreFacets = ['DiamondCutFacet', 'DiamondLoupeFacet', 'OwnershipFacet']
+      coreFacets.forEach((name) => {
+        const oldFacet = get(jsonOld, 'local.contracts', []).find((a: any) => a.name === name) as any
+        const newFacet = get(jsonNew, 'local.contracts', []).find((a: any) => a.name === name) as any
+        expect(oldFacet).to.exist
+        expect(newFacet).to.exist
+        expect(newFacet.onChain.address.toLowerCase()).to.equal(oldFacet.onChain.address.toLowerCase())
+      })
+
       const n = await contract.getInt1()
       expect(n.toString()).to.equal('2') // still the same as before!
     })