@openzeppelin/wizard-stellar 0.1.1 → 0.2.0

package/src/fungible.ts

@@ -3,6 +3,7 @@ import { ContractBuilder } from './contract';
 import type { Access } from './set-access-control';
 import { requireAccessControl, setAccessControl } from './set-access-control';
 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';
@@ -17,6 +18,7 @@ export const defaults: Required<FungibleOptions> = {
   symbol: 'MTK',
   burnable: false,
   pausable: false,
+  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
@@ -32,6 +34,7 @@ export interface FungibleOptions extends CommonContractOptions {
   symbol: string;
   burnable?: boolean;
   pausable?: boolean;
+  upgradeable?: boolean;
   premint?: string;
   mintable?: boolean;
 }
@@ -42,6 +45,7 @@ function withDefaults(opts: FungibleOptions): Required<FungibleOptions> {
     ...withCommonContractDefaults(opts),
     burnable: opts.burnable ?? defaults.burnable,
     pausable: opts.pausable ?? defaults.pausable,
+    upgradeable: opts.upgradeable ?? defaults.upgradeable,
     premint: opts.premint || defaults.premint,
     mintable: opts.mintable ?? defaults.mintable,
   };
@@ -62,6 +66,10 @@ export function buildFungible(opts: FungibleOptions): Contract {
     addPausable(c, allOpts.access);
   }
 
+  if (allOpts.upgradeable) {
+    addUpgradeable(c, allOpts.access);
+  }
+
   if (allOpts.burnable) {
     addBurnable(c, allOpts.pausable);
   }
@@ -83,8 +91,8 @@ function addBase(c: ContractBuilder, name: string, symbol: string, pausable: boo
   );
 
   // Set token functions
-  c.addUseClause('openzeppelin_fungible_token', 'self', { alias: 'fungible' });
-  c.addUseClause('openzeppelin_fungible_token', 'FungibleToken');
+  c.addUseClause('stellar_fungible', 'self', { alias: 'fungible' });
+  c.addUseClause('stellar_fungible', 'FungibleToken');
   c.addUseClause('soroban_sdk', 'contract');
   c.addUseClause('soroban_sdk', 'contractimpl');
   c.addUseClause('soroban_sdk', 'Address');
@@ -93,46 +101,46 @@ function addBase(c: ContractBuilder, name: string, symbol: string, pausable: boo
   c.addUseClause('soroban_sdk', 'Symbol');
 
   const fungibleTokenTrait = {
-    name: 'FungibleToken',
-    for: c.name,
+    traitName: 'FungibleToken',
+    structName: c.name,
     tags: ['contractimpl'],
   };
 
-  c.addFunction(fungibleTokenTrait, functions.total_supply);
-  c.addFunction(fungibleTokenTrait, functions.balance);
-  c.addFunction(fungibleTokenTrait, functions.allowance);
-  c.addFunction(fungibleTokenTrait, functions.transfer);
-  c.addFunction(fungibleTokenTrait, functions.transfer_from);
-  c.addFunction(fungibleTokenTrait, functions.approve);
-  c.addFunction(fungibleTokenTrait, functions.decimals);
-  c.addFunction(fungibleTokenTrait, functions.name);
-  c.addFunction(fungibleTokenTrait, functions.symbol);
+  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);
 
   if (pausable) {
-    c.addUseClause('openzeppelin_pausable_macros', 'when_not_paused');
-    c.addFunctionTag(fungibleTokenTrait, functions.transfer, 'when_not_paused');
-    c.addFunctionTag(fungibleTokenTrait, functions.transfer_from, 'when_not_paused');
+    c.addUseClause('stellar_pausable_macros', 'when_not_paused');
+    c.addFunctionTag(functions.transfer, 'when_not_paused', fungibleTokenTrait);
+    c.addFunctionTag(functions.transfer_from, 'when_not_paused', fungibleTokenTrait);
   }
 }
 
 function addBurnable(c: ContractBuilder, pausable: boolean) {
-  c.addUseClause('openzeppelin_fungible_token', 'burnable::FungibleBurnable');
+  c.addUseClause('stellar_fungible', 'burnable::FungibleBurnable');
   c.addUseClause('soroban_sdk', 'Address');
 
   const fungibleBurnableTrait = {
-    name: 'FungibleBurnable',
-    for: c.name,
+    traitName: 'FungibleBurnable',
+    structName: c.name,
     tags: ['contractimpl'],
     section: 'Extensions',
   };
 
-  c.addFunction(fungibleBurnableTrait, functions.burn);
-  c.addFunction(fungibleBurnableTrait, functions.burn_from);
+  c.addTraitFunction(fungibleBurnableTrait, functions.burn);
+  c.addTraitFunction(fungibleBurnableTrait, functions.burn_from);
 
   if (pausable) {
-    c.addUseClause('openzeppelin_pausable_macros', 'when_not_paused');
-    c.addFunctionTag(fungibleBurnableTrait, functions.burn, 'when_not_paused');
-    c.addFunctionTag(fungibleBurnableTrait, functions.burn_from, 'when_not_paused');
+    c.addUseClause('stellar_pausable_macros', 'when_not_paused');
+    c.addFunctionTag(functions.burn, 'when_not_paused', fungibleBurnableTrait);
+    c.addFunctionTag(functions.burn_from, 'when_not_paused', fungibleBurnableTrait);
   }
 }
 
