Add Zama tab [WIP]

.gitignore

@@ -5,3 +5,5 @@ node_modules
 .env
 .env.local
 .vscode/settings.json
+
+fhevmTemp

packages/common/src/ai/descriptions/zama.ts

@@ -0,0 +1,15 @@
+// IMPORTANT: This file must not have any imports since it is used in both Node and Deno environments,
+// which have different requirements for file extensions in import statements.
+
+export const zamaPrompts = {
+  ConfidentialFungible: 'Make a confidential fungible token per the ERC-7984 standard, similar to ERC-20 but with confidentiality.',
+};
+
+export const zamaConfidentialFungibleDescriptions = {
+  tokenURI: 'The URI of the token.',
+  premint: 'The number of tokens to premint for the deployer.',
+  networkConfig: 'Specify the network on which to use FHEVM contracts provided by Zama.',
+  wrappable: 'Whether to allow wrapping an ERC20 token into a confidential fungible token.',
+  votes:
+    'Whether to keep track of historical balances for voting in on-chain governance. Voting durations can be expressed as block numbers or timestamps.',
+};

packages/common/src/index.ts

@@ -3,3 +3,4 @@ export * from './ai/descriptions/cairo';
 export * from './ai/descriptions/solidity';
 export * from './ai/descriptions/stellar';
 export * from './ai/descriptions/stylus';
+export * from './ai/descriptions/zama';

packages/core/solidity/src/contract.ts

