@openzeppelin/wizard-stellar 0.4.5 → 0.6.0

package/src/fungible.ts

@@ -17,6 +17,7 @@ export const defaults: Required<FungibleOptions> = {
   name: 'MyToken',
   symbol: 'MTK',
   burnable: false,
+  votes: false,
   pausable: false,
   upgradeable: false,
   premint: '0',
@@ -34,6 +35,7 @@ export interface FungibleOptions extends CommonContractOptions {
   name: string;
   symbol: string;
   burnable?: boolean;
+  votes?: boolean;
   pausable?: boolean;
   upgradeable?: boolean;
   premint?: string;
@@ -45,6 +47,7 @@ export function withDefaults(opts: FungibleOptions): Required<FungibleOptions> {
     ...opts,
     ...withCommonContractDefaults(opts),
     burnable: opts.burnable ?? defaults.burnable,
+    votes: opts.votes ?? defaults.votes,
     pausable: opts.pausable ?? defaults.pausable,
     upgradeable: opts.upgradeable ?? defaults.upgradeable,
     premint: opts.premint || defaults.premint,
@@ -61,10 +64,17 @@ export function buildFungible(opts: FungibleOptions): ContractBuilder {
 
   const allOpts = withDefaults(opts);
 
-  addBase(c, toByteArray(allOpts.name), toByteArray(allOpts.symbol), allOpts.pausable, allOpts.explicitImplementations);
+  addBase(
+    c,
+    toByteArray(allOpts.name),
+    toByteArray(allOpts.symbol),
+    allOpts.votes,
+    allOpts.pausable,
+    allOpts.explicitImplementations,
+  );
 
   if (allOpts.premint) {
-    addPremint(c, allOpts.premint);
+    addPremint(c, allOpts.premint, allOpts.votes);
   }
 
   if (allOpts.pausable) {
@@ -76,11 +86,11 @@ export function buildFungible(opts: FungibleOptions): ContractBuilder {
   }
 
   if (allOpts.burnable) {
-    addBurnable(c, allOpts.pausable, allOpts.explicitImplementations);
+    addBurnable(c, allOpts.votes, allOpts.pausable, allOpts.explicitImplementations);
   }
 
   if (allOpts.mintable) {
-    addMintable(c, allOpts.access, allOpts.pausable, allOpts.explicitImplementations);
+    addMintable(c, allOpts.access, allOpts.votes, allOpts.pausable, allOpts.explicitImplementations);
   }
 
   setAccessControl(c, allOpts.access, allOpts.explicitImplementations);
@@ -93,29 +103,35 @@ function addBase(
   c: ContractBuilder,
   name: string,
   symbol: string,
+  votes: boolean,
   pausable: boolean,
   explicitImplementations: boolean,
 ) {
   // Set metadata
-  c.addConstructorCode(`Base::set_metadata(e, 18, String::from_str(e, "${name}"), String::from_str(e, "${symbol}"));`);
+  c.addConstructorCode(`Base::set_metadata(e, 7, 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');
-  if (!explicitImplementations) c.addUseClause('stellar_macros', 'default_impl');
+  if (votes) {
+    c.addUseClause('stellar_tokens::fungible', 'ContractOverrides');
+    c.addUseClause('stellar_governance::votes', 'Votes');
+    c.addUseClause('stellar_tokens::fungible', 'votes::FungibleVotes');
+  }
   c.addUseClause('soroban_sdk', 'contract');
   c.addUseClause('soroban_sdk', 'contractimpl');
   c.addUseClause('soroban_sdk', 'String');
+  c.addUseClause('soroban_sdk', 'Symbol');
   c.addUseClause('soroban_sdk', 'Env');
-  if (explicitImplementations || pausable) {
-    c.addUseClause('soroban_sdk', 'Address');
-  }
+  c.addUseClause('soroban_sdk', 'Address');
+  c.addUseClause('soroban_sdk', 'MuxedAddress');
+  c.addUseClause('soroban_sdk', 'Vec');
 
   const fungibleTokenTrait = {
     traitName: 'FungibleToken',
     structName: c.name,
-    tags: explicitImplementations ? ['contractimpl'] : ['default_impl', 'contractimpl'],
-    assocType: 'type ContractType = Base;',
+    tags: explicitImplementations ? ['contractimpl'] : ['contractimpl(contracttrait)'],
+    assocType: `type ContractType = ${votes ? 'FungibleVotes' : 'Base'};`,
   };
 
   c.addTraitImplBlock(fungibleTokenTrait);
@@ -131,30 +147,47 @@ function addBase(
     c.addTraitFunction(fungibleTokenTrait, functions.transfer_from);
     c.addFunctionTag(functions.transfer_from, 'when_not_paused', fungibleTokenTrait);
   }
+
+  if (votes) {
+    c.addTraitImplBlock({
+      traitName: 'Votes',
+      structName: c.name,
+      tags: explicitImplementations ? ['contractimpl'] : ['contractimpl(contracttrait)'],
+      section: 'Extensions',
+    });
+  }
 }
 
-function addMintable(c: ContractBuilder, access: Access, pausable: boolean, explicitImplementations: boolean) {
-  c.addUseClause('soroban_sdk', 'Address');
+function addMintable(
+  c: ContractBuilder,
+  access: Access,
+  votes: boolean,
+  pausable: boolean,
+  explicitImplementations: boolean,
+) {
+  const mintFn = votes ? votesFunctions.mint : functions.mint;
+  const mintWithCallerFn = votes ? votesFunctions.mint_with_caller : functions.mint_with_caller;
+
   switch (access) {
     case false:
       break;
     case 'ownable': {
-      c.addFreeFunction(functions.mint);
+      c.addFreeFunction(mintFn);
 
-      requireAccessControl(c, undefined, functions.mint, access, undefined, explicitImplementations);
+      requireAccessControl(c, undefined, mintFn, access, undefined, explicitImplementations);
 
       if (pausable) {
-        c.addFunctionTag(functions.mint, 'when_not_paused');
+        c.addFunctionTag(mintFn, 'when_not_paused');
       }
       break;
     }
     case 'roles': {
-      c.addFreeFunction(functions.mint_with_caller);
+      c.addFreeFunction(mintWithCallerFn);
 
       requireAccessControl(
         c,
         undefined,
-        functions.mint_with_caller,
+        mintWithCallerFn,
         access,
         {
           useMacro: true,
@@ -165,7 +198,7 @@ function addMintable(c: ContractBuilder, access: Access, pausable: boolean, expl
       );
 
       if (pausable) {
-        c.addFunctionTag(functions.mint_with_caller, 'when_not_paused');
+        c.addFunctionTag(mintWithCallerFn, 'when_not_paused');
       }
       break;
     }
@@ -176,36 +209,39 @@ function addMintable(c: ContractBuilder, access: Access, pausable: boolean, expl
   }
 }
 
-function addBurnable(c: ContractBuilder, pausable: boolean, explicitImplementations: boolean) {
+function addBurnable(c: ContractBuilder, votes: boolean, pausable: boolean, explicitImplementations: boolean) {
   c.addUseClause('stellar_tokens::fungible', 'burnable::FungibleBurnable');
-  c.addUseClause('soroban_sdk', 'Address');
 
   const fungibleBurnableTrait = {
     traitName: 'FungibleBurnable',
     structName: c.name,
-    tags: ['contractimpl'],
+    tags: explicitImplementations ? ['contractimpl'] : ['contractimpl(contracttrait)'],
     section: 'Extensions',
   };
 
-  if (pausable) {
-    c.addUseClause('stellar_macros', 'when_not_paused');
+  const burnFn = votes ? votesFunctions.burn : functions.burn;
+  const burnFromFn = votes ? votesFunctions.burn_from : functions.burn_from;
 
-    c.addTraitFunction(fungibleBurnableTrait, functions.burn);
-    c.addFunctionTag(functions.burn, 'when_not_paused', fungibleBurnableTrait);
+  if (pausable || votes || explicitImplementations) {
+    if (pausable) {
+      c.addUseClause('stellar_macros', 'when_not_paused');
+    }
+
+    c.addTraitFunction(fungibleBurnableTrait, burnFn);
+    c.addTraitFunction(fungibleBurnableTrait, burnFromFn);
 
-    c.addTraitFunction(fungibleBurnableTrait, functions.burn_from);
-    c.addFunctionTag(functions.burn_from, 'when_not_paused', fungibleBurnableTrait);
-  } else if (explicitImplementations) c.addTraitForEachFunctions(fungibleBurnableTrait, fungibleBurnableFunctions);
-  else {
-    // prepend '#[default_impl]'
-    fungibleBurnableTrait.tags.unshift('default_impl');
+    if (pausable) {
+      c.addFunctionTag(burnFn, 'when_not_paused', fungibleBurnableTrait);
+      c.addFunctionTag(burnFromFn, 'when_not_paused', fungibleBurnableTrait);
+    }
+  } else {
     c.addTraitImplBlock(fungibleBurnableTrait);
   }
 }
 
 export const premintPattern = /^(\d*\.?\d*)$/;
 
-function addPremint(c: ContractBuilder, amount: string) {
+function addPremint(c: ContractBuilder, amount: string, votes: boolean) {
   if (amount !== undefined && amount !== '0') {
     if (!premintPattern.test(amount)) {
       throw new OptionsError({
@@ -214,12 +250,10 @@ function addPremint(c: ContractBuilder, amount: string) {
     }
 
     // TODO: handle signed int?
-    const premintAbsolute = toUint(getInitialSupply(amount, 18), 'premint', 'u128');
-
-    c.addUseClause('soroban_sdk', 'Address');
+    const premintAbsolute = toUint(getInitialSupply(amount, 7), 'premint', 'u128');
 
     c.addConstructorArgument({ name: 'recipient', type: 'Address' });
-    c.addConstructorCode(`Base::mint(e, &recipient, ${premintAbsolute});`);
+    c.addConstructorCode(`${votes ? 'FungibleVotes' : 'Base'}::mint(e, &recipient, ${premintAbsolute});`);
   }
 }
 
@@ -285,7 +319,7 @@ export const functions = defineFunctions({
     args: [
       getSelfArg(),
       { name: 'from', type: 'Address' },
-      { name: 'to', type: 'Address' },
+      { name: 'to', type: 'MuxedAddress' },
       { name: 'amount', type: 'i128' },
     ],
     code: ['Self::ContractType::transfer(e, &from, &to, amount)'],
@@ -356,6 +390,36 @@ export const functions = defineFunctions({
   },
 });
 
+const votesFunctions = defineFunctions({
+  burn: {
+    args: [getSelfArg(), { name: 'from', type: 'Address' }, { name: 'amount', type: 'i128' }],
+    code: ['FungibleVotes::burn(e, &from, amount)'],
+  },
+  burn_from: {
+    args: [
+      getSelfArg(),
+      { name: 'spender', type: 'Address' },
+      { name: 'from', type: 'Address' },
+      { name: 'amount', type: 'i128' },
+    ],
+    code: ['FungibleVotes::burn_from(e, &spender, &from, amount)'],
+  },
+  mint: {
+    args: [getSelfArg(), { name: 'account', type: 'Address' }, { name: 'amount', type: 'i128' }],
+    code: ['FungibleVotes::mint(e, &account, amount);'],
+  },
+  mint_with_caller: {
+    name: 'mint',
+    args: [
+      getSelfArg(),
+      { name: 'account', type: 'Address' },
+      { name: 'amount', type: 'i128' },
+      { name: 'caller', type: 'Address' },
+    ],
+    code: ['FungibleVotes::mint(e, &account, amount);'],
+  },
+});
+
 const fungibleTokenTraitFunctions = pickKeys(functions, [
   'total_supply',
   'balance',
@@ -367,5 +431,3 @@ const fungibleTokenTraitFunctions = pickKeys(functions, [
   'name',
   'symbol',
 ]);
-
-const fungibleBurnableFunctions = pickKeys(functions, ['burn', 'burn_from']);

package/src/generate/fungible.ts

@@ -9,6 +9,7 @@ const blueprint = {
   name: ['MyToken'],
   symbol: ['MTK'],
   burnable: booleans,
+  votes: booleans,
   pausable: booleans,
   upgradeable: booleans,
   mintable: booleans,

package/src/generate/governor.ts

@@ -0,0 +1,24 @@
+import type { GovernorOptions } from '../governor';
+import { accessOptions } from '../set-access-control';
+import { infoOptions } from '../set-info';
+import { generateAlternatives } from './alternatives';
+
+const booleans = [true, false];
+
+const blueprint = {
+  name: ['MyGovernor'],
+  version: ['1.0.0'],
+  votingDelay: ['10'],
+  votingPeriod: ['100'],
+  proposalThreshold: ['100'],
+  quorum: ['500'],
+  upgradeable: booleans,
+  timelock: booleans,
+  access: accessOptions,
+  info: infoOptions,
+  explicitImplementations: booleans,
+};
+
+export function* generateGovernorOptions(): Generator<Required<GovernorOptions>> {
+  yield* generateAlternatives(blueprint);
+}

package/src/generate/non-fungible.ts

@@ -10,6 +10,7 @@ const blueprint = {
   symbol: ['MTK'],
   tokenUri: ['https://www.mytoken.com'],
   burnable: booleans,
+  votes: booleans,
   pausable: booleans,
   upgradeable: booleans,
   enumerable: booleans,

package/src/generate/sources.ts

@@ -3,6 +3,7 @@ import path from 'path';
 import crypto from 'crypto';
 
 import { generateFungibleOptions } from './fungible';
+import { generateGovernorOptions } from './governor';
 import { generateNonFungibleOptions } from './non-fungible';
 import { generateStablecoinOptions } from './stablecoin';
 import type { GenericOptions, KindedOptions } from '../build-generic';
@@ -20,6 +21,12 @@ export function* generateOptions(kind?: Kind): Generator<GenericOptions> {
     }
   }
 
+  if (!kind || kind === 'Governor') {
+    for (const kindOpts of generateGovernorOptions()) {
+      yield { kind: 'Governor', ...kindOpts };
+    }
+  }
+
   if (!kind || kind === 'NonFungible') {
     for (const kindOpts of generateNonFungibleOptions()) {
       yield { kind: 'NonFungible', ...kindOpts };

package/src/generate/stablecoin.ts

@@ -9,6 +9,7 @@ const blueprint = {
   name: ['MyStablecoin'],
   symbol: ['MST'],
   burnable: booleans,
+  votes: booleans,
   pausable: booleans,
   upgradeable: booleans,
   mintable: booleans,