@openzeppelin/wizard-stellar 0.2.3 → 0.4.1

package/src/fungible.ts

@@ -1,4 +1,3 @@
-import type { Contract } from './contract';
 import { ContractBuilder } from './contract';
 import type { Access } from './set-access-control';
 import { requireAccessControl, setAccessControl } from './set-access-control';
@@ -21,7 +20,7 @@ export const defaults: Required<FungibleOptions> = {
   upgradeable: false,
   premint: '0',
   mintable: false,
-  access: commonDefaults.access, // TODO: Determine whether Access Control options should be visible in the UI before they are implemented as modules
+  access: commonDefaults.access,
   info: commonDefaults.info,
 } as const;
 
@@ -39,7 +38,7 @@ export interface FungibleOptions extends CommonContractOptions {
   mintable?: boolean;
 }
 
-function withDefaults(opts: FungibleOptions): Required<FungibleOptions> {
+export function withDefaults(opts: FungibleOptions): Required<FungibleOptions> {
   return {
     ...opts,
     ...withCommonContractDefaults(opts),
@@ -51,7 +50,11 @@ function withDefaults(opts: FungibleOptions): Required<FungibleOptions> {
   };
 }
 
-export function buildFungible(opts: FungibleOptions): Contract {
+export function isAccessControlRequired(opts: Partial<FungibleOptions>): boolean {
+  return opts.mintable === true || opts.pausable === true || opts.upgradeable === true;
+}
+
+export function buildFungible(opts: FungibleOptions): ContractBuilder {
   const c = new ContractBuilder(opts.name);
 
   const allOpts = withDefaults(opts);
@@ -86,45 +89,76 @@ export function buildFungible(opts: FungibleOptions): Contract {
 
 function addBase(c: ContractBuilder, name: string, symbol: string, pausable: boolean) {
   // Set metadata
-  c.addConstructorCode(
-    `fungible::metadata::set_metadata(e, 18, String::from_str(e, "${name}"), String::from_str(e, "${symbol}"));`,
-  );
+  c.addConstructorCode(`Base::set_metadata(e, 18, String::from_str(e, "${name}"), String::from_str(e, "${symbol}"));`);
 
   // Set token functions
-  c.addUseClause('stellar_fungible', 'self', { alias: 'fungible' });
-  c.addUseClause('stellar_fungible', 'FungibleToken');
+  c.addUseClause('stellar_tokens::fungible', 'Base');
+  c.addUseClause('stellar_tokens::fungible', 'FungibleToken');
+  c.addUseClause('stellar_macros', 'default_impl');
   c.addUseClause('soroban_sdk', 'contract');
   c.addUseClause('soroban_sdk', 'contractimpl');
-  c.addUseClause('soroban_sdk', 'Address');
   c.addUseClause('soroban_sdk', 'String');
   c.addUseClause('soroban_sdk', 'Env');
-  c.addUseClause('soroban_sdk', 'Symbol');
 
   const fungibleTokenTrait = {
     traitName: 'FungibleToken',
     structName: c.name,
-    tags: ['contractimpl'],
+    tags: ['default_impl', 'contractimpl'],
+    assocType: 'type ContractType = Base;',
   };
 
-  c.addTraitFunction(fungibleTokenTrait, functions.total_supply);
-  c.addTraitFunction(fungibleTokenTrait, functions.balance);
-  c.addTraitFunction(fungibleTokenTrait, functions.allowance);
-  c.addTraitFunction(fungibleTokenTrait, functions.transfer);
-  c.addTraitFunction(fungibleTokenTrait, functions.transfer_from);
-  c.addTraitFunction(fungibleTokenTrait, functions.approve);
-  c.addTraitFunction(fungibleTokenTrait, functions.decimals);
-  c.addTraitFunction(fungibleTokenTrait, functions.name);
-  c.addTraitFunction(fungibleTokenTrait, functions.symbol);
+  c.addTraitImplBlock(fungibleTokenTrait);
 
   if (pausable) {
-    c.addUseClause('stellar_pausable_macros', 'when_not_paused');
+    c.addUseClause('soroban_sdk', 'Address');
+    c.addUseClause('stellar_macros', 'when_not_paused');
+
+    c.addTraitFunction(fungibleTokenTrait, functions.transfer);
     c.addFunctionTag(functions.transfer, 'when_not_paused', fungibleTokenTrait);
+
+    c.addTraitFunction(fungibleTokenTrait, functions.transfer_from);
     c.addFunctionTag(functions.transfer_from, 'when_not_paused', fungibleTokenTrait);
   }
 }
 
+function addMintable(c: ContractBuilder, access: Access, pausable: boolean) {
+  c.addUseClause('soroban_sdk', 'Address');
+  switch (access) {
+    case false:
+      break;
+    case 'ownable': {
+      c.addFreeFunction(functions.mint);
+
+      requireAccessControl(c, undefined, functions.mint, access);
+
+      if (pausable) {
+        c.addFunctionTag(functions.mint, 'when_not_paused');
+      }
+      break;
+    }
+    case 'roles': {
+      c.addFreeFunction(functions.mint_with_caller);
+
+      requireAccessControl(c, undefined, functions.mint_with_caller, access, {
+        useMacro: true,
+        caller: 'caller',
+        role: 'minter',
+      });
+
+      if (pausable) {
+        c.addFunctionTag(functions.mint_with_caller, 'when_not_paused');
+      }
+      break;
+    }
+    default: {
+      const _: never = access;
+      throw new Error('Unknown value for `access`');
+    }
+  }
+}
+
 function addBurnable(c: ContractBuilder, pausable: boolean) {
-  c.addUseClause('stellar_fungible', 'burnable::FungibleBurnable');
+  c.addUseClause('stellar_tokens::fungible', 'burnable::FungibleBurnable');
   c.addUseClause('soroban_sdk', 'Address');
 
   const fungibleBurnableTrait = {
@@ -134,13 +168,18 @@ function addBurnable(c: ContractBuilder, pausable: boolean) {
     section: 'Extensions',
   };
 
-  c.addTraitFunction(fungibleBurnableTrait, functions.burn);
-  c.addTraitFunction(fungibleBurnableTrait, functions.burn_from);
-
   if (pausable) {
-    c.addUseClause('stellar_pausable_macros', 'when_not_paused');
+    c.addUseClause('stellar_macros', 'when_not_paused');
+
+    c.addTraitFunction(fungibleBurnableTrait, functions.burn);
     c.addFunctionTag(functions.burn, 'when_not_paused', fungibleBurnableTrait);
+
+    c.addTraitFunction(fungibleBurnableTrait, functions.burn_from);
     c.addFunctionTag(functions.burn_from, 'when_not_paused', fungibleBurnableTrait);
+  } else {
+    // prepend '#[default_impl]'
+    fungibleBurnableTrait.tags.unshift('default_impl');
+    c.addTraitImplBlock(fungibleBurnableTrait);
   }
 }
 
@@ -157,11 +196,10 @@ function addPremint(c: ContractBuilder, amount: string) {
     // TODO: handle signed int?
     const premintAbsolute = toUint(getInitialSupply(amount, 18), 'premint', 'u128');
 
-    c.addUseClause('stellar_fungible', 'mintable::FungibleMintable');
     c.addUseClause('soroban_sdk', 'Address');
 
     c.addConstructorArgument({ name: 'recipient', type: 'Address' });
-    c.addConstructorCode(`fungible::mintable::mint(e, &recipient, ${premintAbsolute});`);
+    c.addConstructorCode(`Base::mint(e, &recipient, ${premintAbsolute});`);
   }
 }
 
@@ -206,41 +244,22 @@ export function getInitialSupply(premint: string, decimals: number): string {
   return result;
 }
 
-function addMintable(c: ContractBuilder, access: Access, pausable: boolean) {
-  c.addUseClause('stellar_fungible', 'mintable::FungibleMintable');
-
-  const fungibleMintableTrait = {
-    traitName: 'FungibleMintable',
-    structName: c.name,
-    tags: ['contractimpl'],
-    section: 'Extensions',
-  };
-
-  c.addTraitFunction(fungibleMintableTrait, functions.mint);
-
-  requireAccessControl(c, fungibleMintableTrait, functions.mint, access);
-
-  if (pausable) {
-    c.addFunctionTag(functions.mint, 'when_not_paused', fungibleMintableTrait);
-  }
-}
-
-const functions = defineFunctions({
+export const functions = defineFunctions({
   // Token Functions
   total_supply: {
     args: [getSelfArg()],
     returns: 'i128',
-    code: ['fungible::total_supply(e)'],
+    code: ['Self::ContractType::total_supply(e)'],
   },
   balance: {
     args: [getSelfArg(), { name: 'account', type: 'Address' }],
     returns: 'i128',
-    code: ['fungible::balance(e, &account)'],
+    code: ['Self::ContractType::balance(e, &account)'],
   },
   allowance: {
     args: [getSelfArg(), { name: 'owner', type: 'Address' }, { name: 'spender', type: 'Address' }],
     returns: 'i128',
-    code: ['fungible::allowance(e, &owner, &spender)'],
+    code: ['Self::ContractType::allowance(e, &owner, &spender)'],
   },
   transfer: {
     args: [
@@ -249,7 +268,7 @@ const functions = defineFunctions({
       { name: 'to', type: 'Address' },
       { name: 'amount', type: 'i128' },
     ],
-    code: ['fungible::transfer(e, &from, &to, amount)'],
+    code: ['Self::ContractType::transfer(e, &from, &to, amount)'],
   },
   transfer_from: {
     args: [
@@ -259,7 +278,7 @@ const functions = defineFunctions({
       { name: 'to', type: 'Address' },
       { name: 'amount', type: 'i128' },
     ],
-    code: ['fungible::transfer_from(e, &spender, &from, &to, amount)'],
+    code: ['Self::ContractType::transfer_from(e, &spender, &from, &to, amount)'],
   },
   approve: {
     args: [
@@ -269,28 +288,28 @@ const functions = defineFunctions({
       { name: 'amount', type: 'i128' },
       { name: 'live_until_ledger', type: 'u32' },
     ],
-    code: ['fungible::approve(e, &owner, &spender, amount, live_until_ledger)'],
+    code: ['Self::ContractType::approve(e, &owner, &spender, amount, live_until_ledger)'],
   },
   decimals: {
     args: [getSelfArg()],
     returns: 'u32',
-    code: ['fungible::metadata::decimals(e)'],
+    code: ['Self::ContractType::decimals(e)'],
   },
   name: {
     args: [getSelfArg()],
     returns: 'String',
-    code: ['fungible::metadata::name(e)'],
+    code: ['Self::ContractType::name(e)'],
   },
   symbol: {
     args: [getSelfArg()],
     returns: 'String',
-    code: ['fungible::metadata::symbol(e)'],
+    code: ['Self::ContractType::symbol(e)'],
   },
 
   // Extensions
   burn: {
     args: [getSelfArg(), { name: 'from', type: 'Address' }, { name: 'amount', type: 'i128' }],
-    code: ['fungible::burnable::burn(e, &from, amount)'],
+    code: ['Base::burn(e, &from, amount)'],
   },
   burn_from: {
     args: [
@@ -299,10 +318,20 @@ const functions = defineFunctions({
       { name: 'from', type: 'Address' },
       { name: 'amount', type: 'i128' },
     ],
-    code: ['fungible::burnable::burn_from(e, &spender, &from, amount)'],
+    code: ['Base::burn_from(e, &spender, &from, amount)'],
   },
   mint: {
     args: [getSelfArg(), { name: 'account', type: 'Address' }, { name: 'amount', type: 'i128' }],
-    code: ['fungible::mintable::mint(e, &account, amount);'],
+    code: ['Base::mint(e, &account, amount);'],
+  },
+  mint_with_caller: {
+    name: 'mint',
+    args: [
+      getSelfArg(),
+      { name: 'account', type: 'Address' },
+      { name: 'amount', type: 'i128' },
+      { name: 'caller', type: 'Address' },
+    ],
+    code: ['Base::mint(e, &account, amount);'],
   },
 });

package/src/generate/sources.ts

@@ -4,6 +4,7 @@ import crypto from 'crypto';
 
 import { generateFungibleOptions } from './fungible';
 import { generateNonFungibleOptions } from './non-fungible';
+import { generateStablecoinOptions } from './stablecoin';
 import type { GenericOptions, KindedOptions } from '../build-generic';
 import { buildGeneric } from '../build-generic';
 import { printContract } from '../print';
@@ -24,6 +25,12 @@ export function* generateOptions(kind?: Kind): Generator<GenericOptions> {
       yield { kind: 'NonFungible', ...kindOpts };
     }
   }
+
+  if (!kind || kind === 'Stablecoin') {
+    for (const kindOpts of generateStablecoinOptions()) {
+      yield { kind: 'Stablecoin', ...kindOpts };
+    }
+  }
 }
 
 interface GeneratedContract {

package/src/generate/stablecoin.ts

@@ -0,0 +1,23 @@
+import { limitationsOptions, type StablecoinOptions } from '../stablecoin';
+import { accessOptions } from '../set-access-control';
+import { infoOptions } from '../set-info';
+import { generateAlternatives } from './alternatives';
+
+const booleans = [true, false];
+
+const blueprint = {
+  name: ['MyStablecoin'],
+  symbol: ['MST'],
+  burnable: booleans,
+  pausable: booleans,
+  upgradeable: booleans,
+  mintable: booleans,
+  premint: ['1'],
+  access: accessOptions,
+  limitations: limitationsOptions,
+  info: infoOptions,
+};
+
+export function* generateStablecoinOptions(): Generator<Required<StablecoinOptions>> {
+  yield* generateAlternatives(blueprint);
+}

package/src/index.ts

@@ -23,6 +23,8 @@ export { contractsVersion, contractsVersionTag, compatibleContractsSemver } from
 
 export { fungible } from './api';
 export { nonFungible } from './api';
+export { stablecoin } from './api';
 
 export type { FungibleOptions } from './fungible';
 export type { NonFungibleOptions } from './non-fungible';
+export type { StablecoinOptions } from './stablecoin';

package/src/kind.ts

@@ -16,6 +16,7 @@ function isKind<T>(value: Kind | T): value is Kind {
   switch (value) {
     case 'Fungible':
     case 'NonFungible':
+    case 'Stablecoin':
       return true;
 
     default: {

package/src/non-fungible.ts

@@ -57,6 +57,10 @@ function withDefaults(opts: NonFungibleOptions): Required<NonFungibleOptions> {
   };
 }
 
+export function isAccessControlRequired(opts: Partial<NonFungibleOptions>): boolean {
+  return opts.mintable === true || opts.pausable === true || opts.upgradeable === true || opts.consecutive === true;
+}
+
 export function buildNonFungible(opts: NonFungibleOptions): Contract {
   const c = new ContractBuilder(opts.name);
 
@@ -117,50 +121,42 @@ export function buildNonFungible(opts: NonFungibleOptions): Contract {
 
 function addBase(c: ContractBuilder, name: string, symbol: string, pausable: boolean) {
   // Set metadata
-  c.addConstructorCode(
-    `Base::set_metadata(e, String::from_str(e, "www.mytoken.com"), String::from_str(e, "${name}"), String::from_str(e, "${symbol}"));`,
-  );
+  c.addConstructorCode('let uri = String::from_str(e, "www.mytoken.com");');
+  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);`);
 
   // Set token functions
-  c.addUseClause('stellar_non_fungible', 'Base');
-  c.addUseClause('stellar_non_fungible', 'NonFungibleToken');
+  c.addUseClause('stellar_tokens::non_fungible', 'Base');
+  c.addUseClause('stellar_tokens::non_fungible', 'NonFungibleToken');
+  c.addUseClause('stellar_macros', 'default_impl');
   c.addUseClause('soroban_sdk', 'contract');
   c.addUseClause('soroban_sdk', 'contractimpl');
-  c.addUseClause('soroban_sdk', 'Address');
   c.addUseClause('soroban_sdk', 'String');
   c.addUseClause('soroban_sdk', 'Env');
 
   const nonFungibleTokenTrait = {
     traitName: 'NonFungibleToken',
     structName: c.name,
-    tags: ['contractimpl'],
+    tags: ['default_impl', 'contractimpl'],
     assocType: 'type ContractType = Base;',
   };
 
-  // all the below may be eliminated by introducing `defaultimpl` macro at `tags` above,
-  // but we lose the customization for `pausable`, and so on...
-  c.addTraitFunction(nonFungibleTokenTrait, baseFunctions.owner_of);
-  c.addTraitFunction(nonFungibleTokenTrait, baseFunctions.transfer);
-  c.addTraitFunction(nonFungibleTokenTrait, baseFunctions.transfer_from);
-  c.addTraitFunction(nonFungibleTokenTrait, baseFunctions.balance);
-  c.addTraitFunction(nonFungibleTokenTrait, baseFunctions.approve);
-  c.addTraitFunction(nonFungibleTokenTrait, baseFunctions.approve_for_all);
-  c.addTraitFunction(nonFungibleTokenTrait, baseFunctions.get_approved);
-  c.addTraitFunction(nonFungibleTokenTrait, baseFunctions.is_approved_for_all);
-  c.addTraitFunction(nonFungibleTokenTrait, baseFunctions.name);
-  c.addTraitFunction(nonFungibleTokenTrait, baseFunctions.symbol);
-  c.addTraitFunction(nonFungibleTokenTrait, baseFunctions.token_uri);
+  c.addTraitImplBlock(nonFungibleTokenTrait);
 
   if (pausable) {
-    c.addUseClause('stellar_pausable_macros', 'when_not_paused');
+    c.addUseClause('stellar_macros', 'when_not_paused');
+
+    c.addTraitFunction(nonFungibleTokenTrait, baseFunctions.transfer);
     c.addFunctionTag(baseFunctions.transfer, 'when_not_paused', nonFungibleTokenTrait);
+
     c.addFunctionTag(baseFunctions.transfer_from, 'when_not_paused', nonFungibleTokenTrait);
+    c.addTraitFunction(nonFungibleTokenTrait, baseFunctions.transfer_from);
   }
 }
 
 function addBurnable(c: ContractBuilder, pausable: boolean) {
-  c.addUseClause('stellar_non_fungible', 'burnable::NonFungibleBurnable');
-  c.addUseClause('soroban_sdk', 'Address');
+  c.addUseClause('stellar_tokens::non_fungible', 'burnable::NonFungibleBurnable');
 
   const nonFungibleBurnableTrait = {
     traitName: 'NonFungibleBurnable',
@@ -169,20 +165,24 @@ function addBurnable(c: ContractBuilder, pausable: boolean) {
     section: 'Extensions',
   };
 
-  c.addTraitFunction(nonFungibleBurnableTrait, burnableFunctions.burn);
-  c.addTraitFunction(nonFungibleBurnableTrait, burnableFunctions.burn_from);
-
   if (pausable) {
-    c.addUseClause('stellar_pausable_macros', 'when_not_paused');
+    c.addUseClause('stellar_macros', 'when_not_paused');
+
+    c.addTraitFunction(nonFungibleBurnableTrait, burnableFunctions.burn);
     c.addFunctionTag(burnableFunctions.burn, 'when_not_paused', nonFungibleBurnableTrait);
+
+    c.addTraitFunction(nonFungibleBurnableTrait, burnableFunctions.burn_from);
     c.addFunctionTag(burnableFunctions.burn_from, 'when_not_paused', nonFungibleBurnableTrait);
+  } else {
+    // prepend '#[default_impl]'
+    nonFungibleBurnableTrait.tags.unshift('default_impl');
+    c.addTraitImplBlock(nonFungibleBurnableTrait);
   }
 }
 
 function addEnumerable(c: ContractBuilder) {
-  c.addUseClause('stellar_non_fungible', 'enumerable::{NonFungibleEnumerable, Enumerable}');
-  c.addUseClause('stellar_default_impl_macro', 'default_impl');
-  c.addUseClause('stellar_non_fungible', 'ContractOverrides');
+  c.addUseClause('stellar_tokens::non_fungible', 'enumerable::{NonFungibleEnumerable, Enumerable}');
+  c.addUseClause('stellar_macros', 'default_impl');
 
   const nonFungibleEnumerableTrait = {
     traitName: 'NonFungibleEnumerable',
@@ -193,23 +193,11 @@ function addEnumerable(c: ContractBuilder) {
   c.addTraitImplBlock(nonFungibleEnumerableTrait);
 
   c.overrideAssocType('NonFungibleToken', 'type ContractType = Enumerable;');
-
-  // Below is not required due to `defaultimpl` macro. If we require to customize the functions,
-  // then we should:
-  // 1. get rid of the `defaultimpl` macro form `tags` above,
-  // 2. get rid of `c.addImplementedTrait(nonFungibleEnumerableTrait);` line,
-  // 3. uncomment the section below:
-  // 4. uncomment `get_owner_token_id` and `get_token_id` from `enumerableFunctions` definition
-  /*
-  c.addFunction(nonFungibleEnumerableTrait, enumerableFunctions.total_supply);
-  c.addFunction(nonFungibleEnumerableTrait, enumerableFunctions.get_owner_token_id);
-  c.addFunction(nonFungibleEnumerableTrait, enumerableFunctions.get_token_id);
-  */
 }
 
 function addConsecutive(c: ContractBuilder, pausable: boolean, access: Access) {
-  c.addUseClause('stellar_non_fungible', 'consecutive::{NonFungibleConsecutive, Consecutive}');
-  c.addUseClause('stellar_non_fungible', 'ContractOverrides');
+  c.addUseClause('stellar_tokens::non_fungible', 'consecutive::{NonFungibleConsecutive, Consecutive}');
+  c.addUseClause('soroban_sdk', 'Address');
 
   const nonFungibleConsecutiveTrait = {
     traitName: 'NonFungibleConsecutive',
@@ -222,48 +210,49 @@ function addConsecutive(c: ContractBuilder, pausable: boolean, access: Access) {
 
   c.overrideAssocType('NonFungibleToken', 'type ContractType = Consecutive;');
 
-  c.addFreeFunction(consecutiveFunctions.batch_mint);
+  const mintFn = access === 'ownable' ? consecutiveFunctions.batch_mint : consecutiveFunctions.batch_mint_with_caller;
+  c.addFreeFunction(mintFn);
   if (pausable) {
-    c.addFunctionTag(consecutiveFunctions.batch_mint, 'when_not_paused');
+    c.addFunctionTag(mintFn, 'when_not_paused');
   }
 
-  requireAccessControl(c, undefined, consecutiveFunctions.batch_mint, access);
+  requireAccessControl(c, undefined, mintFn, access, {
+    useMacro: true,
+    role: 'minter',
+    caller: 'caller',
+  });
 }
 
 function addMintable(c: ContractBuilder, enumerable: boolean, pausable: boolean, sequential: boolean, access: Access) {
-  if (!enumerable) {
+  c.addUseClause('soroban_sdk', 'Address');
+  const accessProps = { useMacro: true, role: 'minter', caller: 'caller' };
+
+  let mintFn;
+
+  if (enumerable) {
     if (sequential) {
-      c.addUseClause('stellar_non_fungible', 'Base::sequential_mint');
-      c.addFreeFunction(baseFunctions.sequential_mint);
-      requireAccessControl(c, undefined, baseFunctions.sequential_mint, access);
-      if (pausable) {
-        c.addFunctionTag(baseFunctions.sequential_mint, 'when_not_paused');
-      }
+      mintFn =
+        access === 'ownable' ? enumerableFunctions.sequential_mint : enumerableFunctions.sequential_mint_with_caller;
     } else {
-      c.addUseClause('stellar_non_fungible', 'Base::mint');
-      c.addFreeFunction(baseFunctions.mint);
-      requireAccessControl(c, undefined, baseFunctions.mint, access);
-      if (pausable) {
-        c.addFunctionTag(baseFunctions.mint, 'when_not_paused');
-      }
+      mintFn =
+        access === 'ownable'
+          ? enumerableFunctions.non_sequential_mint
+          : enumerableFunctions.non_sequential_mint_with_caller;
     }
-  }
-
-  if (enumerable) {
+  } else {
     if (sequential) {
-      c.addFreeFunction(enumerableFunctions.sequential_mint);
-      requireAccessControl(c, undefined, enumerableFunctions.sequential_mint, access);
-      if (pausable) {
-        c.addFunctionTag(enumerableFunctions.sequential_mint, 'when_not_paused');
-      }
+      mintFn = access === 'ownable' ? baseFunctions.sequential_mint : baseFunctions.sequential_mint_with_caller;
     } else {
-      c.addFreeFunction(enumerableFunctions.non_sequential_mint);
-      requireAccessControl(c, undefined, enumerableFunctions.non_sequential_mint, access);
-      if (pausable) {
-        c.addFunctionTag(enumerableFunctions.non_sequential_mint, 'when_not_paused');
-      }
+      mintFn = access === 'ownable' ? baseFunctions.mint : baseFunctions.mint_with_caller;
     }
   }
+
+  c.addFreeFunction(mintFn);
+  requireAccessControl(c, undefined, mintFn, access, accessProps);
+
+  if (pausable) {
+    c.addFunctionTag(mintFn, 'when_not_paused');
+  }
 }
 
 const baseFunctions = defineFunctions({
@@ -347,10 +336,26 @@ const baseFunctions = defineFunctions({
     args: [getSelfArg(), { name: 'to', type: 'Address' }, { name: 'token_id', type: 'u32' }],
     code: ['Base::mint(e, &to, token_id);'],
   },
+  mint_with_caller: {
+    name: 'mint',
+    args: [
+      getSelfArg(),
+      { name: 'to', type: 'Address' },
+      { name: 'token_id', type: 'u32' },
+      { name: 'caller', type: 'Address' },
+    ],
+    code: ['Base::mint(e, &to, token_id);'],
+  },
   sequential_mint: {
+    name: 'mint',
     args: [getSelfArg(), { name: 'to', type: 'Address' }],
     code: ['Base::sequential_mint(e, &to);'],
   },
+  sequential_mint_with_caller: {
+    name: 'mint',
+    args: [getSelfArg(), { name: 'to', type: 'Address' }, { name: 'caller', type: 'Address' }],
+    code: ['Base::sequential_mint(e, &to);'],
+  },
 });
 
 const burnableFunctions = defineFunctions({
@@ -375,33 +380,49 @@ const enumerableFunctions = defineFunctions({
     returns: 'u32',
     code: ['non_fungible::enumerable::Enumerable::total_supply(e)'],
   },
-  // These are not currently used, see addEnumerable() above
-  /*
-  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',
     args: [getSelfArg(), { name: 'to', type: 'Address' }, { name: 'token_id', type: 'u32' }],
-    code: ['Enumerable::non_sequential_mint(e, &to, token_id);'], // TODO: unify `mint` name in Stellar-Contracts across extensions
+    code: ['Enumerable::non_sequential_mint(e, &to, token_id);'],
+  },
+  non_sequential_mint_with_caller: {
+    name: 'mint',
+    args: [
+      getSelfArg(),
+      { name: 'to', type: 'Address' },
+      { name: 'token_id', type: 'u32' },
+      { name: 'caller', type: 'Address' },
+    ],
+    code: ['Enumerable::non_sequential_mint(e, &to, token_id);'],
   },
   sequential_mint: {
+    name: 'mint',
     args: [getSelfArg(), { name: 'to', type: 'Address' }],
     code: ['Enumerable::sequential_mint(e, &to);'],
   },
+  sequential_mint_with_caller: {
+    name: 'mint',
+    args: [getSelfArg(), { name: 'to', type: 'Address' }, { name: 'caller', type: 'Address' }],
+    code: ['Enumerable::sequential_mint(e, &to);'],
+  },
 });
 
 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);'],
   },
+  batch_mint_with_caller: {
+    name: 'batch_mint',
+    args: [
+      getSelfArg(),
+      { name: 'to', type: 'Address' },
+      { name: 'amount', type: 'u32' },
+      { name: 'caller', type: 'Address' },
+    ],
+    returns: 'u32',
+    code: ['Consecutive::batch_mint(e, &to, amount);'],
+  },
 });