@openzeppelin/wizard-stellar 0.5.0 → 0.6.1

package/src/governor.ts

@@ -0,0 +1,425 @@
+import type { CommonContractOptions } from './common-options';
+import { contractDefaults as commonDefaults, getSelfArg, withCommonContractDefaults } from './common-options';
+import { ContractBuilder } from './contract';
+import { printContract } from './print';
+import { setAccessControl } from './set-access-control';
+import { addUpgradeable } from './add-upgradeable';
+import { setInfo } from './set-info';
+import { toByteArray, toUint } from './utils/convert-strings';
+import { defineFunctions } from './utils/define-functions';
+
+export const defaults: Required<GovernorOptions> = {
+  name: 'MyGovernor',
+  version: '1.0.0',
+  votingDelay: '17000',
+  votingPeriod: '120000',
+  proposalThreshold: '100',
+  quorum: '500',
+  upgradeable: false,
+  timelock: false,
+  access: commonDefaults.access,
+  info: commonDefaults.info,
+  explicitImplementations: commonDefaults.explicitImplementations,
+} as const;
+
+export function printGovernor(opts: GovernorOptions = defaults): string {
+  return printContract(buildGovernor(opts));
+}
+
+export interface GovernorOptions extends CommonContractOptions {
+  name: string;
+  version?: string;
+  votingDelay?: string;
+  votingPeriod?: string;
+  proposalThreshold?: string;
+  quorum?: string;
+  upgradeable?: boolean;
+  timelock?: boolean;
+}
+
+export function isAccessControlRequired(opts: Partial<GovernorOptions>): boolean {
+  return opts.upgradeable === true;
+}
+
+function withDefaults(opts: GovernorOptions): Required<GovernorOptions> {
+  return {
+    ...opts,
+    ...withCommonContractDefaults(opts),
+    version: opts.version ?? defaults.version,
+    votingDelay: opts.votingDelay ?? defaults.votingDelay,
+    votingPeriod: opts.votingPeriod ?? defaults.votingPeriod,
+    proposalThreshold: opts.proposalThreshold ?? defaults.proposalThreshold,
+    quorum: opts.quorum ?? defaults.quorum,
+    upgradeable: opts.upgradeable ?? defaults.upgradeable,
+    timelock: opts.timelock ?? defaults.timelock,
+  };
+}
+
+export function buildGovernor(opts: GovernorOptions): ContractBuilder {
+  const allOpts = withDefaults(opts);
+  const c = new ContractBuilder(allOpts.name);
+
+  addBase(
+    c,
+    toByteArray(allOpts.name),
+    toByteArray(allOpts.version),
+    toUint(allOpts.votingDelay, 'votingDelay', 'u32'),
+    toUint(allOpts.votingPeriod, 'votingPeriod', 'u32'),
+    toUint(allOpts.proposalThreshold, 'proposalThreshold', 'u128'),
+    toUint(allOpts.quorum, 'quorum', 'u128'),
+    allOpts.timelock,
+    allOpts.explicitImplementations,
+  );
+
+  if (allOpts.upgradeable) {
+    addUpgradeable(c, allOpts.access, allOpts.explicitImplementations);
+  }
+
+  setAccessControl(c, allOpts.access, allOpts.explicitImplementations);
+  setInfo(c, allOpts.info);
+
+  return c;
+}
+
+function addBase(
+  c: ContractBuilder,
+  name: string,
+  version: string,
+  votingDelay: bigint,
+  votingPeriod: bigint,
+  proposalThreshold: bigint,
+  quorum: bigint,
+  timelock: boolean,
+  explicitImplementations: boolean,
+) {
+  c.addUseClause('stellar_governance::governor', 'Governor');
+  c.addUseClause('stellar_governance::governor', 'ProposalState');
+  c.addUseClause('stellar_governance::governor', 'self', { alias: 'governor' });
+  c.addUseClause('soroban_sdk', 'contract');
+  c.addUseClause('soroban_sdk', 'contractimpl');
+  c.addUseClause('soroban_sdk', 'Address');
+  c.addUseClause('soroban_sdk', 'BytesN');
+  c.addUseClause('soroban_sdk', 'Env');
+  c.addUseClause('soroban_sdk', 'String');
+  c.addUseClause('soroban_sdk', 'Symbol');
+  c.addUseClause('soroban_sdk', 'Val');
+  c.addUseClause('soroban_sdk', 'Vec');
+
+  c.addConstructorArgument({ name: 'token_contract', type: 'Address' });
+  c.addConstructorCode(`governor::set_name(e, String::from_str(e, "${name}"));`);
+  c.addConstructorCode(`governor::set_version(e, String::from_str(e, "${version}"));`);
+  c.addConstructorCode(`governor::set_voting_delay(e, ${votingDelay});`);
+  c.addConstructorCode(`governor::set_voting_period(e, ${votingPeriod});`);
+  c.addConstructorCode(`governor::set_proposal_threshold(e, ${proposalThreshold});`);
+  c.addConstructorCode(`governor::set_quorum(e, ${quorum});`);
+  c.addConstructorCode('governor::set_token_contract(e, &token_contract);');
+
+  const governorTrait = {
+    traitName: 'Governor',
+    structName: c.name,
+    tags: explicitImplementations ? ['contractimpl'] : ['contractimpl(contracttrait)'],
+  };
+
+  // Custom impls must be added before the defaults so the deduplication keeps
+  // the custom version when a default-method override exists (e.g. timelock's
+  // `proposals_need_queuing`/`queue` overriding the trait defaults).
+  if (timelock) {
+    addTimelock(c, governorTrait);
+  } else {
+    c.addTraitFunction(governorTrait, functions.execute);
+    c.addTraitFunction(governorTrait, functions.cancel);
+  }
+
+  if (explicitImplementations) {
+    c.addTraitForEachFunctions(governorTrait, governorTraitDefaultFunctions);
+  }
+}
+
+function addTimelock(c: ContractBuilder, governorTrait: { traitName: string; structName: string; tags: string[] }) {
+  c.addUseClause('soroban_sdk', 'contracttype');
+  c.addUseClause('soroban_sdk', 'IntoVal');
+  c.addUseClause('stellar_governance::timelock', 'TimelockClient');
+
+  c.addTopLevelDeclaration([
+    '#[contracttype]',
+    'enum GovernorTimelockKey {',
+    '    Timelock,',
+    '    OperationID(BytesN<32>),',
+    '}',
+  ]);
+
+  c.addConstructorArgument({ name: 'timelock_contract', type: 'Address' });
+  c.addConstructorCode('e.storage().instance().set(&GovernorTimelockKey::Timelock, &timelock_contract);');
+
+  c.addFreeFunction(timelockFreeFunctions.timelock);
+
+  c.addTraitFunction(governorTrait, timelockFunctions.proposals_need_queuing);
+  c.addTraitFunction(governorTrait, timelockFunctions.queue);
+  c.addTraitFunction(governorTrait, timelockFunctions.execute);
+  c.addTraitFunction(governorTrait, timelockFunctions.cancel);
+}
+
+const functions = defineFunctions({
+  execute: {
+    args: [
+      getSelfArg(),
+      { name: 'targets', type: 'Vec<Address>' },
+      { name: 'functions', type: 'Vec<Symbol>' },
+      { name: 'args', type: 'Vec<Vec<Val>>' },
+      { name: 'description_hash', type: 'BytesN<32>' },
+      { name: 'executor', type: 'Address' },
+    ],
+    returns: 'BytesN<32>',
+    code: [
+      'executor.require_auth()',
+      'let proposal_id = governor::hash_proposal(e, &targets, &functions, &args, &description_hash)',
+      'let snapshot = governor::get_proposal_snapshot(e, &proposal_id)',
+      'let quorum = Self::quorum(e, snapshot)',
+      'governor::execute(e, targets, functions, args, &description_hash, Self::proposals_need_queuing(e), quorum)',
+    ],
+  },
+  cancel: {
+    args: [
+      getSelfArg(),
+      { name: 'targets', type: 'Vec<Address>' },
+      { name: 'functions', type: 'Vec<Symbol>' },
+      { name: 'args', type: 'Vec<Vec<Val>>' },
+      { name: 'description_hash', type: 'BytesN<32>' },
+      { name: 'operator', type: 'Address' },
+    ],
+    returns: 'BytesN<32>',
+    code: [
+      'let proposal_id = governor::hash_proposal(e, &targets, &functions, &args, &description_hash)',
+      'let proposer = governor::get_proposal_proposer(e, &proposal_id)',
+      'assert!(operator == proposer)',
+      'operator.require_auth()',
+      'governor::cancel(e, targets, functions, args, &description_hash)',
+    ],
+  },
+});
+
+const timelockFreeFunctions = defineFunctions({
+  timelock: {
+    args: [getSelfArg()],
+    returns: 'Address',
+    code: ['e.storage().instance().get(&GovernorTimelockKey::Timelock).expect("timelock not set")'],
+  },
+});
+
+const timelockFunctions = defineFunctions({
+  proposals_need_queuing: {
+    args: [{ name: '_e', type: '&Env' }],
+    returns: 'bool',
+    code: ['true'],
+  },
+  queue: {
+    args: [
+      getSelfArg(),
+      { name: 'targets', type: 'Vec<Address>' },
+      { name: 'functions', type: 'Vec<Symbol>' },
+      { name: 'args', type: 'Vec<Vec<Val>>' },
+      { name: 'description_hash', type: 'BytesN<32>' },
+      { name: 'eta', type: 'u32' },
+      { name: '_operator', type: 'Address' },
+    ],
+    returns: 'BytesN<32>',
+    code: [
+      'let proposal_id = governor::hash_proposal(e, &targets, &functions, &args, &description_hash)',
+      'let snapshot = governor::get_proposal_snapshot(e, &proposal_id)',
+      'let quorum = Self::quorum(e, snapshot)',
+      'let proposal_id = governor::queue(e, targets.clone(), functions.clone(), args.clone(), &description_hash, eta, quorum)',
+      'let timelock = Self::timelock(e)',
+      'let delay = eta.saturating_sub(e.ledger().sequence())',
+      'let execute_args: Vec<Val> = (targets, functions, args, description_hash.clone(), timelock.clone()).into_val(e)',
+      'let timelock_client = TimelockClient::new(e, &timelock)',
+      'let zero_predecessor = BytesN::from_array(e, &[0u8; 32])',
+      'let op_id = timelock_client.schedule(&e.current_contract_address(), &Symbol::new(e, "execute"), &execute_args, &zero_predecessor, &description_hash, &delay, &e.current_contract_address())',
+      'e.storage().persistent().set(&GovernorTimelockKey::OperationID(proposal_id.clone()), &op_id);',
+      'proposal_id',
+    ],
+  },
+  execute: {
+    args: [
+      getSelfArg(),
+      { name: 'targets', type: 'Vec<Address>' },
+      { name: 'functions', type: 'Vec<Symbol>' },
+      { name: 'args', type: 'Vec<Vec<Val>>' },
+      { name: 'description_hash', type: 'BytesN<32>' },
+      { name: 'executor', type: 'Address' },
+    ],
+    returns: 'BytesN<32>',
+    code: [
+      'let timelock = Self::timelock(e)',
+      'assert!(executor == timelock)',
+      'executor.require_auth()',
+      'let proposal_id = governor::hash_proposal(e, &targets, &functions, &args, &description_hash)',
+      'let snapshot = governor::get_proposal_snapshot(e, &proposal_id)',
+      'let quorum = Self::quorum(e, snapshot)',
+      'governor::execute(e, targets, functions, args, &description_hash, Self::proposals_need_queuing(e), quorum)',
+    ],
+  },
+  cancel: {
+    args: [
+      getSelfArg(),
+      { name: 'targets', type: 'Vec<Address>' },
+      { name: 'functions', type: 'Vec<Symbol>' },
+      { name: 'args', type: 'Vec<Vec<Val>>' },
+      { name: 'description_hash', type: 'BytesN<32>' },
+      { name: 'operator', type: 'Address' },
+    ],
+    returns: 'BytesN<32>',
+    code: [
+      'let proposal_id = governor::hash_proposal(e, &targets, &functions, &args, &description_hash)',
+      'let proposer = governor::get_proposal_proposer(e, &proposal_id)',
+      'assert!(operator == proposer)',
+      'operator.require_auth()',
+      'if let Some(op_id) = e.storage().persistent().get::<_, BytesN<32>>(&GovernorTimelockKey::OperationID(proposal_id)) {',
+      '    let timelock = Self::timelock(e);',
+      '    let timelock_client = TimelockClient::new(e, &timelock);',
+      '    timelock_client.cancel(&op_id, &e.current_contract_address());',
+      '}',
+      'governor::cancel(e, targets, functions, args, &description_hash)',
+    ],
+  },
+});
+
+// Explicit-trait variants for every default method on the `Governor` trait.
+// When `explicitImplementations` is enabled, these are emitted as overrides
+// that mirror the upstream defaults — letting users see and customize each
+// method directly. Order matches the trait definition for readability.
+const governorTraitDefaultFunctions = defineFunctions({
+  name: {
+    args: [getSelfArg()],
+    returns: 'String',
+    code: ['governor::get_name(e)'],
+  },
+  version: {
+    args: [getSelfArg()],
+    returns: 'String',
+    code: ['governor::get_version(e)'],
+  },
+  voting_delay: {
+    args: [getSelfArg()],
+    returns: 'u32',
+    code: ['governor::get_voting_delay(e)'],
+  },
+  voting_period: {
+    args: [getSelfArg()],
+    returns: 'u32',
+    code: ['governor::get_voting_period(e)'],
+  },
+  proposal_threshold: {
+    args: [getSelfArg()],
+    returns: 'u128',
+    code: ['governor::get_proposal_threshold(e)'],
+  },
+  get_token_contract: {
+    args: [getSelfArg()],
+    returns: 'Address',
+    code: ['governor::get_token_contract(e)'],
+  },
+  counting_mode: {
+    args: [getSelfArg()],
+    returns: 'Symbol',
+    code: ['governor::counting_mode(e)'],
+  },
+  has_voted: {
+    args: [getSelfArg(), { name: 'proposal_id', type: 'BytesN<32>' }, { name: 'account', type: 'Address' }],
+    returns: 'bool',
+    code: ['governor::has_voted(e, &proposal_id, &account)'],
+  },
+  quorum: {
+    args: [getSelfArg(), { name: 'ledger', type: 'u32' }],
+    returns: 'u128',
+    code: ['governor::get_quorum(e, ledger)'],
+  },
+  proposal_state: {
+    args: [getSelfArg(), { name: 'proposal_id', type: 'BytesN<32>' }],
+    returns: 'ProposalState',
+    code: [
+      'let snapshot = governor::get_proposal_snapshot(e, &proposal_id)',
+      'let quorum = Self::quorum(e, snapshot)',
+      'governor::get_proposal_state(e, &proposal_id, quorum)',
+    ],
+  },
+  proposal_snapshot: {
+    args: [getSelfArg(), { name: 'proposal_id', type: 'BytesN<32>' }],
+    returns: 'u32',
+    code: ['governor::get_proposal_snapshot(e, &proposal_id)'],
+  },
+  proposal_deadline: {
+    args: [getSelfArg(), { name: 'proposal_id', type: 'BytesN<32>' }],
+    returns: 'u32',
+    code: ['governor::get_proposal_deadline(e, &proposal_id)'],
+  },
+  proposal_proposer: {
+    args: [getSelfArg(), { name: 'proposal_id', type: 'BytesN<32>' }],
+    returns: 'Address',
+    code: ['governor::get_proposal_proposer(e, &proposal_id)'],
+  },
+  get_proposal_id: {
+    args: [
+      getSelfArg(),
+      { name: 'targets', type: 'Vec<Address>' },
+      { name: 'functions', type: 'Vec<Symbol>' },
+      { name: 'args', type: 'Vec<Vec<Val>>' },
+      { name: 'description_hash', type: 'BytesN<32>' },
+    ],
+    returns: 'BytesN<32>',
+    code: ['governor::hash_proposal(e, &targets, &functions, &args, &description_hash)'],
+  },
+  propose: {
+    args: [
+      getSelfArg(),
+      { name: 'targets', type: 'Vec<Address>' },
+      { name: 'functions', type: 'Vec<Symbol>' },
+      { name: 'args', type: 'Vec<Vec<Val>>' },
+      { name: 'description', type: 'String' },
+      { name: 'proposer', type: 'Address' },
+    ],
+    returns: 'BytesN<32>',
+    code: ['proposer.require_auth()', 'governor::propose(e, targets, functions, args, description, &proposer)'],
+  },
+  cast_vote: {
+    args: [
+      getSelfArg(),
+      { name: 'proposal_id', type: 'BytesN<32>' },
+      { name: 'vote_type', type: 'u32' },
+      { name: 'reason', type: 'String' },
+      { name: 'voter', type: 'Address' },
+    ],
+    returns: 'u128',
+    code: [
+      'voter.require_auth()',
+      'let snapshot = governor::get_proposal_snapshot(e, &proposal_id)',
+      'let quorum = Self::quorum(e, snapshot)',
+      'governor::cast_vote(e, &proposal_id, vote_type, &reason, &voter, quorum)',
+    ],
+  },
+  queue: {
+    args: [
+      getSelfArg(),
+      { name: 'targets', type: 'Vec<Address>' },
+      { name: 'functions', type: 'Vec<Symbol>' },
+      { name: 'args', type: 'Vec<Vec<Val>>' },
+      { name: 'description_hash', type: 'BytesN<32>' },
+      { name: 'eta', type: 'u32' },
+      { name: '_operator', type: 'Address' },
+    ],
+    returns: 'BytesN<32>',
+    code: [
+      'if !Self::proposals_need_queuing(e) {',
+      '    soroban_sdk::panic_with_error!(e, governor::GovernorError::QueueNotEnabled);',
+      '}',
+      'let proposal_id = governor::hash_proposal(e, &targets, &functions, &args, &description_hash)',
+      'let snapshot = governor::get_proposal_snapshot(e, &proposal_id)',
+      'let quorum = Self::quorum(e, snapshot)',
+      'governor::queue(e, targets, functions, args, &description_hash, eta, quorum)',
+    ],
+  },
+  proposals_need_queuing: {
+    args: [{ name: '_e', type: '&Env' }],
+    returns: 'bool',
+    code: ['false'],
+  },
+});

