@openzeppelin/wizard-stellar 0.4.4 → 0.4.5

package/src/non-fungible.ts

@@ -1,17 +1,17 @@
-import type { Contract } from './contract';
-import { ContractBuilder } from './contract';
-import { type Access, requireAccessControl, setAccessControl } from './set-access-control';
+import { pickKeys } from '@openzeppelin/wizard-common';
 import { addPausable } from './add-pausable';
 import { addUpgradeable } from './add-upgradeable';
-import { defineFunctions } from './utils/define-functions';
 import type { CommonContractOptions } from './common-options';
-import { withCommonContractDefaults, getSelfArg } from './common-options';
-import { setInfo } from './set-info';
+import { contractDefaults as commonDefaults, getSelfArg, withCommonContractDefaults } from './common-options';
+import type { Contract } from './contract';
+import { ContractBuilder } from './contract';
 import type { OptionsErrorMessages } from './error';
 import { OptionsError } from './error';
-import { contractDefaults as commonDefaults } from './common-options';
 import { printContract } from './print';
+import { type Access, DEFAULT_ACCESS_CONTROL, requireAccessControl, setAccessControl } from './set-access-control';
+import { setInfo } from './set-info';
 import { toByteArray } from './utils/convert-strings';
+import { defineFunctions } from './utils/define-functions';
 
 export const defaults: Required<NonFungibleOptions> = {
   name: 'MyToken',
@@ -26,6 +26,7 @@ export const defaults: Required<NonFungibleOptions> = {
   sequential: false,
   access: commonDefaults.access, // TODO: Determine whether Access Control options should be visible in the UI before they are implemented as modules
   info: commonDefaults.info,
+  explicitImplementations: commonDefaults.explicitImplementations,
 } as const;
 
 export function printNonFungible(opts: NonFungibleOptions = defaults): string {
@@ -90,39 +91,60 @@ export function buildNonFungible(opts: NonFungibleOptions): Contract {
     throw new OptionsError(errors);
   }
 
-  addBase(c, toByteArray(allOpts.name), toByteArray(allOpts.symbol), toByteArray(allOpts.tokenUri), allOpts.pausable);
+  addBase(
+    c,
+    toByteArray(allOpts.name),
+    toByteArray(allOpts.symbol),
+    toByteArray(allOpts.tokenUri),
+    allOpts.pausable,
+    allOpts.explicitImplementations,
+  );
 
   if (allOpts.pausable) {
-    addPausable(c, allOpts.access);
+    addPausable(c, allOpts.access, allOpts.explicitImplementations);
   }
 
   if (allOpts.upgradeable) {
-    addUpgradeable(c, allOpts.access);
+    addUpgradeable(c, allOpts.access, allOpts.explicitImplementations);
   }
 
   if (allOpts.burnable) {
-    addBurnable(c, allOpts.pausable);
+    addBurnable(c, allOpts.pausable, allOpts.explicitImplementations);
   }
 
   if (allOpts.enumerable) {
-    addEnumerable(c);
+    addEnumerable(c, allOpts.explicitImplementations);
   }
 
   if (allOpts.consecutive) {
-    addConsecutive(c, allOpts.pausable, allOpts.access);
+    addConsecutive(c, allOpts.pausable, allOpts.access, allOpts.explicitImplementations);
   }
 
   if (allOpts.mintable) {
-    addMintable(c, allOpts.enumerable, allOpts.pausable, allOpts.sequential, allOpts.access);
+    addMintable(
+      c,
+      allOpts.enumerable,
+      allOpts.pausable,
+      allOpts.sequential,
+      allOpts.access,
+      allOpts.explicitImplementations,
+    );
   }
 
-  setAccessControl(c, allOpts.access);
+  setAccessControl(c, allOpts.access, allOpts.explicitImplementations);
   setInfo(c, allOpts.info);
 
   return c;
 }
 
-function addBase(c: ContractBuilder, name: string, symbol: string, tokenUri: string, pausable: boolean) {
+function addBase(
+  c: ContractBuilder,
+  name: string,
+  symbol: string,
+  tokenUri: string,
+  pausable: boolean,
+  explicitImplementations: boolean,
+) {
   // Set metadata
   c.addConstructorCode(`let uri = String::from_str(e, "${tokenUri}");`);
   c.addConstructorCode(`let name = String::from_str(e, "${name}");`);
@@ -132,21 +154,25 @@ function addBase(c: ContractBuilder, name: string, symbol: string, tokenUri: str
   // Set token functions
   c.addUseClause('stellar_tokens::non_fungible', 'Base');
   c.addUseClause('stellar_tokens::non_fungible', 'NonFungibleToken');
-  c.addUseClause('stellar_macros', 'default_impl');
+  if (explicitImplementations) c.addUseClause('stellar_tokens::non_fungible', 'ContractOverrides');
+  else c.addUseClause('stellar_macros', 'default_impl');
   c.addUseClause('soroban_sdk', 'contract');
   c.addUseClause('soroban_sdk', 'contractimpl');
   c.addUseClause('soroban_sdk', 'String');
   c.addUseClause('soroban_sdk', 'Env');
+  if (explicitImplementations || pausable) c.addUseClause('soroban_sdk', 'Address');
 
   const nonFungibleTokenTrait = {
     traitName: 'NonFungibleToken',
     structName: c.name,
-    tags: ['default_impl', 'contractimpl'],
+    tags: explicitImplementations ? ['contractimpl'] : ['default_impl', 'contractimpl'],
     assocType: 'type ContractType = Base;',
   };
 
   c.addTraitImplBlock(nonFungibleTokenTrait);
 
+  if (explicitImplementations) c.addTraitForEachFunctions(nonFungibleTokenTrait, nonFungibleTokenTraitFunctions);
+
   if (pausable) {
     c.addUseClause('stellar_macros', 'when_not_paused');
 
@@ -158,7 +184,7 @@ function addBase(c: ContractBuilder, name: string, symbol: string, tokenUri: str
   }
 }
 
-function addBurnable(c: ContractBuilder, pausable: boolean) {
+function addBurnable(c: ContractBuilder, pausable: boolean, explicitImplementations: boolean) {
   c.addUseClause('stellar_tokens::non_fungible', 'burnable::NonFungibleBurnable');
 
   const nonFungibleBurnableTrait = {
@@ -176,32 +202,38 @@ function addBurnable(c: ContractBuilder, pausable: boolean) {
 
     c.addTraitFunction(nonFungibleBurnableTrait, burnableFunctions.burn_from);
     c.addFunctionTag(burnableFunctions.burn_from, 'when_not_paused', nonFungibleBurnableTrait);
-  } else {
+  } else if (explicitImplementations)
+    c.addTraitForEachFunctions(nonFungibleBurnableTrait, nonFungibleBurnableFunctions);
+  else {
     // prepend '#[default_impl]'
     nonFungibleBurnableTrait.tags.unshift('default_impl');
     c.addTraitImplBlock(nonFungibleBurnableTrait);
   }
 }
 
-function addEnumerable(c: ContractBuilder) {
+function addEnumerable(c: ContractBuilder, explicitImplementations: boolean) {
   c.addUseClause('stellar_tokens::non_fungible', 'enumerable::{NonFungibleEnumerable, Enumerable}');
-  c.addUseClause('stellar_macros', 'default_impl');
+  if (explicitImplementations) c.addUseClause('soroban_sdk', 'Address');
+  else c.addUseClause('stellar_macros', 'default_impl');
 
   const nonFungibleEnumerableTrait = {
     traitName: 'NonFungibleEnumerable',
     structName: c.name,
-    tags: ['default_impl', 'contractimpl'],
+    tags: explicitImplementations ? ['contractimpl'] : ['default_impl', 'contractimpl'],
     section: 'Extensions',
   };
-  c.addTraitImplBlock(nonFungibleEnumerableTrait);
+  if (explicitImplementations)
+    c.addTraitForEachFunctions(nonFungibleEnumerableTrait, nonFungibleEnumerableTraitFunctions);
+  else c.addTraitImplBlock(nonFungibleEnumerableTrait);
 
   c.overrideAssocType('NonFungibleToken', 'type ContractType = Enumerable;');
 }
 
-function addConsecutive(c: ContractBuilder, pausable: boolean, access: Access) {
+function addConsecutive(c: ContractBuilder, pausable: boolean, access: Access, explicitImplementations: boolean) {
   c.addUseClause('stellar_tokens::non_fungible', 'consecutive::{NonFungibleConsecutive, Consecutive}');
   c.addUseClause('soroban_sdk', 'Address');
 
+  const effectiveAccess = access === false ? DEFAULT_ACCESS_CONTROL : access;
   const nonFungibleConsecutiveTrait = {
     traitName: 'NonFungibleConsecutive',
     structName: c.name,
@@ -213,45 +245,64 @@ function addConsecutive(c: ContractBuilder, pausable: boolean, access: Access) {
 
   c.overrideAssocType('NonFungibleToken', 'type ContractType = Consecutive;');
 
-  const mintFn = access === 'ownable' ? consecutiveFunctions.batch_mint : consecutiveFunctions.batch_mint_with_caller;
+  const mintFn =
+    effectiveAccess === 'ownable' ? consecutiveFunctions.batch_mint : consecutiveFunctions.batch_mint_with_caller;
   c.addFreeFunction(mintFn);
   if (pausable) {
     c.addFunctionTag(mintFn, 'when_not_paused');
   }
 
-  requireAccessControl(c, undefined, mintFn, access, {
-    useMacro: true,
-    role: 'minter',
-    caller: 'caller',
-  });
+  requireAccessControl(
+    c,
+    undefined,
+    mintFn,
+    effectiveAccess,
+    {
+      useMacro: true,
+      role: 'minter',
+      caller: 'caller',
+    },
+    explicitImplementations,
+  );
 }
 
-function addMintable(c: ContractBuilder, enumerable: boolean, pausable: boolean, sequential: boolean, access: Access) {
+function addMintable(
+  c: ContractBuilder,
+  enumerable: boolean,
+  pausable: boolean,
+  sequential: boolean,
+  access: Access,
+  explicitImplementations: boolean,
+) {
   c.addUseClause('soroban_sdk', 'Address');
   const accessProps = { useMacro: true, role: 'minter', caller: 'caller' };
+  const effectiveAccess = access === false ? DEFAULT_ACCESS_CONTROL : access;
 
   let mintFn;
 
   if (enumerable) {
     if (sequential) {
       mintFn =
-        access === 'ownable' ? enumerableFunctions.sequential_mint : enumerableFunctions.sequential_mint_with_caller;
+        effectiveAccess === 'ownable'
+          ? enumerableFunctions.sequential_mint
+          : enumerableFunctions.sequential_mint_with_caller;
     } else {
       mintFn =
-        access === 'ownable'
+        effectiveAccess === 'ownable'
           ? enumerableFunctions.non_sequential_mint
           : enumerableFunctions.non_sequential_mint_with_caller;
     }
   } else {
     if (sequential) {
-      mintFn = access === 'ownable' ? baseFunctions.sequential_mint : baseFunctions.sequential_mint_with_caller;
+      mintFn =
+        effectiveAccess === 'ownable' ? baseFunctions.sequential_mint : baseFunctions.sequential_mint_with_caller;
     } else {
-      mintFn = access === 'ownable' ? baseFunctions.mint : baseFunctions.mint_with_caller;
+      mintFn = effectiveAccess === 'ownable' ? baseFunctions.mint : baseFunctions.mint_with_caller;
     }
   }
 
   c.addFreeFunction(mintFn);
-  requireAccessControl(c, undefined, mintFn, access, accessProps);
+  requireAccessControl(c, undefined, mintFn, effectiveAccess, accessProps, explicitImplementations);
 
   if (pausable) {
     c.addFunctionTag(mintFn, 'when_not_paused');
@@ -361,6 +412,20 @@ const baseFunctions = defineFunctions({
   },
 });
 
+const nonFungibleTokenTraitFunctions = pickKeys(baseFunctions, [
+  'balance',
+  'owner_of',
+  'transfer',
+  'transfer_from',
+  'approve',
+  'approve_for_all',
+  'get_approved',
+  'is_approved_for_all',
+  'name',
+  'symbol',
+  'token_uri',
+]);
+
 const burnableFunctions = defineFunctions({
   burn: {
     args: [getSelfArg(), { name: 'from', type: 'Address' }, { name: 'token_id', type: 'u32' }],
@@ -377,11 +442,23 @@ const burnableFunctions = defineFunctions({
   },
 });
 
+const nonFungibleBurnableFunctions = pickKeys(burnableFunctions, ['burn', 'burn_from']);
+
 const enumerableFunctions = defineFunctions({
   total_supply: {
     args: [getSelfArg()],
     returns: 'u32',
-    code: ['non_fungible::enumerable::Enumerable::total_supply(e)'],
+    code: ['Enumerable::total_supply(e)'],
+  },
+  get_owner_token_id: {
+    args: [getSelfArg(), { name: 'owner', type: 'Address' }, { name: 'index', type: 'u32' }],
+    returns: 'u32',
+    code: ['Enumerable::get_owner_token_id(e, &owner, index)'],
+  },
+  get_token_id: {
+    args: [getSelfArg(), { name: 'index', type: 'u32' }],
+    returns: 'u32',
+    code: ['Enumerable::get_token_id(e, index)'],
   },
   non_sequential_mint: {
     name: 'mint',
@@ -410,12 +487,18 @@ const enumerableFunctions = defineFunctions({
   },
 });
 
+const nonFungibleEnumerableTraitFunctions = pickKeys(enumerableFunctions, [
+  'total_supply',
+  'get_owner_token_id',
+  'get_token_id',
+]);
+
 const consecutiveFunctions = defineFunctions({
   batch_mint: {
     name: 'batch_mint',
     args: [getSelfArg(), { name: 'to', type: 'Address' }, { name: 'amount', type: 'u32' }],
     returns: 'u32',
-    code: ['Consecutive::batch_mint(e, &to, amount);'],
+    code: ['Consecutive::batch_mint(e, &to, amount)'],
   },
   batch_mint_with_caller: {
     name: 'batch_mint',
@@ -426,6 +509,6 @@ const consecutiveFunctions = defineFunctions({
       { name: 'caller', type: 'Address' },
     ],
     returns: 'u32',
-    code: ['Consecutive::batch_mint(e, &to, amount);'],
+    code: ['Consecutive::batch_mint(e, &to, amount)'],
   },
 });

package/src/set-access-control.ts

@@ -1,4 +1,6 @@
+import { getSelfArg } from './common-options';
 import type { BaseFunction, BaseTraitImplBlock, ContractBuilder } from './contract';
+import { defineFunctions } from './utils/define-functions';
 
 export const accessOptions = [false, 'ownable', 'roles'] as const;
 export const DEFAULT_ACCESS_CONTROL = 'ownable';
@@ -13,7 +15,7 @@ export type AccessProps = {
 /**
  * Sets access control for the contract via constructor args.
  */
-export function setAccessControl(c: ContractBuilder, access: Access): void {
+export function setAccessControl(c: ContractBuilder, access: Access, explicitImplementations = false): void {
   switch (access) {
     case false:
       break;
@@ -27,10 +29,14 @@ export function setAccessControl(c: ContractBuilder, access: Access): void {
         const ownableTrait = {
           traitName: 'Ownable',
           structName: c.name,
-          tags: ['default_impl', 'contractimpl'],
+          tags: explicitImplementations ? ['contractimpl'] : ['default_impl', 'contractimpl'],
           section: 'Utils',
         };
-        c.addTraitImplBlock(ownableTrait);
+        if (explicitImplementations) {
+          c.addTraitForEachFunctions(ownableTrait, ownableFunctions);
+        } else {
+          c.addTraitImplBlock(ownableTrait);
+        }
 
         c.addConstructorArgument({ name: 'owner', type: 'Address' });
         c.addConstructorCode('ownable::set_owner(e, &owner);');
@@ -42,13 +48,18 @@ export function setAccessControl(c: ContractBuilder, access: Access): void {
       c.addUseClause('stellar_access::access_control', 'self', { alias: 'access_control' });
       c.addUseClause('stellar_access::access_control', 'AccessControl');
 
-      const accessControltrait = {
+      const accessControlTrait = {
         traitName: 'AccessControl',
         structName: c.name,
-        tags: ['default_impl', 'contractimpl'],
+        tags: explicitImplementations ? ['contractimpl'] : ['default_impl', 'contractimpl'],
         section: 'Utils',
       };
-      c.addTraitImplBlock(accessControltrait);
+      if (explicitImplementations) {
+        c.addUseClause('soroban_sdk', 'Symbol');
+        c.addTraitForEachFunctions(accessControlTrait, accessControlFunctions);
+      } else {
+        c.addTraitImplBlock(accessControlTrait);
+      }
 
       c.addConstructorArgument({ name: 'admin', type: 'Address' });
       c.addConstructorCode('access_control::set_admin(e, &admin);');
@@ -70,11 +81,12 @@ export function requireAccessControl(
   fn: BaseFunction,
   access: Access,
   accessProps: AccessProps = { useMacro: true },
+  explicitImplementations = false,
 ): void {
   if (access === false) {
     access = DEFAULT_ACCESS_CONTROL;
   }
-  setAccessControl(c, access);
+  setAccessControl(c, access, explicitImplementations);
 
   switch (access) {
     case 'ownable': {
@@ -123,3 +135,89 @@ export function requireAccessControl(
     }
   }
 }
+
+const ownableFunctions = defineFunctions({
+  get_owner: {
+    args: [getSelfArg()],
+    returns: 'Option<Address>',
+    code: ['ownable::get_owner(e)'],
+  },
+  transfer_ownership: {
+    args: [getSelfArg(), { name: 'new_owner', type: 'Address' }, { name: 'live_until_ledger', type: 'u32' }],
+    code: ['ownable::transfer_ownership(e, &new_owner, live_until_ledger);'],
+  },
+  accept_ownership: {
+    args: [getSelfArg()],
+    code: ['ownable::accept_ownership(e);'],
+  },
+  renounce_ownership: {
+    args: [getSelfArg()],
+    code: ['ownable::renounce_ownership(e);'],
+  },
+});
+
+const accessControlFunctions = defineFunctions({
+  has_role: {
+    args: [getSelfArg(), { name: 'account', type: 'Address' }, { name: 'role', type: 'Symbol' }],
+    returns: 'Option<u32>',
+    code: ['access_control::has_role(e, &account, &role)'],
+  },
+  get_role_member_count: {
+    args: [getSelfArg(), { name: 'role', type: 'Symbol' }],
+    returns: 'u32',
+    code: ['access_control::get_role_member_count(e, &role)'],
+  },
+  get_role_member: {
+    args: [getSelfArg(), { name: 'role', type: 'Symbol' }, { name: 'index', type: 'u32' }],
+    returns: 'Address',
+    code: ['access_control::get_role_member(e, &role, index)'],
+  },
+  get_role_admin: {
+    args: [getSelfArg(), { name: 'role', type: 'Symbol' }],
+    returns: 'Option<Symbol>',
+    code: ['access_control::get_role_admin(e, &role)'],
+  },
+  get_admin: {
+    args: [getSelfArg()],
+    returns: 'Option<Address>',
+    code: ['access_control::get_admin(e)'],
+  },
+  grant_role: {
+    args: [
+      getSelfArg(),
+      { name: 'caller', type: 'Address' },
+      { name: 'account', type: 'Address' },
+      { name: 'role', type: 'Symbol' },
+    ],
+    code: ['access_control::grant_role(e, &caller, &account, &role);'],
+  },
+  revoke_role: {
+    args: [
+      getSelfArg(),
+      { name: 'caller', type: 'Address' },
+      { name: 'account', type: 'Address' },
+      { name: 'role', type: 'Symbol' },
+    ],
+    code: ['access_control::revoke_role(e, &caller, &account, &role);'],
+  },
+  renounce_role: {
+    args: [getSelfArg(), { name: 'caller', type: 'Address' }, { name: 'role', type: 'Symbol' }],
+    code: ['access_control::renounce_role(e, &caller, &role);'],
+  },
+  transfer_admin_role: {
+    args: [getSelfArg(), { name: 'new_admin', type: 'Address' }, { name: 'live_until_ledger', type: 'u32' }],
+    code: ['access_control::transfer_admin_role(e, &new_admin, live_until_ledger);'],
+  },
+  accept_admin_transfer: {
+    args: [getSelfArg()],
+    code: ['access_control::accept_admin_transfer(e);'],
+  },
+  set_role_admin: {
+    args: [getSelfArg(), { name: 'role', type: 'Symbol' }, { name: 'admin_role', type: 'Symbol' }],
+    code: ['access_control::set_role_admin(e, &role, &admin_role);'],
+  },
+  renounce_admin: {
+    args: [getSelfArg()],
+    code: ['access_control::renounce_admin(e);'],
+  },
+});

package/src/stablecoin.ts

@@ -1,16 +1,16 @@
-import type { Contract, ContractBuilder } from './contract';
-import { defineFunctions } from './utils/define-functions';
 import { getSelfArg } from './common-options';
-import { printContract } from './print';
+import type { Contract, ContractBuilder } from './contract';
 import type { FungibleOptions } from './fungible';
 import {
   buildFungible,
   defaults as fungibleDefaults,
-  withDefaults as withFungibleDefaults,
   functions as fungibleFunctions,
   isAccessControlRequired as fungibleIsAccessControlRequired,
+  withDefaults as withFungibleDefaults,
 } from './fungible';
+import { printContract } from './print';
 import { requireAccessControl, type Access } from './set-access-control';
+import { defineFunctions } from './utils/define-functions';
 
 export const defaults: Required<StablecoinOptions> = {
   ...fungibleDefaults,
@@ -20,13 +20,14 @@ export const defaults: Required<StablecoinOptions> = {
 } as const;
 
 export const limitationsOptions = [false, 'allowlist', 'blocklist'] as const;
+export type Limitations = (typeof limitationsOptions)[number];
 
 export function printStablecoin(opts: StablecoinOptions = defaults): string {
   return printContract(buildStablecoin(opts));
 }
 
 export interface StablecoinOptions extends FungibleOptions {
-  limitations?: false | 'allowlist' | 'blocklist';
+  limitations?: Limitations;
 }
 
 function withDefaults(opts: StablecoinOptions): Required<StablecoinOptions> {
@@ -48,13 +49,18 @@ export function buildStablecoin(opts: StablecoinOptions): Contract {
   const c = buildFungible(allOpts);
 
   if (allOpts.limitations) {
-    addLimitations(c, allOpts.access, allOpts.limitations);
+    addLimitations(c, allOpts.access, allOpts.limitations, allOpts.explicitImplementations);
   }
 
   return c;
 }
 
-function addLimitations(c: ContractBuilder, access: Access, mode: 'allowlist' | 'blocklist') {
+function addLimitations(
+  c: ContractBuilder,
+  access: Access,
+  mode: 'allowlist' | 'blocklist',
+  explicitImplementations: boolean,
+) {
   const type = mode === 'allowlist';
 
   const limitationsTrait = {
@@ -72,6 +78,8 @@ function addLimitations(c: ContractBuilder, access: Access, mode: 'allowlist' |
     c.overrideAssocType('FungibleToken', 'type ContractType = BlockList;');
   }
 
+  if (explicitImplementations) overrideFungibleReadonlyFunctionsWithBase(c);
+
   const [getterFn, addFn, removeFn] = type
     ? [functions.allowed, functions.allow_user, functions.disallow_user]
     : [functions.blocked, functions.block_user, functions.unblock_user];
@@ -85,10 +93,32 @@ function addLimitations(c: ContractBuilder, access: Access, mode: 'allowlist' |
   };
 
   c.addTraitFunction(limitationsTrait, addFn);
-  requireAccessControl(c, limitationsTrait, addFn, access, accessProps);
+  requireAccessControl(c, limitationsTrait, addFn, access, accessProps, explicitImplementations);
 
   c.addTraitFunction(limitationsTrait, removeFn);
-  requireAccessControl(c, limitationsTrait, removeFn, access, accessProps);
+  requireAccessControl(c, limitationsTrait, removeFn, access, accessProps, explicitImplementations);
+}
+
+function overrideFungibleReadonlyFunctionsWithBase(c: ContractBuilder) {
+  c.addUseClause('stellar_tokens::fungible', 'ContractOverrides');
+  const fungibleTokenTrait = {
+    traitName: 'FungibleToken',
+    structName: c.name,
+    tags: [],
+  };
+
+  const overrides: Array<[(typeof fungibleFunctions)[keyof typeof fungibleFunctions], string[]]> = [
+    [fungibleFunctions.total_supply, ['Self::ContractType::total_supply(e)']],
+    [fungibleFunctions.balance, ['Self::ContractType::balance(e, &account)']],
+    [fungibleFunctions.allowance, ['Self::ContractType::allowance(e, &owner, &spender)']],
+    [fungibleFunctions.decimals, ['Self::ContractType::decimals(e)']],
+    [fungibleFunctions.name, ['Self::ContractType::name(e)']],
+    [fungibleFunctions.symbol, ['Self::ContractType::symbol(e)']],
+  ];
+
+  for (const [fn, code] of overrides) {
+    c.setFunctionCode(fn, code, fungibleTokenTrait);
+  }
 }
 
 const functions = {