@openzeppelin/wizard-stellar 0.5.0 → 0.6.0

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.6.0';
+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.6.0';
+export const compatibleContractsSemver = '^0.7.1';
 
 /**
  * The Soroban version for which compilation and testing have passing tests
  */
-export const compatibleSorobanVersion = '23.4.0';
+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"