rename, implement

Author: ericglau

packages/core/zama/package.json

@@ -25,6 +25,8 @@
     "@openzeppelin/community-contracts": "git+https://github.com/OpenZeppelin/openzeppelin-community-contracts.git#de17c8e",
     "@openzeppelin/contracts": "^5.4.0",
     "@openzeppelin/contracts-upgradeable": "^5.4.0",
+    "@openzeppelin/confidential-contracts": "^0.2.0",
+    "@fhevm/solidity": "^0.7.0",
     "@types/node": "^20.0.0",
     "@types/semver": "^7.5.7",
     "ava": "^6.0.0",

packages/core/zama/src/api.ts

@@ -1,9 +1,9 @@
 import type { CommonOptions } from './common-options';
-import type { ERC20Options } from './erc20';
+import type { ConfidentialFungibleOptions } from './confidentialFungible';
 import {
-  printERC20,
-  defaults as erc20defaults,
-} from './erc20';
+  printConfidentialFungible,
+  defaults as confidentialFungibleDefaults,
+} from './confidentialFungible';
 
 export interface WizardContractAPI<Options extends CommonOptions> {
   /**
@@ -17,9 +17,9 @@ export interface WizardContractAPI<Options extends CommonOptions> {
   defaults: Required<Options>;
 }
 
-export type ERC20 = WizardContractAPI<ERC20Options>;
+export type ConfidentialFungible = WizardContractAPI<ConfidentialFungibleOptions>;
 
-export const erc20: ERC20 = {
-  print: printERC20,
-  defaults: erc20defaults,
+export const confidentialFungible: ConfidentialFungible = {
+  print: printConfidentialFungible,
+  defaults: confidentialFungibleDefaults,
 };

packages/core/zama/src/build-generic.ts

@@ -1,17 +1,17 @@
-import type { ERC20Options } from './erc20';
-import { buildERC20 } from './erc20';
+import type { ConfidentialFungibleOptions } from './confidentialFungible';
+import { buildConfidentialFungible } from './confidentialFungible';
 import type { Contract } from './contract';
 
 export interface KindedOptions {
-  ERC20: { kind: 'ERC20' } & ERC20Options;
+  ConfidentialFungible: { kind: 'ConfidentialFungible' } & ConfidentialFungibleOptions;
 }
 
 export type GenericOptions = KindedOptions[keyof KindedOptions];
 
 export function buildGeneric(opts: GenericOptions): Contract {
   switch (opts.kind) {
-    case 'ERC20':
-      return buildERC20(opts);
+    case 'ConfidentialFungible':
+      return buildConfidentialFungible(opts);
 
     default: {
       // TODO: When other contract kinds are available, change the below to:

packages/core/zama/src/erc20.test.ts renamed to packages/core/zama/src/confidentialFungible.test.ts

@@ -1,16 +1,17 @@
 import test from 'ava';
 import type { OptionsError } from '.';
-import { erc20 } from '.';
+import { confidentialFungible } from '.';
 
-import type { ERC20Options } from './erc20';
-import { buildERC20 } from './erc20';
+import type { ConfidentialFungibleOptions } from './confidentialFungible';
+import { buildConfidentialFungible } from './confidentialFungible';
 import { printContract } from './print';
 
-function testERC20(title: string, opts: Partial<ERC20Options>) {
+function testConfidentialFungible(title: string, opts: Partial<ConfidentialFungibleOptions>) {
   test(title, t => {
-    const c = buildERC20({
+    const c = buildConfidentialFungible({
       name: 'MyToken',
       symbol: 'MTK',
+      tokenURI: '',
       ...opts,
     });
     t.snapshot(printContract(c));
@@ -20,48 +21,51 @@ function testERC20(title: string, opts: Partial<ERC20Options>) {
 /**
  * Tests external API for equivalence with internal API
  */
-function testAPIEquivalence(title: string, opts?: ERC20Options) {
+function testAPIEquivalence(title: string, opts?: ConfidentialFungibleOptions) {
   test(title, t => {
     t.is(
-      erc20.print(opts),
+      confidentialFungible.print(opts),
       printContract(
-        buildERC20({
+        buildConfidentialFungible({
           name: 'MyToken',
           symbol: 'MTK',
+          tokenURI: '',
           ...opts,
         }),
       ),
     );
   });
 }
 
-testERC20('basic erc20', {});
+testConfidentialFungible('basic confidentialFungible', {});
 
-testERC20('erc20 name is unicodeSafe', { name: 'MyTokeć' });
+testConfidentialFungible('confidentialFungible name is unicodeSafe', { name: 'MyTokeć' });
 
-testERC20('erc20 preminted', {
+testConfidentialFungible('confidentialFungible preminted', {
   premint: '1000',
 });
 
-testERC20('erc20 premint of 0', {
+testConfidentialFungible('confidentialFungible premint of 0', {
   premint: '0',
 });
 
 function testPremint(scenario: string, premint: string, expectedError?: string) {
-  test(`erc20 premint - ${scenario} - ${expectedError ? 'invalid' : 'valid'}`, async t => {
+  test(`confidentialFungible premint - ${scenario} - ${expectedError ? 'invalid' : 'valid'}`, async t => {
     if (expectedError) {
       const error = t.throws(() =>
-        buildERC20({
+        buildConfidentialFungible({
           name: 'MyToken',
           symbol: 'MTK',
+          tokenURI: '',
           premint,
         }),
       );
       t.is((error as OptionsError).messages.premint, expectedError);
     } else {
-      const c = buildERC20({
+      const c = buildConfidentialFungible({
         name: 'MyToken',
         symbol: 'MTK',
+        tokenURI: '',
         premint,
       });
       t.snapshot(printContract(c));
@@ -84,32 +88,32 @@ testPremint(
 testPremint('e notation', '1e59');
 testPremint('e notation arithmetic overflow', '1e60', 'Amount would overflow uint256 after applying decimals');
 
-testERC20('erc20 mintable', {
+testConfidentialFungible('confidentialFungible mintable', {
   mintable: true,
   access: 'ownable',
 });
 
-testERC20('erc20 mintable with roles', {
+testConfidentialFungible('confidentialFungible mintable with roles', {
   mintable: true,
   access: 'roles',
 });
 
-testERC20('erc20 votes', {
+testConfidentialFungible('confidentialFungible votes', {
   votes: true,
 });
 
-testERC20('erc20 votes + blocknumber', {
+testConfidentialFungible('confidentialFungible votes + blocknumber', {
   votes: 'blocknumber',
 });
 
-testERC20('erc20 votes + timestamp', {
+testConfidentialFungible('confidentialFungible votes + timestamp', {
   votes: 'timestamp',
 });
 
 
 // TODO test full
 /**
-testERC20('erc20 full', {
+testConfidentialFungible('confidentialFungible full', {
   premint: '2000',
   access: 'roles',
   burnable: true,
@@ -124,19 +128,20 @@ testERC20('erc20 full', {
 */
 
 
-testAPIEquivalence('erc20 API default');
+testAPIEquivalence('confidentialFungible API default');
 
-testAPIEquivalence('erc20 API basic', { name: 'CustomToken', symbol: 'CTK' });
+testAPIEquivalence('confidentialFungible API basic', { name: 'CustomToken', symbol: 'CTK', tokenURI: '' });
 
-testAPIEquivalence('erc20 API full upgradeable', {
+testAPIEquivalence('confidentialFungible API full upgradeable', {
   name: 'CustomToken',
   symbol: 'CTK',
+  tokenURI: 'http://example.com',
   premint: '2000',
   access: 'roles',
   mintable: true,
   votes: true,
 });
 
-test('erc20 API assert defaults', async t => {
-  t.is(erc20.print(erc20.defaults), erc20.print());
+test('confidentialFungible API assert defaults', async t => {
+  t.is(confidentialFungible.print(confidentialFungible.defaults), confidentialFungible.print());
 });

packages/core/zama/src/erc20.ts renamed to packages/core/zama/src/confidentialFungible.ts

@@ -12,9 +12,10 @@ import { toUint256, UINT256_MAX } from './utils/convert-strings';
 export const crossChainBridgingOptions = [false, 'custom', 'superchain'] as const;
 export type CrossChainBridging = (typeof crossChainBridgingOptions)[number];
 
-export interface ERC20Options extends CommonOptions {
+export interface ConfidentialFungibleOptions extends CommonOptions {
   name: string;
   symbol: string;
+  tokenURI: string;
   premint?: string;
   mintable?: boolean;
   /**
@@ -24,9 +25,10 @@ export interface ERC20Options extends CommonOptions {
   votes?: boolean | ClockMode;
 }
 
-export const defaults: Required<ERC20Options> = {
+export const defaults: Required<ConfidentialFungibleOptions> = {
   name: 'MyToken',
   symbol: 'MTK',
+  tokenURI: '',
   premint: '0',
   mintable: false,
   votes: false,
@@ -35,7 +37,7 @@ export const defaults: Required<ERC20Options> = {
   info: commonDefaults.info,
 } as const;
 
-export function withDefaults(opts: ERC20Options): Required<ERC20Options> {
+export function withDefaults(opts: ConfidentialFungibleOptions): Required<ConfidentialFungibleOptions> {
   return {
     ...opts,
     ...withCommonDefaults(opts),
@@ -45,18 +47,18 @@ export function withDefaults(opts: ERC20Options): Required<ERC20Options> {
   };
 }
 
-export function printERC20(opts: ERC20Options = defaults): string {
-  return printContract(buildERC20(opts));
+export function printConfidentialFungible(opts: ConfidentialFungibleOptions = defaults): string {
+  return printContract(buildConfidentialFungible(opts));
 }
 
-export function buildERC20(opts: ERC20Options): ContractBuilder {
+export function buildConfidentialFungible(opts: ConfidentialFungibleOptions): ContractBuilder {
   const allOpts = withDefaults(opts);
 
   const c = new ContractBuilder(allOpts.name);
 
   const { info } = allOpts;
 
-  addBase(c, allOpts.name, allOpts.symbol);
+  addBase(c, allOpts.name, allOpts.symbol, allOpts.tokenURI);
 
   if (allOpts.premint) {
     addPremint(c, allOpts.premint);
@@ -66,24 +68,33 @@ export function buildERC20(opts: ERC20Options): ContractBuilder {
   //   addMintable(c);
   // }
 
-  if (allOpts.votes) {
-    const clockMode = allOpts.votes === true ? clockModeDefault : allOpts.votes;
-    addVotes(c, clockMode);
-  }
+  // if (allOpts.votes) {
+  //   const clockMode = allOpts.votes === true ? clockModeDefault : allOpts.votes;
+  //   addVotes(c, clockMode);
+  // }
 
   setInfo(c, info);
 
   return c;
 }
 
-function addBase(c: ContractBuilder, name: string, symbol: string) {
-  const ERC20 = {
-    name: 'ERC20',
-    path: '@openzeppelin/contracts/token/ERC20/ERC20.sol',
+function addBase(c: ContractBuilder, name: string, symbol: string, tokenURI: string) {
+  const ConfidentialFungibleToken = {
+    name: 'ConfidentialFungibleToken',
+    path: '@openzeppelin/confidential-contracts/token/ConfidentialFungibleToken.sol',
   };
-  c.addParent(ERC20, [name, symbol]);
-
-  c.addOverride(ERC20, functions._update);
+  c.addParent(ConfidentialFungibleToken, [name, symbol, tokenURI]);
+
+  c.addImportOnly({
+    name: 'euint64',
+    path: '@fhevm/solidity/lib/FHE.sol',
+  });
+  c.addImportOnly({
+    name: 'FHE',
+    path: '@fhevm/solidity/lib/FHE.sol',
+  });
+  c.addOverride(ConfidentialFungibleToken, functions._update);
+  c.addOverride(ConfidentialFungibleToken, functions.confidentialTotalSupply);
 }
 
 export const premintPattern = /^(\d*)(?:\.(\d+))?(?:e(\d+))?$/;
@@ -117,7 +128,9 @@ function addPremint(
 
       c.addConstructorArgument({ type: 'address', name: 'recipient' });
 
-      const mintLine = `_mint(recipient, ${units} * 10 ** ${exp});`;
+      // TODO need to include decimals in the euint64. How?
+      // const mintLine = `_mint(recipient, ${units} * 10 ** ${exp});`;
+      const mintLine = `_mint(recipient, FHE.asEuint64(${units}));`;
 
       c.addConstructorCode(mintLine);
     }
@@ -157,6 +170,7 @@ function addVotes(c: ContractBuilder, clockMode: ClockMode) {
   };
   c.addParent(ConfidentialFungibleTokenVotes);
   c.addOverride(ConfidentialFungibleTokenVotes, functions._update);
+  c.addOverride(ConfidentialFungibleTokenVotes, functions.confidentialTotalSupply);
 
   setClockMode(c, ConfidentialFungibleTokenVotes, clockMode);
 }
@@ -170,5 +184,10 @@ export const functions = defineFunctions({
       { name: 'amount', type: 'euint64' },
     ],
   },
-
+  confidentialTotalSupply: {
+    kind: 'public' as const,
+    mutability: 'view',
+    args: [],
+    returns: ['euint64'],
+  },
 });

packages/core/zama/src/contract.test.ts

@@ -70,23 +70,23 @@ test('contract with one override', t => {
       { name: 'amount', type: 'uint256' },
     ],
   };
-  Foo.addOverride(toContractReference('ERC20'), _beforeTokenTransfer);
+  Foo.addOverride(toContractReference('ConfidentialFungible'), _beforeTokenTransfer);
   t.snapshot(printContract(Foo));
 });
 
 test('contract with two overrides', t => {
   const Foo = new ContractBuilder('Foo');
-  Foo.addOverride(toContractReference('ERC20'), _beforeTokenTransfer);
-  Foo.addOverride(toContractReference('ERC20Snapshot'), _beforeTokenTransfer);
+  Foo.addOverride(toContractReference('ConfidentialFungible'), _beforeTokenTransfer);
+  Foo.addOverride(toContractReference('ConfidentialFungibleSnapshot'), _beforeTokenTransfer);
   t.snapshot(printContract(Foo));
 });
 
 test('contract with two different overrides', t => {
   const Foo = new ContractBuilder('Foo');
 
-  Foo.addOverride(toContractReference('ERC20'), _beforeTokenTransfer);
+  Foo.addOverride(toContractReference('ConfidentialFungible'), _beforeTokenTransfer);
   Foo.addOverride(toContractReference('OtherParent'), _beforeTokenTransfer);
-  Foo.addOverride(toContractReference('ERC20'), _otherFunction);
+  Foo.addOverride(toContractReference('ConfidentialFungible'), _otherFunction);
   Foo.addOverride(toContractReference('OtherParent'), _otherFunction);
   t.snapshot(printContract(Foo));
 });
@@ -101,7 +101,7 @@ test('contract with a modifier and override', t => {
   const Foo = new ContractBuilder('Foo');
   Foo.addModifier('whenNotPaused', _otherFunction);
 
-  Foo.addOverride(toContractReference('ERC20'), _otherFunction);
+  Foo.addOverride(toContractReference('ConfidentialFungible'), _otherFunction);
   Foo.addOverride(toContractReference('OtherParent'), _otherFunction);
   t.snapshot(printContract(Foo));
 });