@@ -149,7 +157,7 @@ function addPremint(c: ContractBuilder, amount: string) {
     // TODO: handle signed int?
     const premintAbsolute = toUint(getInitialSupply(amount, 18), 'premint', 'u128');
 
-    c.addUseClause('openzeppelin_fungible_token', 'mintable::FungibleMintable');
+    c.addUseClause('stellar_fungible', 'mintable::FungibleMintable');
     c.addUseClause('soroban_sdk', 'Address');
 
     c.addConstructorArgument({ name: 'recipient', type: 'Address' });
@@ -199,21 +207,21 @@ export function getInitialSupply(premint: string, decimals: number): string {
 }
 
 function addMintable(c: ContractBuilder, access: Access, pausable: boolean) {
-  c.addUseClause('openzeppelin_fungible_token', 'mintable::FungibleMintable');
+  c.addUseClause('stellar_fungible', 'mintable::FungibleMintable');
 
   const fungibleMintableTrait = {
-    name: 'FungibleMintable',
-    for: c.name,
+    traitName: 'FungibleMintable',
+    structName: c.name,
     tags: ['contractimpl'],
     section: 'Extensions',
   };
 
-  c.addFunction(fungibleMintableTrait, functions.mint);
+  c.addTraitFunction(fungibleMintableTrait, functions.mint);
 
   requireAccessControl(c, fungibleMintableTrait, functions.mint, access);
 
   if (pausable) {
-    c.addFunctionTag(fungibleMintableTrait, functions.mint, 'when_not_paused');
+    c.addFunctionTag(functions.mint, 'when_not_paused', fungibleMintableTrait);
   }
 }
 

package/src/generate/fungible.ts

@@ -10,6 +10,7 @@ const blueprint = {
   symbol: ['MTK'],
   burnable: booleans,
   pausable: booleans,
+  upgradeable: booleans,
   mintable: booleans,
   premint: ['1'],
   access: accessOptions,

package/src/generate/non-fungible.ts

@@ -0,0 +1,24 @@
+import type { NonFungibleOptions } from '../non-fungible';
+import { accessOptions } from '../set-access-control';
+import { infoOptions } from '../set-info';
+import { generateAlternatives } from './alternatives';
+
+const booleans = [true, false];
+
+const blueprint = {
+  name: ['MyToken'],
+  symbol: ['MTK'],
+  burnable: booleans,
+  pausable: booleans,
+  upgradeable: booleans,
+  enumerable: booleans,
+  consecutive: booleans,
+  sequential: booleans,
+  mintable: booleans,
+  access: accessOptions,
+  info: infoOptions,
+};
+
+export function* generateNonFungibleOptions(): Generator<Required<NonFungibleOptions>> {
+  yield* generateAlternatives(blueprint);
+}

package/src/generate/sources.ts

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

package/src/index.ts

@@ -22,3 +22,4 @@ export { sanitizeKind } from './kind';
 export { contractsVersion, contractsVersionTag, compatibleContractsSemver } from './utils/version';
 
 export { fungible } from './api';
+export { nonFungible } from './api';

package/src/kind.ts

@@ -4,7 +4,7 @@ export type Kind = GenericOptions['kind'];
 
 export function sanitizeKind(kind: unknown): Kind {
   if (typeof kind === 'string') {
-    const sanitized = kind.replace(/^(ERC|.)/i, c => c.toUpperCase());
+    const sanitized = kind.replace(/^(ERC|.)/i, c => c.toUpperCase()).replace(/^(NonFungible)$/i, 'NonFungible');
     if (isKind(sanitized)) {
       return sanitized;
     }
@@ -15,6 +15,7 @@ export function sanitizeKind(kind: unknown): Kind {
 function isKind<T>(value: Kind | T): value is Kind {
   switch (value) {
     case 'Fungible':
+    case 'NonFungible':
       return true;
 
     default: {

package/src/non-fungible.ts

@@ -0,0 +1,410 @@
+import type { Contract } from './contract';
+import { ContractBuilder } from './contract';
+import { type Access, requireAccessControl, setAccessControl } from './set-access-control';
+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 type { OptionsErrorMessages } from './error';
+import { OptionsError } from './error';
+import { contractDefaults as commonDefaults } from './common-options';
+import { printContract } from './print';
+import { toByteArray } from './utils/convert-strings';
+
+export const defaults: Required<NonFungibleOptions> = {
+  name: 'MyToken',
+  symbol: 'MTK',
+  burnable: false,
+  enumerable: false,
+  consecutive: false,
+  pausable: false,
+  upgradeable: false,
+  mintable: false,
+  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,
+} as const;
+
+export function printNonFungible(opts: NonFungibleOptions = defaults): string {
+  return printContract(buildNonFungible(opts));
+}
+
+export interface NonFungibleOptions extends CommonContractOptions {
+  name: string;
+  symbol: string;
+  burnable?: boolean;
+  enumerable?: boolean;
+  consecutive?: boolean;
+  pausable?: boolean;
+  upgradeable?: boolean;
+  mintable?: boolean;
+  sequential?: boolean;
+}
+
+function withDefaults(opts: NonFungibleOptions): Required<NonFungibleOptions> {
+  return {
+    ...opts,
+    ...withCommonContractDefaults(opts),
+    burnable: opts.burnable ?? defaults.burnable,
+    consecutive: opts.consecutive ?? defaults.consecutive,
+    enumerable: opts.enumerable ?? defaults.enumerable,
+    pausable: opts.pausable ?? defaults.pausable,
+    upgradeable: opts.upgradeable ?? defaults.upgradeable,
+    mintable: opts.mintable ?? defaults.mintable,
+    sequential: opts.sequential ?? defaults.sequential,
+  };
+}
+
+export function buildNonFungible(opts: NonFungibleOptions): Contract {
+  const c = new ContractBuilder(opts.name);
+
+  const allOpts = withDefaults(opts);
+
+  const errors: OptionsErrorMessages = {};
+
+  if (allOpts.enumerable && allOpts.consecutive) {
+    errors.enumerable = 'Enumerable cannot be used with Consecutive extension';
+    errors.consecutive = 'Consecutive cannot be used with Enumerable extension';
+  }
+
+  if (allOpts.consecutive && allOpts.mintable) {
+    errors.consecutive = 'Consecutive cannot be used with Mintable extension';
+    errors.mintable = 'Mintable cannot be used with Consecutive extension';
+  }
+
+  if (allOpts.consecutive && allOpts.sequential) {
+    errors.consecutive = 'Consecutive cannot be used with Sequential minting';
+    errors.sequential = 'Sequential minting cannot be used with Consecutive extension';
+  }
+
+  if (Object.keys(errors).length > 0) {
+    throw new OptionsError(errors);
+  }
+
+  addBase(c, toByteArray(allOpts.name), toByteArray(allOpts.symbol), allOpts.pausable);
+
+  if (allOpts.pausable) {
+    addPausable(c, allOpts.access);
+  }
+
+  if (allOpts.upgradeable) {
+    addUpgradeable(c, allOpts.access);
+  }
+
+  if (allOpts.burnable) {
+    addBurnable(c, allOpts.pausable);
+  }
+
+  if (allOpts.enumerable) {
+    addEnumerable(c, allOpts.burnable);
+  }
+
+  if (allOpts.consecutive) {
+    addConsecutive(c, allOpts.pausable, allOpts.access);
+  }
+
+  if (allOpts.mintable) {
+    addMintable(c, allOpts.enumerable, allOpts.pausable, allOpts.sequential, allOpts.access);
+  }
+
+  setAccessControl(c, allOpts.access);
+  setInfo(c, allOpts.info);
+
+  return c;
+}
+
+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}"));`,
+  );
+
+  // Set token functions
+  c.addUseClause('stellar_non_fungible', 'Base');
+  c.addUseClause('stellar_non_fungible', 'NonFungibleToken');
+  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'],
+    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);
+
+  if (pausable) {
+    c.addUseClause('stellar_pausable_macros', 'when_not_paused');
+    c.addFunctionTag(baseFunctions.transfer, 'when_not_paused', nonFungibleTokenTrait);
+    c.addFunctionTag(baseFunctions.transfer_from, 'when_not_paused', nonFungibleTokenTrait);
+  }
+}
+
+function addBurnable(c: ContractBuilder, pausable: boolean) {
+  c.addUseClause('stellar_non_fungible', 'burnable::NonFungibleBurnable');
+  c.addUseClause('soroban_sdk', 'Address');
+
+  const nonFungibleBurnableTrait = {
+    traitName: 'NonFungibleBurnable',
+    structName: c.name,
+    tags: ['contractimpl'],
+    section: 'Extensions',
+  };
+
+  c.addTraitFunction(nonFungibleBurnableTrait, burnableFunctions.burn);
+  c.addTraitFunction(nonFungibleBurnableTrait, burnableFunctions.burn_from);
+
+  if (pausable) {
+    c.addUseClause('stellar_pausable_macros', 'when_not_paused');
+    c.addFunctionTag(burnableFunctions.burn, 'when_not_paused', nonFungibleBurnableTrait);
+    c.addFunctionTag(burnableFunctions.burn_from, 'when_not_paused', nonFungibleBurnableTrait);
+  }
+}
+
+function addEnumerable(c: ContractBuilder, burnable: boolean) {
+  c.addUseClause('stellar_non_fungible', 'enumerable::{NonFungibleEnumerable, Enumerable}');
+  //c.addUseClause('stellar_default_impl_macro', 'default_impl');
+
+  const nonFungibleEnumerableTrait = {
+    traitName: 'NonFungibleEnumerable',
+    structName: c.name,
+    tags: ['defaultimpl', 'contractimpl'],
+    section: 'Extensions',
+  };
+  c.addTraitImplBlock(nonFungibleEnumerableTrait);
+
+  c.overrideAssocType('NonFungibleToken', 'type ContractType = Enumerable;');
+
+  if (burnable) {
+    c.overrideAssocType('NonFungibleBurnable', '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');
+
+  const nonFungibleConsecutiveTrait = {
+    traitName: 'NonFungibleConsecutive',
+    structName: c.name,
+    tags: ['contractimpl'],
+    section: 'Extensions',
+  };
+
+  c.addTraitImplBlock(nonFungibleConsecutiveTrait);
+
+  c.overrideAssocType('NonFungibleToken', 'type ContractType = Consecutive;');
+
+  c.addFreeFunction(consecutiveFunctions.batch_mint);
+  if (pausable) {
+    c.addFunctionTag(consecutiveFunctions.batch_mint, 'when_not_paused');
+  }
+
+  requireAccessControl(c, undefined, consecutiveFunctions.batch_mint, access);
+}
+
+function addMintable(c: ContractBuilder, enumerable: boolean, pausable: boolean, sequential: boolean, access: Access) {
+  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');
+      }
+    } 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');
+      }
+    }
+  }
+
+  if (enumerable) {
+    if (sequential) {
+      c.addFreeFunction(enumerableFunctions.sequential_mint);
+      requireAccessControl(c, undefined, enumerableFunctions.sequential_mint, access);
+      if (pausable) {
+        c.addFunctionTag(enumerableFunctions.sequential_mint, 'when_not_paused');
+      }
+    } 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');
+      }
+    }
+  }
+}
+
+const baseFunctions = defineFunctions({
+  // NonFungible Trait
+  balance: {
+    args: [getSelfArg(), { name: 'owner', type: 'Address' }],
+    returns: 'u32',
+    code: ['Self::ContractType::balance(e, &owner)'],
+  },
+  owner_of: {
+    args: [getSelfArg(), { name: 'token_id', type: 'u32' }],
+    returns: 'Address',
+    code: ['Self::ContractType::owner_of(e, token_id)'],
+  },
+  transfer: {
+    args: [
+      getSelfArg(),
+      { name: 'from', type: 'Address' },
+      { name: 'to', type: 'Address' },
+      { name: 'token_id', type: 'u32' },
+    ],
+    code: ['Self::ContractType::transfer(e, &from, &to, token_id);'],
+  },
+  transfer_from: {
+    args: [
+      getSelfArg(),
+      { name: 'spender', type: 'Address' },
+      { name: 'from', type: 'Address' },
+      { name: 'to', type: 'Address' },
+      { name: 'token_id', type: 'u32' },
+    ],
+    code: ['Self::ContractType::transfer_from(e, &spender, &from, &to, token_id);'],
+  },
+  approve: {
+    args: [
+      getSelfArg(),
+      { name: 'approver', type: 'Address' },
+      { name: 'approved', type: 'Address' },
+      { name: 'token_id', type: 'u32' },
+      { name: 'live_until_ledger', type: 'u32' },
+    ],
+    code: ['Self::ContractType::approve(e, &approver, &approved, token_id, live_until_ledger)'],
+  },
+  approve_for_all: {
+    args: [
+      getSelfArg(),
+      { name: 'owner', type: 'Address' },
+      { name: 'operator', type: 'Address' },
+      { name: 'live_until_ledger', type: 'u32' },
+    ],
+    code: ['Self::ContractType::approve_for_all(e, &owner, &operator, live_until_ledger)'],
+  },
+  get_approved: {
+    args: [getSelfArg(), { name: 'token_id', type: 'u32' }],
+    returns: 'Option<Address>',
+    code: ['Self::ContractType::get_approved(e, token_id)'],
+  },
+  is_approved_for_all: {
+    args: [getSelfArg(), { name: 'owner', type: 'Address' }, { name: 'operator', type: 'Address' }],
+    returns: 'bool',
+    code: ['Self::ContractType::is_approved_for_all(e, &owner, &operator)'],
+  },
+  name: {
+    args: [getSelfArg()],
+    returns: 'String',
+    code: ['Self::ContractType::name(e)'],
+  },
+  symbol: {
+    args: [getSelfArg()],
+    returns: 'String',
+    code: ['Self::ContractType::symbol(e)'],
+  },
+  token_uri: {
+    args: [getSelfArg(), { name: 'token_id', type: 'u32' }],
+    returns: 'String',
+    code: ['Self::ContractType::token_uri(e, token_id)'],
+  },
+
+  // Mint
+  mint: {
+    args: [getSelfArg(), { name: 'to', type: 'Address' }, { name: 'token_id', type: 'u32' }],
+    code: ['Base::mint(e, &to, token_id);'],
+  },
+  sequential_mint: {
+    args: [getSelfArg(), { name: 'to', type: 'Address' }],
+    code: ['Base::sequential_mint(e, &to);'],
+  },
+});
+
+const burnableFunctions = defineFunctions({
+  burn: {
+    args: [getSelfArg(), { name: 'from', type: 'Address' }, { name: 'token_id', type: 'u32' }],
+    code: ['Self::ContractType::burn(e, &from, token_id)'],
+  },
+  burn_from: {
+    args: [
+      getSelfArg(),
+      { name: 'spender', type: 'Address' },
+      { name: 'from', type: 'Address' },
+      { name: 'token_id', type: 'u32' },
+    ],
+    code: ['Self::ContractType::burn_from(e, &spender, &from, token_id)'],
+  },
+});
+
+const enumerableFunctions = defineFunctions({
+  total_supply: {
+    args: [getSelfArg()],
+    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: {
+    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
+  },
+  sequential_mint: {
+    args: [getSelfArg(), { name: 'to', type: 'Address' }],
+    code: ['Enumerable::sequential_mint(e, &to);'],
+  },
+});
+
+const consecutiveFunctions = defineFunctions({
+  batch_mint: {
+    args: [getSelfArg(), { name: 'to', type: 'Address' }, { name: 'amount', type: 'u32' }],
+    returns: 'u32',
+    code: ['Consecutive::batch_mint(e, &to, amount);'],
+  },
+});