Release v2.26.0 (#1861)

Co-authored-by: dbeal <git@dbeal.dev>
Co-authored-by: shubham shinde <shubhamshinde5080@gmail.com>
Co-authored-by: 0xusecannon <noreply@usecannon.com>
Co-authored-by: AkihisaY <76488710+AkihisaY@users.noreply.github.com>

Author: 5 people

.eslintignore

@@ -1,4 +1,5 @@
 .next
+artifacts
 coverage
 dist
 next.lock
@@ -9,3 +10,4 @@ packages/hardhat-cannon/dist
 packages/website/out
 typechain-types
 typechain
+artifacts

.github/workflows/claude-code-review.yml

@@ -1,6 +1,8 @@
 {
   "npmClient": "pnpm",
-  "packages": ["packages/*"],
+  "packages": [
+    "packages/*"
+  ],
   "exact": true,
-  "version": "2.25.1"
+  "version": "2.26.0"
 }

.github/workflows/claude.yml

@@ -1,6 +1,6 @@
 {
   "name": "@usecannon/builder",
-  "version": "2.25.1",
+  "version": "2.26.0",
   "description": "Assembles cannonfile.toml manifests into cannon packages.",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -38,6 +38,7 @@
     "@types/jest": "^29.5.14",
     "@types/lodash": "^4.17.16",
     "@types/pako": "^2.0.3",
+    "@types/promise-retry": "^1.1.6",
     "jest": "^29.7.0",
     "rollup": "^4.39.0",
     "ts-jest": "^29.3.1",
@@ -60,6 +61,7 @@
     "lodash": "^4.17.21",
     "pako": "^2.1.0",
     "promise-events": "^0.2.4",
+    "promise-retry": "^2.0.1",
     "rfdc": "^1.4.1",
     "ses": "^1.12.0",
     "typestub-ipfs-only-hash": "^4.0.0",

lerna.json

@@ -1,82 +1,83 @@
-import { computeTemplateAccesses } from './access-recorder';
+import { AccessRecorderEngine } from './access-recorder';
 
 describe('access-recorder.ts', () => {
+  const engine = new AccessRecorderEngine([]);
   describe('computeTemplateAccesses()', () => {
     it('computes dependency with addition operation', () => {
-      expect(computeTemplateAccesses('<%= settings.value1 + settings.value2 %>')).toEqual({
+      expect(engine.computeTemplateAccesses('<%= settings.value1 + settings.value2 %>')).toEqual({
         accesses: ['settings.value1', 'settings.value2'],
         unableToCompute: false,
       });
     });
 
     it('computes dependency with addition operation using extras', () => {
-      expect(computeTemplateAccesses('<%= extras.value1 + extras.value2 %>')).toEqual({
+      expect(engine.computeTemplateAccesses('<%= extras.value1 + extras.value2 %>')).toEqual({
         accesses: ['extras.value1', 'extras.value2'],
         unableToCompute: false,
       });
     });
 
     it('computes dependency with usage of allowed global variables', () => {
-      expect(computeTemplateAccesses('<%= parseEther(String(0.3)) %>')).toEqual({
+      expect(engine.computeTemplateAccesses('<%= parseEther(String(0.3)) %>')).toEqual({
         accesses: [],
         unableToCompute: false,
       });
     });
 
     it('computes simple addition', () => {
-      expect(computeTemplateAccesses('<%= 1 + 1 %>')).toEqual({
+      expect(engine.computeTemplateAccesses('<%= 1 + 1 %>')).toEqual({
         accesses: [],
         unableToCompute: false,
       });
     });
 
     it('computes dependency with subtraction operation', () => {
-      expect(computeTemplateAccesses('<%= settings.value1 - settings.value2 %>')).toEqual({
+      expect(engine.computeTemplateAccesses('<%= settings.value1 - settings.value2 %>')).toEqual({
         accesses: ['settings.value1', 'settings.value2'],
         unableToCompute: false,
       });
     });
 
     it('computes dependency with multiplication operation', () => {
-      expect(computeTemplateAccesses('<%= settings.value1 * settings.value2 %>')).toEqual({
+      expect(engine.computeTemplateAccesses('<%= settings.value1 * settings.value2 %>')).toEqual({
         accesses: ['settings.value1', 'settings.value2'],
         unableToCompute: false,
       });
     });
 
     it('computes dependency with division operation', () => {
-      expect(computeTemplateAccesses('<%= settings.value1 / settings.value2 %>')).toEqual({
+      expect(engine.computeTemplateAccesses('<%= settings.value1 / settings.value2 %>')).toEqual({
         accesses: ['settings.value1', 'settings.value2'],
         unableToCompute: false,
       });
     });
 
     it('computes dependency with complex math operation', () => {
       expect(
-        computeTemplateAccesses('<%= (settings.value1 + settings.value2) * settings.value3 / settings.value4 %>')
+        engine.computeTemplateAccesses('<%= (settings.value1 + settings.value2) * settings.value3 / settings.value4 %>')
       ).toEqual({
         accesses: ['settings.value1', 'settings.value2', 'settings.value3', 'settings.value4'],
         unableToCompute: false,
       });
     });
 
     it('computes multiple dependencies on different template tags', () => {
-      expect(computeTemplateAccesses('<%= settings.woot %>-<%= settings.woot2 %>')).toEqual({
+      expect(engine.computeTemplateAccesses('<%= settings.woot %>-<%= settings.woot2 %>')).toEqual({
         accesses: ['settings.woot', 'settings.woot2'],
         unableToCompute: false,
       });
     });
 
     it('computes simple dependency', () => {
-      expect(computeTemplateAccesses('<%= settings.woot %>')).toEqual({
+      expect(engine.computeTemplateAccesses('<%= settings.woot %>')).toEqual({
         accesses: ['settings.woot'],
         unableToCompute: false,
       });
     });
 
     it('computes array dependency', () => {
       expect(
-        computeTemplateAccesses(
+        engine.computeTemplateAccesses(
           '["<%= settings.camelotSwapPublisherAdmin1 %>","<%= settings.camelotSwapPublisherAdmin2 %>"]'
         )
       ).toEqual({
@@ -86,15 +87,15 @@ describe('access-recorder.ts', () => {
     });
 
     it('computes dependency using simple CannonHelperContext', () => {
-      expect(computeTemplateAccesses('<%= parseEther(settings.woot) %>')).toEqual({
+      expect(engine.computeTemplateAccesses('<%= parseEther(settings.woot) %>')).toEqual({
         accesses: ['settings.woot'],
         unableToCompute: false,
       });
     });
 
     it('computes dependency using complex CannonHelperContext', () => {
       expect(
-        computeTemplateAccesses(
+        engine.computeTemplateAccesses(
           '<%= defaultAbiCoder.encode(parseEther(settings.woot)) %> + <%= defaultAbiCoder.decode(contracts.compound) %>'
         )
       ).toEqual({
@@ -106,28 +107,28 @@ describe('access-recorder.ts', () => {
 
   describe('computeTemplateAccesses() syntax validation', () => {
     it('handles invalid template syntax - unmatched brackets', () => {
-      expect(computeTemplateAccesses('<%= settings.value) %>')).toEqual({
+      expect(engine.computeTemplateAccesses('<%= settings.value) %>')).toEqual({
         accesses: [],
         unableToCompute: true,
       });
     });
 
     it('handles empty template tags', () => {
-      expect(computeTemplateAccesses('<%=%>')).toEqual({
+      expect(engine.computeTemplateAccesses('<%=%>')).toEqual({
         accesses: [],
         unableToCompute: true,
       });
     });
 
     it('handles multiple template tags with mixed validity', () => {
-      expect(computeTemplateAccesses('<%= settings.valid %> and <% invalid.syntax')).toEqual({
+      expect(engine.computeTemplateAccesses('<%= settings.valid %> and <% invalid.syntax')).toEqual({
         accesses: ['settings.valid'],
         unableToCompute: false,
       });
     });
 
     it('handles template with only whitespace', () => {
-      expect(computeTemplateAccesses('<%=   %>')).toEqual({
+      expect(engine.computeTemplateAccesses('<%=   %>')).toEqual({
         accesses: [],
         unableToCompute: true,
       });
@@ -136,58 +137,58 @@ describe('access-recorder.ts', () => {
 
   describe('computeTemplateAccesses() security', () => {
     it('prevents direct code execution', () => {
-      expect(computeTemplateAccesses('<%= process.exit(1) %>')).toEqual({
+      expect(engine.computeTemplateAccesses('<%= process.exit(1) %>')).toEqual({
         accesses: [],
         unableToCompute: true,
       });
     });
 
     it('prevents access to global objects', () => {
-      expect(computeTemplateAccesses('<%= global.process %>')).toEqual({
+      expect(engine.computeTemplateAccesses('<%= global.process %>')).toEqual({
         accesses: [],
         unableToCompute: true,
       });
     });
 
     it('prevents require/import statements', () => {
-      expect(computeTemplateAccesses('<%= require("fs") %>')).toEqual({
+      expect(engine.computeTemplateAccesses('<%= require("fs") %>')).toEqual({
         accesses: [],
         unableToCompute: true,
       });
     });
 
     it('prevents eval usage', () => {
-      expect(computeTemplateAccesses('<%= eval("console.log(\'REKT\')") %>')).toEqual({
+      expect(engine.computeTemplateAccesses('<%= eval("console.log(\'REKT\')") %>')).toEqual({
         accesses: [],
         unableToCompute: true,
       });
     });
 
     it('prevents Function constructor usage', () => {
-      expect(computeTemplateAccesses('<%= new Function("return process")() %>')).toEqual({
+      expect(engine.computeTemplateAccesses('<%= new Function("return process")() %>')).toEqual({
         accesses: [],
         unableToCompute: true,
       });
     });
 
     it('prevents setTimeout/setInterval usage', () => {
-      expect(computeTemplateAccesses('<%= setTimeout(() => {}, 1000) %>')).toEqual({
+      expect(engine.computeTemplateAccesses('<%= setTimeout(() => {}, 1000) %>')).toEqual({
         accesses: [],
         unableToCompute: true,
       });
     });
 
     it('prevents overriding console.log', () => {
       expect(
-        computeTemplateAccesses('<%= console.log=function(n){require("fs").writeFileSync("./exploit.log",n)} %>')
+        engine.computeTemplateAccesses('<%= console.log=function(n){require("fs").writeFileSync("./exploit.log",n)} %>')
       ).toEqual({
         accesses: [],
         unableToCompute: true,
       });
     });
 
     it('prevents assignment of values', () => {
-      expect(computeTemplateAccesses('<%= const value = 1 + 2 %>')).toEqual({
+      expect(engine.computeTemplateAccesses('<%= const value = 1 + 2 %>')).toEqual({
         accesses: [],
         unableToCompute: true,
       });