@openzeppelin/wizard-stellar 0.4.3 → 0.4.5

package/src/contract.ts

@@ -185,6 +185,10 @@ export class ContractBuilder implements Contract {
     }
   }
 
+  addTraitForEachFunctions(baseTrait: BaseTraitImplBlock, functions: Record<string, BaseFunction>) {
+    Object.values(functions).forEach(fn => this.addTraitFunction(baseTrait, fn));
+  }
+
   // used for adding a function to a trait implementation block
   addTraitFunction(baseTrait: BaseTraitImplBlock, fn: BaseFunction): ContractFunction {
     const t = this.addTraitImplBlock(baseTrait);
@@ -241,6 +245,11 @@ export class ContractBuilder implements Contract {
     existingFn.tags = [...(existingFn.tags ?? []), tag];
   }
 
+  setFunctionCode(fn: BaseFunction, code: string[], baseTrait?: BaseTraitImplBlock): void {
+    const existingFn = this.getOrCreateFunction(fn, baseTrait);
+    existingFn.code = [...code];
+  }
+
   addConstructorArgument(arg: Argument): void {
     for (const existingArg of this.constructorArgs) {
       if (existingArg.name == arg.name) {

package/src/fungible.ts

@@ -11,6 +11,7 @@ import { OptionsError } from './error';
 import { contractDefaults as commonDefaults } from './common-options';
 import { printContract } from './print';
 import { toByteArray, toUint } from './utils/convert-strings';
+import { pickKeys } from '@openzeppelin/wizard-common';
 
 export const defaults: Required<FungibleOptions> = {
   name: 'MyToken',
@@ -22,6 +23,7 @@ export const defaults: Required<FungibleOptions> = {
   mintable: false,
   access: commonDefaults.access,
   info: commonDefaults.info,
+  explicitImplementations: commonDefaults.explicitImplementations,
 } as const;
 
 export function printFungible(opts: FungibleOptions = defaults): string {
@@ -59,58 +61,68 @@ export function buildFungible(opts: FungibleOptions): ContractBuilder {
 
   const allOpts = withDefaults(opts);
 
-  addBase(c, toByteArray(allOpts.name), toByteArray(allOpts.symbol), allOpts.pausable);
+  addBase(c, toByteArray(allOpts.name), toByteArray(allOpts.symbol), allOpts.pausable, allOpts.explicitImplementations);
 
   if (allOpts.premint) {
     addPremint(c, allOpts.premint);
   }
 
   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.mintable) {
-    addMintable(c, allOpts.access, allOpts.pausable);
+    addMintable(c, allOpts.access, allOpts.pausable, 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, pausable: boolean) {
+function addBase(
+  c: ContractBuilder,
+  name: string,
+  symbol: string,
+  pausable: boolean,
+  explicitImplementations: boolean,
+) {
   // Set metadata
   c.addConstructorCode(`Base::set_metadata(e, 18, String::from_str(e, "${name}"), String::from_str(e, "${symbol}"));`);
 
   // Set token functions
   c.addUseClause('stellar_tokens::fungible', 'Base');
   c.addUseClause('stellar_tokens::fungible', 'FungibleToken');
-  c.addUseClause('stellar_macros', 'default_impl');
+  if (!explicitImplementations) 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 fungibleTokenTrait = {
     traitName: 'FungibleToken',
     structName: c.name,
-    tags: ['default_impl', 'contractimpl'],
+    tags: explicitImplementations ? ['contractimpl'] : ['default_impl', 'contractimpl'],
     assocType: 'type ContractType = Base;',
   };
 
   c.addTraitImplBlock(fungibleTokenTrait);
 
+  if (explicitImplementations) c.addTraitForEachFunctions(fungibleTokenTrait, fungibleTokenTraitFunctions);
+
   if (pausable) {
-    c.addUseClause('soroban_sdk', 'Address');
     c.addUseClause('stellar_macros', 'when_not_paused');
 
     c.addTraitFunction(fungibleTokenTrait, functions.transfer);
@@ -121,7 +133,7 @@ function addBase(c: ContractBuilder, name: string, symbol: string, pausable: boo
   }
 }
 
-function addMintable(c: ContractBuilder, access: Access, pausable: boolean) {
+function addMintable(c: ContractBuilder, access: Access, pausable: boolean, explicitImplementations: boolean) {
   c.addUseClause('soroban_sdk', 'Address');
   switch (access) {
     case false:
@@ -129,7 +141,7 @@ function addMintable(c: ContractBuilder, access: Access, pausable: boolean) {
     case 'ownable': {
       c.addFreeFunction(functions.mint);
 
-      requireAccessControl(c, undefined, functions.mint, access);
+      requireAccessControl(c, undefined, functions.mint, access, undefined, explicitImplementations);
 
       if (pausable) {
         c.addFunctionTag(functions.mint, 'when_not_paused');
@@ -139,11 +151,18 @@ function addMintable(c: ContractBuilder, access: Access, pausable: boolean) {
     case 'roles': {
       c.addFreeFunction(functions.mint_with_caller);
 
-      requireAccessControl(c, undefined, functions.mint_with_caller, access, {
-        useMacro: true,
-        caller: 'caller',
-        role: 'minter',
-      });
+      requireAccessControl(
+        c,
+        undefined,
+        functions.mint_with_caller,
+        access,
+        {
+          useMacro: true,
+          caller: 'caller',
+          role: 'minter',
+        },
+        explicitImplementations,
+      );
 
       if (pausable) {
         c.addFunctionTag(functions.mint_with_caller, 'when_not_paused');
@@ -157,7 +176,7 @@ function addMintable(c: ContractBuilder, access: Access, pausable: boolean) {
   }
 }
 
-function addBurnable(c: ContractBuilder, pausable: boolean) {
+function addBurnable(c: ContractBuilder, pausable: boolean, explicitImplementations: boolean) {
   c.addUseClause('stellar_tokens::fungible', 'burnable::FungibleBurnable');
   c.addUseClause('soroban_sdk', 'Address');
 
@@ -176,7 +195,8 @@ function addBurnable(c: ContractBuilder, pausable: boolean) {
 
     c.addTraitFunction(fungibleBurnableTrait, functions.burn_from);
     c.addFunctionTag(functions.burn_from, 'when_not_paused', fungibleBurnableTrait);
-  } else {
+  } else if (explicitImplementations) c.addTraitForEachFunctions(fungibleBurnableTrait, fungibleBurnableFunctions);
+  else {
     // prepend '#[default_impl]'
     fungibleBurnableTrait.tags.unshift('default_impl');
     c.addTraitImplBlock(fungibleBurnableTrait);
@@ -204,7 +224,7 @@ function addPremint(c: ContractBuilder, amount: string) {
 }
 
 /**
- * Calculates the initial supply that would be used in an Fungible contract based on a given premint amount and number of decimals.
+ * Calculates the initial supply that would be used in a Fungible contract based on a given premint amount and number of decimals.
  *
  * @param premint Premint amount in token units, may be fractional
  * @param decimals The number of decimals in the token
@@ -335,3 +355,17 @@ export const functions = defineFunctions({
     code: ['Base::mint(e, &account, amount);'],
   },
 });
+
+const fungibleTokenTraitFunctions = pickKeys(functions, [
+  'total_supply',
+  'balance',
+  'allowance',
+  'transfer',
+  'transfer_from',
+  'approve',
+  'decimals',
+  'name',
+  'symbol',
+]);
+
+const fungibleBurnableFunctions = pickKeys(functions, ['burn', 'burn_from']);

package/src/generate/fungible.ts

@@ -15,6 +15,7 @@ const blueprint = {
   premint: ['1'],
   access: accessOptions,
   info: infoOptions,
+  explicitImplementations: booleans,
 };
 
 export function* generateFungibleOptions(): Generator<Required<FungibleOptions>> {

package/src/generate/non-fungible.ts

@@ -8,6 +8,7 @@ const booleans = [true, false];
 const blueprint = {
   name: ['MyToken'],
   symbol: ['MTK'],
+  tokenUri: ['https://www.mytoken.com'],
   burnable: booleans,
   pausable: booleans,
   upgradeable: booleans,
@@ -17,6 +18,7 @@ const blueprint = {
   mintable: booleans,
   access: accessOptions,
   info: infoOptions,
+  explicitImplementations: booleans,
 };
 
 export function* generateNonFungibleOptions(): Generator<Required<NonFungibleOptions>> {

package/src/generate/stablecoin.ts

@@ -16,6 +16,7 @@ const blueprint = {
   access: accessOptions,
   limitations: limitationsOptions,
   info: infoOptions,
+  explicitImplementations: booleans,
 };
 
 export function* generateStablecoinOptions(): Generator<Required<StablecoinOptions>> {

package/src/non-fungible.ts

@@ -1,21 +1,22 @@
-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',
   symbol: 'MTK',
+  tokenUri: 'https://www.mytoken.com',
   burnable: false,
   enumerable: false,
   consecutive: false,
@@ -25,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 {
@@ -34,6 +36,7 @@ export function printNonFungible(opts: NonFungibleOptions = defaults): string {
 export interface NonFungibleOptions extends CommonContractOptions {
   name: string;
   symbol: string;
+  tokenUri?: string;
   burnable?: boolean;
   enumerable?: boolean;
   consecutive?: boolean;
@@ -47,6 +50,7 @@ function withDefaults(opts: NonFungibleOptions): Required<NonFungibleOptions> {
   return {
     ...opts,
     ...withCommonContractDefaults(opts),
+    tokenUri: opts.tokenUri ?? defaults.tokenUri,
     burnable: opts.burnable ?? defaults.burnable,
     consecutive: opts.consecutive ?? defaults.consecutive,
     enumerable: opts.enumerable ?? defaults.enumerable,
@@ -87,41 +91,62 @@ export function buildNonFungible(opts: NonFungibleOptions): Contract {
     throw new OptionsError(errors);
   }
 
-  addBase(c, toByteArray(allOpts.name), toByteArray(allOpts.symbol), 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, 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, "www.mytoken.com");');
+  c.addConstructorCode(`let uri = String::from_str(e, "${tokenUri}");`);
   c.addConstructorCode(`let name = String::from_str(e, "${name}");`);
   c.addConstructorCode(`let symbol = String::from_str(e, "${symbol}");`);
   c.addConstructorCode(`Base::set_metadata(e, uri, name, symbol);`);
@@ -129,21 +154,25 @@ function addBase(c: ContractBuilder, name: string, symbol: string, pausable: boo
   // 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');
 
@@ -155,7 +184,7 @@ function addBase(c: ContractBuilder, name: string, symbol: string, pausable: boo
   }
 }
 
-function addBurnable(c: ContractBuilder, pausable: boolean) {
+function addBurnable(c: ContractBuilder, pausable: boolean, explicitImplementations: boolean) {
   c.addUseClause('stellar_tokens::non_fungible', 'burnable::NonFungibleBurnable');
 
   const nonFungibleBurnableTrait = {
@@ -173,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,
@@ -210,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');
@@ -358,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' }],
@@ -374,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',
@@ -407,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',
@@ -423,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)'],
   },
 });