@openzeppelin/wizard-stellar 0.4.5 → 0.6.0

package/src/set-access-control.ts

@@ -29,7 +29,7 @@ export function setAccessControl(c: ContractBuilder, access: Access, explicitImp
         const ownableTrait = {
           traitName: 'Ownable',
           structName: c.name,
-          tags: explicitImplementations ? ['contractimpl'] : ['default_impl', 'contractimpl'],
+          tags: explicitImplementations ? ['contractimpl'] : ['contractimpl(contracttrait)'],
           section: 'Utils',
         };
         if (explicitImplementations) {
@@ -51,7 +51,7 @@ export function setAccessControl(c: ContractBuilder, access: Access, explicitImp
       const accessControlTrait = {
         traitName: 'AccessControl',
         structName: c.name,
-        tags: explicitImplementations ? ['contractimpl'] : ['default_impl', 'contractimpl'],
+        tags: explicitImplementations ? ['contractimpl'] : ['contractimpl(contracttrait)'],
         section: 'Utils',
       };
       if (explicitImplementations) {
@@ -105,8 +105,9 @@ export function requireAccessControl(
 
       if (caller && role) {
         c.addUseClause('soroban_sdk', 'Symbol');
+        c.addUseClause('soroban_sdk', 'Vec');
         c.addConstructorArgument({ name: role, type: 'Address' });
-        c.addConstructorCode(`access_control::grant_role_no_auth(e, &admin, &${role}, &Symbol::new(e, "${role}"));`);
+        c.addConstructorCode(`access_control::grant_role_no_auth(e, &${role}, &Symbol::new(e, "${role}"), &admin);`);
 
         if (useMacro) {
           c.addUseClause('stellar_macros', 'only_role');
@@ -114,7 +115,7 @@ export function requireAccessControl(
         } else {
           c.addFunctionCodeBefore(
             fn,
-            [`access_control::ensure_role(e, ${caller}, &Symbol::new(e, "${role}"));`],
+            [`access_control::ensure_role(e, &Symbol::new(e, "${role}"), ${caller});`],
             trait,
           );
         }
@@ -162,6 +163,11 @@ const accessControlFunctions = defineFunctions({
     returns: 'Option<u32>',
     code: ['access_control::has_role(e, &account, &role)'],
   },
+  get_existing_roles: {
+    args: [getSelfArg()],
+    returns: 'Vec<Symbol>',
+    code: ['access_control::get_existing_roles(e)'],
+  },
   get_role_member_count: {
     args: [getSelfArg(), { name: 'role', type: 'Symbol' }],
     returns: 'u32',
@@ -185,24 +191,24 @@ const accessControlFunctions = defineFunctions({
   grant_role: {
     args: [
       getSelfArg(),
-      { name: 'caller', type: 'Address' },
       { name: 'account', type: 'Address' },
       { name: 'role', type: 'Symbol' },
+      { name: 'caller', type: 'Address' },
     ],
-    code: ['access_control::grant_role(e, &caller, &account, &role);'],
+    code: ['access_control::grant_role(e, &account, &role, &caller);'],
   },
   revoke_role: {
     args: [
       getSelfArg(),
-      { name: 'caller', type: 'Address' },
       { name: 'account', type: 'Address' },
       { name: 'role', type: 'Symbol' },
+      { name: 'caller', type: 'Address' },
     ],
-    code: ['access_control::revoke_role(e, &caller, &account, &role);'],
+    code: ['access_control::revoke_role(e, &account, &role, &caller);'],
   },
   renounce_role: {
-    args: [getSelfArg(), { name: 'caller', type: 'Address' }, { name: 'role', type: 'Symbol' }],
-    code: ['access_control::renounce_role(e, &caller, &role);'],
+    args: [getSelfArg(), { name: 'role', type: 'Symbol' }, { name: 'caller', type: 'Address' }],
+    code: ['access_control::renounce_role(e, &role, &caller);'],
   },
   transfer_admin_role: {
     args: [getSelfArg(), { name: 'new_admin', type: 'Address' }, { name: 'live_until_ledger', type: 'u32' }],

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');
 });

package/src/utils/compile-test.ts

@@ -1,10 +1,12 @@
 import type { ExecutionContext } from 'ava';
 import { exec } from 'child_process';
-import { mkdir, mkdtemp, rm } from 'fs/promises';
-import { tmpdir } from 'os';
+import { copyFile, mkdir, mkdtemp, readFile, rm, writeFile } from 'fs/promises';
+import { homedir, tmpdir } from 'os';
 import path from 'path';
 import { promisify } from 'util';
 import type { GenericOptions } from '../build-generic';
+import type { CommonContractOptions } from '../common-options';
+import { withCommonContractDefaults } from '../common-options';
 import type { Contract } from '../contract';
 import { zipRustProject } from '../zip-rust';
 import { contractOptionsToContractName } from '../zip-shared';
@@ -18,6 +20,63 @@ export const runCargoTest = async (t: ExecutionContext, temporaryFolder: string)
   t.regex(result.stdout, /0 failed/);
 };
 
+const resolvePath = (inputPath: string) =>
+  inputPath.startsWith('~/') ? path.join(homedir(), inputPath.slice(2)) : path.resolve(inputPath);
+const toCargoPath = (inputPath: string) => inputPath.replace(/\\/g, '/');
+
+const localDependencies = [
+  ['stellar-tokens', 'packages/tokens'],
+  ['stellar-access', 'packages/access'],
+  ['stellar-contract-utils', 'packages/contract-utils'],
+  ['stellar-governance', 'packages/governance'],
+  ['stellar-macros', 'packages/macros'],
+] as const;
+
+const workspaceDependenciesPattern = /\[workspace\.dependencies\][\s\S]*?(?=\n\[profile\.release\])/;
+
+async function rewriteWorkspaceCargoForLocalContracts(workspaceCargoPath: string, stellarContractsPath: string) {
+  const absoluteContractsPath = resolvePath(stellarContractsPath);
+  const upstreamCargoPath = path.join(absoluteContractsPath, 'Cargo.toml');
+  const upstreamLockPath = path.join(absoluteContractsPath, 'Cargo.lock');
+  const workspaceDir = path.dirname(workspaceCargoPath);
+
+  const [workspaceCargo, upstreamCargo] = await Promise.all([
+    readFile(workspaceCargoPath, 'utf8'),
+    readFile(upstreamCargoPath, 'utf8'),
+  ]);
+
+  const sorobanMatch = upstreamCargo.match(/^\s*soroban-sdk\s*=\s*"([^"]+)"/m);
+  if (sorobanMatch === null || sorobanMatch[1] === undefined) {
+    throw new Error(`Unable to find soroban-sdk version in ${upstreamCargoPath}`);
+  }
+
+  const dependencyLines = [
+    `soroban-sdk = "${sorobanMatch[1]}"`,
+    ...localDependencies.map(
+      ([crate, relativePath]) =>
+        `${crate} = { path = "${toCargoPath(path.join(absoluteContractsPath, relativePath))}" }`,
+    ),
+  ];
+
+  if (!workspaceDependenciesPattern.test(workspaceCargo)) {
+    throw new Error(`Unable to locate [workspace.dependencies] section in ${workspaceCargoPath}`);
+  }
+
+  const nextCargo = workspaceCargo.replace(
+    workspaceDependenciesPattern,
+    `[workspace.dependencies]\n${dependencyLines.join('\n')}\n`,
+  );
+
+  await writeFile(workspaceCargoPath, nextCargo);
+
+  // Reuse upstream lockfile when available to minimize resolver drift/offline cache misses.
+  try {
+    await copyFile(upstreamLockPath, path.join(workspaceDir, 'Cargo.lock'));
+  } catch {
+    // Ignore if lockfile is unavailable.
+  }
+}
+
 type WithTemporaryFolderTestFunction<Args extends unknown[]> = (
   ...args: [...Args, ExecutionContext, string]
 ) => Promise<void> | void;
@@ -63,12 +122,21 @@ const doRunRustCompilationTest = async (
 
   assertLayout(test, zip, expandPathsFromFilesPaths(expectedZipFiles));
   await extractPackage(zip, folderPath);
+
+  if (process.env.STELLAR_CONTRACTS_PATH !== undefined) {
+    // Useful for release-candidate validation before crates.io publication.
+    await rewriteWorkspaceCargoForLocalContracts(
+      path.join(folderPath, 'Cargo.toml'),
+      process.env.STELLAR_CONTRACTS_PATH,
+    );
+  }
+
   await runCargoTest(test, folderPath);
 
   if (testOptions.snapshotResult) await snapshotZipContents(test, zip, expectedZipFiles);
 };
 
-export const runRustCompilationTest = withTemporaryFolderDo(
+const _runRustCompilationTest = withTemporaryFolderDo(
   async (
     makeContract: MakeContract,
     opts: GenericOptions,
@@ -78,13 +146,16 @@ export const runRustCompilationTest = withTemporaryFolderDo(
   ) => {
     await doRunRustCompilationTest(makeContract, opts, testOptions, test, `${folderPath}/default`);
 
-    const shouldBeExcludedOrHasAlreadyRun = testOptions.excludeExplicitTraitTest || opts.explicitImplementations;
+    const mergedOpts = withCommonContractDefaults(opts as GenericOptions & CommonContractOptions);
+    const supportsExplicitImplementations = 'explicitImplementations' in mergedOpts;
+    const shouldBeExcludedOrHasAlreadyRun =
+      testOptions.excludeExplicitTraitTest || !supportsExplicitImplementations || mergedOpts.explicitImplementations;
     if (shouldBeExcludedOrHasAlreadyRun) return;
 
     try {
       await doRunRustCompilationTest(
         makeContract,
-        { ...opts, explicitImplementations: true },
+        { ...opts, explicitImplementations: true } as GenericOptions,
         testOptions,
         test,
         `${folderPath}/explicit`,
@@ -94,3 +165,11 @@ export const runRustCompilationTest = withTemporaryFolderDo(
     }
   },
 );
+
+export function runRustCompilationTest<T extends GenericOptions>(
+  makeContract: (opt: T) => Contract,
+  opts: T,
+  testOptions: { snapshotResult: boolean; excludeExplicitTraitTest?: boolean },
+) {
+  return _runRustCompilationTest(makeContract as MakeContract, opts, testOptions);
+}

package/src/utils/version.ts

@@ -1,15 +1,15 @@
 /**
  * The actual latest version to use in links.
  */
-export const contractsVersion = '0.4.1';
+export const contractsVersion = '0.7.1';
 export const contractsVersionTag = `v${contractsVersion}`;
 
 /**
  * Semantic version string representing of the minimum compatible version of Contracts to display in output.
  */
-export const compatibleContractsSemver = '^0.4.1';
+export const compatibleContractsSemver = '^0.7.1';
 
 /**
  * The Soroban version for which compilation and testing have passing tests
  */
-export const compatibleSorobanVersion = '22.0.8';
+export const compatibleSorobanVersion = '25.3.0';

package/src/zip-rust.ts

@@ -5,6 +5,7 @@ import { printContract, removeCreateLevelAttributes } from './print';
 import {
   contractOptionsToContractName,
   createRustLibFile,
+  getRequiredLibDependencies,
   printContractCargo,
   printRustNameTest,
   workspaceCargo,
@@ -33,12 +34,13 @@ export const createRustZipEnvironment = (c: Contract, opts: GenericOptions) => {
   const zip = new JSZip();
 
   const contractName = contractOptionsToContractName(opts?.kind || 'contract');
+  const requiredLibDeps = getRequiredLibDependencies(c);
 
   zip.file(`contracts/${contractName}/src/contract.rs`, removeCreateLevelAttributes(printContract(c)));
   zip.file(`contracts/${contractName}/src/test.rs`, printRustNameTest(c));
   zip.file(`contracts/${contractName}/src/lib.rs`, createRustLibFile);
-  zip.file(`contracts/${contractName}/Cargo.toml`, printContractCargo(contractName));
-  zip.file('Cargo.toml', workspaceCargo);
+  zip.file(`contracts/${contractName}/Cargo.toml`, printContractCargo(contractName, requiredLibDeps));
+  zip.file('Cargo.toml', workspaceCargo(requiredLibDeps));
   zip.file('.gitignore', gitIgnore);
 
   return zip;

package/src/zip-shared.ts

@@ -39,19 +39,30 @@ fn initial_state() {
 // Add more tests bellow
 `;
 
-export const libDependencies = [
+const libDependencies = [
   'stellar-tokens',
   'stellar-access',
   'stellar-contract-utils',
+  'stellar-governance',
   'stellar-macros',
 ] as const;
 
-export const allDependencies = [...libDependencies, 'soroban-sdk'] as const;
+// Derives required lib crate dependencies from the contract's use clauses.
+// Each use clause has a containerPath like "stellar_tokens::fungible::Base".
+// We extract the first segment (the crate name), convert underscores to hyphens
+// to match Cargo naming (e.g., stellar_tokens -> stellar-tokens), then filter
+// libDependencies to include only crates the contract actually references.
+// Filtering against the known list preserves stable ordering and ignores
+// non-lib crates like soroban_sdk (which is always added separately).
+export function getRequiredLibDependencies(c: Pick<Contract, 'useClauses'>): string[] {
+  const usedCrates = new Set(c.useClauses.map(uc => uc.containerPath.split('::')[0]!.replace(/_/g, '-')));
+  return libDependencies.filter(dep => usedCrates.has(dep));
+}
 
 export const addDependenciesWith = (dependencyValue: string, dependenciesToAdd: string[]) =>
   `${dependenciesToAdd.map(dependency => `${dependency} = ${dependencyValue}\n`).join('')}`;
 
-export const printContractCargo = (scaffoldContractName: string) => `[package]
+export const printContractCargo = (scaffoldContractName: string, requiredLibDeps: readonly string[]) => `[package]
 name = "${scaffoldContractName.replace(/_/, '-')}-contract"
 edition.workspace = true
 license.workspace = true
@@ -66,7 +77,7 @@ crate-type = ["cdylib"]
 doctest = false
 
 [dependencies]
-${addDependenciesWith('{ workspace = true }', [...allDependencies])}
+${addDependenciesWith('{ workspace = true }', [...requiredLibDeps, 'soroban-sdk'])}
 [dev-dependencies]
 ${addDependenciesWith('{ workspace = true, features = ["testutils"] }', ['soroban-sdk'])}`;
 
@@ -77,7 +88,7 @@ mod contract;
 mod test;
 `;
 
-export const workspaceCargo = `[workspace]
+export const workspaceCargo = (requiredLibDeps: readonly string[]) => `[workspace]
 resolver = "2"
 members = ["contracts/*"]
 
@@ -88,7 +99,7 @@ license = "Apache-2.0"
 version = "0.0.1"
 
 [workspace.dependencies]
-${addDependenciesWith(`"${compatibleSorobanVersion}"`, ['soroban-sdk'])}${addDependenciesWith(`"=${contractsVersion}"`, [...libDependencies])}
+${addDependenciesWith(`"${compatibleSorobanVersion}"`, ['soroban-sdk'])}${addDependenciesWith(`"=${contractsVersion}"`, [...requiredLibDeps])}
 
 [profile.release]
 opt-level = "z"