package/src/index.ts

@@ -22,9 +22,11 @@ export { sanitizeKind } from './kind';
 export { contractsVersion, contractsVersionTag, compatibleContractsSemver } from './utils/version';
 
 export { fungible } from './api';
+export { governor } from './api';
 export { nonFungible } from './api';
 export { stablecoin } from './api';
 
 export type { FungibleOptions } from './fungible';
+export type { GovernorOptions } from './governor';
 export type { NonFungibleOptions } from './non-fungible';
 export type { StablecoinOptions } from './stablecoin';

package/src/kind.ts

@@ -15,6 +15,7 @@ export function sanitizeKind(kind: unknown): Kind {
 function isKind<T>(value: Kind | T): value is Kind {
   switch (value) {
     case 'Fungible':
+    case 'Governor':
     case 'NonFungible':
     case 'Stablecoin':
       return true;

package/src/non-fungible.ts

@@ -18,6 +18,7 @@ export const defaults: Required<NonFungibleOptions> = {
   symbol: 'MTK',
   tokenUri: 'https://www.mytoken.com',
   burnable: false,
+  votes: false,
   enumerable: false,
   consecutive: false,
   pausable: false,
@@ -38,6 +39,7 @@ export interface NonFungibleOptions extends CommonContractOptions {
   symbol: string;
   tokenUri?: string;
   burnable?: boolean;
+  votes?: boolean;
   enumerable?: boolean;
   consecutive?: boolean;
   pausable?: boolean;
@@ -52,6 +54,7 @@ function withDefaults(opts: NonFungibleOptions): Required<NonFungibleOptions> {
     ...withCommonContractDefaults(opts),
     tokenUri: opts.tokenUri ?? defaults.tokenUri,
     burnable: opts.burnable ?? defaults.burnable,
+    votes: opts.votes ?? defaults.votes,
     consecutive: opts.consecutive ?? defaults.consecutive,
     enumerable: opts.enumerable ?? defaults.enumerable,
     pausable: opts.pausable ?? defaults.pausable,
@@ -87,6 +90,16 @@ export function buildNonFungible(opts: NonFungibleOptions): Contract {
     errors.sequential = 'Sequential minting cannot be used with Consecutive extension';
   }
 
+  if (allOpts.votes && allOpts.enumerable) {
+    errors.votes = 'Votes extension cannot be used with Enumerable extension';
+    errors.enumerable = 'Enumerable extension cannot be used with Votes extension';
+  }
+
+  if (allOpts.votes && allOpts.consecutive) {
+    errors.votes = 'Votes extension cannot be used with Consecutive extension';
+    errors.consecutive = 'Consecutive extension cannot be used with Votes extension';
+  }
+
   if (Object.keys(errors).length > 0) {
     throw new OptionsError(errors);
   }
@@ -96,6 +109,7 @@ export function buildNonFungible(opts: NonFungibleOptions): Contract {
     toByteArray(allOpts.name),
     toByteArray(allOpts.symbol),
     toByteArray(allOpts.tokenUri),
+    allOpts.votes,
     allOpts.pausable,
     allOpts.explicitImplementations,
   );
@@ -124,6 +138,7 @@ export function buildNonFungible(opts: NonFungibleOptions): Contract {
     addMintable(
       c,
       allOpts.enumerable,
+      allOpts.votes,
       allOpts.pausable,
       allOpts.sequential,
       allOpts.access,
@@ -142,6 +157,7 @@ function addBase(
   name: string,
   symbol: string,
   tokenUri: string,
+  votes: boolean,
   pausable: boolean,
   explicitImplementations: boolean,
 ) {
@@ -154,6 +170,10 @@ function addBase(
   // Set token functions
   c.addUseClause('stellar_tokens::non_fungible', 'Base');
   c.addUseClause('stellar_tokens::non_fungible', 'NonFungibleToken');
+  if (votes) {
+    c.addUseClause('stellar_governance::votes', 'Votes');
+    c.addUseClause('stellar_tokens::non_fungible', 'votes::NonFungibleVotes');
+  }
   if (explicitImplementations) c.addUseClause('stellar_tokens::non_fungible', 'ContractOverrides');
   c.addUseClause('soroban_sdk', 'contract');
   c.addUseClause('soroban_sdk', 'contractimpl');
@@ -165,7 +185,7 @@ function addBase(
     traitName: 'NonFungibleToken',
     structName: c.name,
     tags: explicitImplementations ? ['contractimpl'] : ['contractimpl(contracttrait)'],
-    assocType: 'type ContractType = Base;',
+    assocType: `type ContractType = ${votes ? 'NonFungibleVotes' : 'Base'};`,
   };
 
   c.addTraitImplBlock(nonFungibleTokenTrait);
@@ -181,6 +201,15 @@ function addBase(
     c.addFunctionTag(baseFunctions.transfer_from, 'when_not_paused', nonFungibleTokenTrait);
     c.addTraitFunction(nonFungibleTokenTrait, baseFunctions.transfer_from);
   }
+
+  if (votes) {
+    c.addTraitImplBlock({
+      traitName: 'Votes',
+      structName: c.name,
+      tags: explicitImplementations ? ['contractimpl'] : ['contractimpl(contracttrait)'],
+      section: 'Extensions',
+    });
+  }
 }
 
 function addBurnable(c: ContractBuilder, pausable: boolean, explicitImplementations: boolean) {
@@ -263,6 +292,7 @@ function addConsecutive(c: ContractBuilder, pausable: boolean, access: Access, e
 function addMintable(
   c: ContractBuilder,
   enumerable: boolean,
+  votes: boolean,
   pausable: boolean,
   sequential: boolean,
   access: Access,
@@ -288,9 +318,22 @@ function addMintable(
   } else {
     if (sequential) {
       mintFn =
-        effectiveAccess === 'ownable' ? baseFunctions.sequential_mint : baseFunctions.sequential_mint_with_caller;
+        effectiveAccess === 'ownable'
+          ? votes
+            ? votesMintFunctions.sequential_mint
+            : baseFunctions.sequential_mint
+          : votes
+            ? votesMintFunctions.sequential_mint_with_caller
+            : baseFunctions.sequential_mint_with_caller;
     } else {
-      mintFn = effectiveAccess === 'ownable' ? baseFunctions.mint : baseFunctions.mint_with_caller;
+      mintFn =
+        effectiveAccess === 'ownable'
+          ? votes
+            ? votesMintFunctions.mint
+            : baseFunctions.mint
+          : votes
+            ? votesMintFunctions.mint_with_caller
+            : baseFunctions.mint_with_caller;
     }
   }
 
@@ -405,6 +448,33 @@ const baseFunctions = defineFunctions({
   },
 });
 
+const votesMintFunctions = defineFunctions({
+  mint: {
+    args: [getSelfArg(), { name: 'to', type: 'Address' }, { name: 'token_id', type: 'u32' }],
+    code: ['NonFungibleVotes::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: ['NonFungibleVotes::mint(e, &to, token_id);'],
+  },
+  sequential_mint: {
+    name: 'mint',
+    args: [getSelfArg(), { name: 'to', type: 'Address' }],
+    code: ['NonFungibleVotes::sequential_mint(e, &to);'],
+  },
+  sequential_mint_with_caller: {
+    name: 'mint',
+    args: [getSelfArg(), { name: 'to', type: 'Address' }, { name: 'caller', type: 'Address' }],
+    code: ['NonFungibleVotes::sequential_mint(e, &to);'],
+  },
+});
+
 const nonFungibleTokenTraitFunctions = pickKeys(baseFunctions, [
   'balance',
   'owner_of',

package/src/print.ts

@@ -4,7 +4,6 @@ import type { Lines } from './utils/format-lines';
 import { formatLines, spaceBetween } from './utils/format-lines';
 import { getSelfArg } from './common-options';
 import { compatibleContractsSemver } from './utils/version';
-import { toByteArray } from './utils/convert-strings';
 
 const DEFAULT_SECTION = '1. with no section';
 const STANDALONE_IMPORTS_GROUP = 'Standalone Imports';
@@ -31,6 +30,7 @@ export function printContract(contract: Contract): string {
         printUseClauses(contract),
         printMetadata(contract),
         printVariables(contract),
+        printTopLevelDeclarations(contract),
         printContractStruct(contract),
         printContractErrors(contract),
         printContractFunctions(contract),
@@ -364,6 +364,11 @@ function printArgument(arg: Argument): string {
   }
 }
 
+function printTopLevelDeclarations(contract: Contract): Lines[] {
+  if (contract.topLevelDeclarations.length === 0) return [];
+  return spaceBetween(...contract.topLevelDeclarations);
+}
+
 function printDocumentations(documentations: string[]): string[] {
   return documentations.map(documentation => `//! ${documentation}`);
 }

package/src/stablecoin.ts

@@ -11,6 +11,7 @@ import {
 import { printContract } from './print';
 import { requireAccessControl, type Access } from './set-access-control';
 import { defineFunctions } from './utils/define-functions';
+import { OptionsError } from './error';
 
 export const defaults: Required<StablecoinOptions> = {
   ...fungibleDefaults,
@@ -46,6 +47,13 @@ export function isAccessControlRequired(opts: Partial<StablecoinOptions>): boole
 export function buildStablecoin(opts: StablecoinOptions): Contract {
   const allOpts = withDefaults(opts);
 
+  if (allOpts.votes && allOpts.limitations) {
+    throw new OptionsError({
+      votes: 'Votes extension cannot be used with stablecoin limitations',
+      limitations: 'Stablecoin limitations cannot be used with Votes extension',
+    });
+  }
+
   const c = buildFungible(allOpts);
 
   if (allOpts.limitations) {

package/src/test.ts

@@ -17,6 +17,10 @@ test.serial('fungible result generated', async t => {
   await testGenerate(t, 'Fungible');
 });
 
+test.serial('governor result generated', async t => {
+  await testGenerate(t, 'Governor');
+});
+
 test.serial('non-fungible result generated', async t => {
   await testGenerate(t, 'NonFungible');
 });