@@ -5,6 +5,7 @@ export interface Contract {
   license: string;
   parents: Parent[];
   natspecTags: NatspecTag[];
+  libraries: Library[];
   imports: ImportContract[];
   functions: ContractFunction[];
   constructorCode: string[];
@@ -33,9 +34,9 @@ export interface ReferencedContract {
   transpiled?: boolean;
 }
 
-export interface Using {
+export interface Library {
   library: ImportContract;
-  usingFor: string;
+  usingFor: Set<string>;
 }
 
 export interface BaseFunction {
@@ -55,7 +56,7 @@ export interface ContractFunction extends BaseFunction {
   comments: string[];
 }
 
-export type FunctionKind = 'internal' | 'public';
+export type FunctionKind = 'private' | 'internal' | 'public' | 'external';
 export type FunctionMutability = (typeof mutabilityRank)[number];
 
 // Order is important
@@ -83,7 +84,6 @@ export class ContractBuilder implements Contract {
   shouldInstallContractsUpgradeable: boolean = false;
   shouldUseUpgradesPluginsForProxyDeployment: boolean = false;
 
-  readonly using: Using[] = [];
   readonly natspecTags: NatspecTag[] = [];
 
   readonly constructorArgs: FunctionArgument[] = [];
@@ -92,7 +92,8 @@ export class ContractBuilder implements Contract {
   readonly variableSet: Set<string> = new Set();
 
   private parentMap: Map<string, Parent> = new Map<string, Parent>();
-  private functionMap: Map<string, ContractFunction> = new Map();
+  private functionMap: Map<string, ContractFunction> = new Map<string, ContractFunction>();
+  private libraryMap: Map<string, Library> = new Map<string, Library>();
 
   constructor(name: string) {
     this.name = toIdentifier(name, true);
@@ -113,7 +114,13 @@ export class ContractBuilder implements Contract {
   }
 
   get imports(): ImportContract[] {
-    return [...[...this.parentMap.values()].map(p => p.contract), ...this.using.map(u => u.library)];
+    const parents = [...this.parentMap.values()].map(p => p.contract);
+    const libraries = [...this.libraryMap.values()].map(l => l.library);
+    return [...parents, ...libraries];
+  }
+
+  get libraries(): Library[] {
+    return [...this.libraryMap.values()];
   }
 
   get functions(): ContractFunction[] {
@@ -140,6 +147,21 @@ export class ContractBuilder implements Contract {
     return !present;
   }
 
+  addLibrary(library: ImportContract, usingFor: string[]): boolean {
+    let modified = false;
+    if (this.libraryMap.has(library.name)) {
+      const existing = this.libraryMap.get(library.name)!;
+      const initialSize = existing.usingFor.size;
+      usingFor.forEach(type => existing.usingFor.add(type));
+      modified = existing.usingFor.size > initialSize;
+    } else {
+      this.libraryMap.set(library.name, { library, usingFor: new Set(usingFor) });
+      modified = true;
+    }
+
+    return modified;
+  }
+
   addOverride(parent: ReferencedContract, baseFn: BaseFunction, mutability?: FunctionMutability) {
     const fn = this.addFunction(baseFn);
     fn.override.add(parent);

packages/core/solidity/src/options.ts

@@ -27,6 +27,10 @@ const upgradeableImport = (p: ImportContract): ImportContract => {
 
 export interface Options {
   transformImport?: (parent: ImportContract) => ImportContract;
+  /**
+   * Add additional libraries to the compatibility banner printed at the top of the contract.
+   */
+  additionalCompatibleLibraries?: { name: string; path: string; version: string }[];
 }
 
 export interface Helpers extends Required<Options> {
@@ -45,5 +49,6 @@ export function withHelpers(contract: Contract, opts: Options = {}): Helpers {
       const p2 = shouldAutoTranspileImports && inferTranspiled(p1) ? upgradeableImport(p1) : p1;
       return opts.transformImport?.(p2) ?? p2;
     },
+    additionalCompatibleLibraries: opts.additionalCompatibleLibraries ?? [],
   };
 }

packages/core/solidity/src/print.ts

@@ -17,7 +17,7 @@ import SOLIDITY_VERSION from './solidity-version.json';
 import { inferTranspiled } from './infer-transpiled';
 import { compatibleContractsSemver } from './utils/version';
 import { stringifyUnicodeSafe } from './utils/sanitize';
-import { importsCommunityContracts } from './utils/imports-libraries';
+import { importsLibrary } from './utils/imports-libraries';
 import { getCommunityContractsGitCommit } from './utils/community-contracts-git-commit';
 
 export function printContract(contract: Contract, opts?: Options): string {
@@ -31,7 +31,7 @@ export function printContract(contract: Contract, opts?: Options): string {
     ...spaceBetween(
       [
         `// SPDX-License-Identifier: ${contract.license}`,
-        printCompatibleLibraryVersions(contract),
+        printCompatibleLibraryVersions(contract, opts),
         `pragma solidity ^${SOLIDITY_VERSION};`,
       ],
 
@@ -42,6 +42,7 @@ export function printContract(contract: Contract, opts?: Options): string {
         [`contract ${contract.name}`, ...printInheritance(contract, helpers), '{'].join(' '),
 
         spaceBetween(
+          printLibraries(contract, helpers),
           contract.variables,
           printConstructor(contract, helpers),
           ...fns.code,
@@ -56,17 +57,30 @@ export function printContract(contract: Contract, opts?: Options): string {
   );
 }
 
-function printCompatibleLibraryVersions(contract: Contract): string {
-  let result = `// Compatible with OpenZeppelin Contracts ${compatibleContractsSemver}`;
-  if (importsCommunityContracts(contract)) {
+function printCompatibleLibraryVersions(contract: Contract, opts?: Options): string {
+  const libraries: string[] = [];
+  if (importsLibrary(contract, '@openzeppelin/contracts')) {
+    libraries.push(`OpenZeppelin Contracts ${compatibleContractsSemver}`);
+  }
+  if (importsLibrary(contract, '@openzeppelin/community-contracts')) {
     try {
       const commit = getCommunityContractsGitCommit();
-      result += ` and Community Contracts commit ${commit}`;
+      libraries.push(`Community Contracts commit ${commit}`);
     } catch (e) {
       console.error(e);
     }
   }
-  return result;
+  if (opts?.additionalCompatibleLibraries) {
+    for (const library of opts.additionalCompatibleLibraries) {
+      if (importsLibrary(contract, library.path)) {
+        libraries.push(`${library.name} ${library.version}`);
+      }
+    }
+  }
+
+  if (libraries.length === 0) return '';
+  if (libraries.length === 1) return `// Compatible with ${libraries[0]}`;
+  return `// Compatible with ${libraries.slice(0, -1).join(', ')} and ${libraries.slice(-1)}`;
 }
 
 function printInheritance(contract: Contract, { transformName }: Helpers): [] | [string] {
@@ -275,3 +289,14 @@ function printImports(imports: ImportContract[], helpers: Helpers): string[] {
 
   return lines;
 }
+
+function printLibraries(contract: Contract, { transformName }: Helpers): string[] {
+  if (!contract.libraries || contract.libraries.length === 0) return [];
+
+  return contract.libraries
+    .sort((a, b) => a.library.name.localeCompare(b.library.name)) // Sort by library name
+    .map(lib => {
+      const sortedTypes = Array.from(lib.usingFor).sort((a, b) => a.localeCompare(b)); // Sort types
+      return `using ${transformName(lib.library)} for ${sortedTypes.join(', ')};`;
+    });
+}

packages/core/solidity/src/utils/imports-libraries.ts

@@ -1,5 +1,5 @@
 import type { Contract } from '../contract';
 
-export function importsCommunityContracts(contract: Contract) {
-  return contract.imports.some(i => i.path.startsWith('@openzeppelin/community-contracts/'));
+export function importsLibrary(contract: Contract, library: string) {
+  return contract.imports.some(i => i.path.startsWith(library));
 }

packages/core/zama/.gitignore

@@ -0,0 +1,4 @@
+/cache
+/artifacts
+/contracts/generated
+/openzeppelin-contracts.json

packages/core/zama/CHANGELOG.md

@@ -0,0 +1,2 @@
+# Changelog
+