@openzeppelin/wizard-stellar 0.4.3 → 0.4.5

package/src/set-access-control.ts

@@ -1,4 +1,6 @@
+import { getSelfArg } from './common-options';
 import type { BaseFunction, BaseTraitImplBlock, ContractBuilder } from './contract';
+import { defineFunctions } from './utils/define-functions';
 
 export const accessOptions = [false, 'ownable', 'roles'] as const;
 export const DEFAULT_ACCESS_CONTROL = 'ownable';
@@ -13,7 +15,7 @@ export type AccessProps = {
 /**
  * Sets access control for the contract via constructor args.
  */
-export function setAccessControl(c: ContractBuilder, access: Access): void {
+export function setAccessControl(c: ContractBuilder, access: Access, explicitImplementations = false): void {
   switch (access) {
     case false:
       break;
@@ -27,10 +29,14 @@ export function setAccessControl(c: ContractBuilder, access: Access): void {
         const ownableTrait = {
           traitName: 'Ownable',
           structName: c.name,
-          tags: ['default_impl', 'contractimpl'],
+          tags: explicitImplementations ? ['contractimpl'] : ['default_impl', 'contractimpl'],
           section: 'Utils',
         };
-        c.addTraitImplBlock(ownableTrait);
+        if (explicitImplementations) {
+          c.addTraitForEachFunctions(ownableTrait, ownableFunctions);
+        } else {
+          c.addTraitImplBlock(ownableTrait);
+        }
 
         c.addConstructorArgument({ name: 'owner', type: 'Address' });
         c.addConstructorCode('ownable::set_owner(e, &owner);');
@@ -42,13 +48,18 @@ export function setAccessControl(c: ContractBuilder, access: Access): void {
       c.addUseClause('stellar_access::access_control', 'self', { alias: 'access_control' });
       c.addUseClause('stellar_access::access_control', 'AccessControl');
 
-      const accessControltrait = {
+      const accessControlTrait = {
         traitName: 'AccessControl',
         structName: c.name,
-        tags: ['default_impl', 'contractimpl'],
+        tags: explicitImplementations ? ['contractimpl'] : ['default_impl', 'contractimpl'],
         section: 'Utils',
       };
-      c.addTraitImplBlock(accessControltrait);
+      if (explicitImplementations) {
+        c.addUseClause('soroban_sdk', 'Symbol');
+        c.addTraitForEachFunctions(accessControlTrait, accessControlFunctions);
+      } else {
+        c.addTraitImplBlock(accessControlTrait);
+      }
 
       c.addConstructorArgument({ name: 'admin', type: 'Address' });
       c.addConstructorCode('access_control::set_admin(e, &admin);');
@@ -70,11 +81,12 @@ export function requireAccessControl(
   fn: BaseFunction,
   access: Access,
   accessProps: AccessProps = { useMacro: true },
+  explicitImplementations = false,
 ): void {
   if (access === false) {
     access = DEFAULT_ACCESS_CONTROL;
   }
-  setAccessControl(c, access);
+  setAccessControl(c, access, explicitImplementations);
 
   switch (access) {
     case 'ownable': {
@@ -123,3 +135,89 @@ export function requireAccessControl(
     }
   }
 }
+
+const ownableFunctions = defineFunctions({
+  get_owner: {
+    args: [getSelfArg()],
+    returns: 'Option<Address>',
+    code: ['ownable::get_owner(e)'],
+  },
+  transfer_ownership: {
+    args: [getSelfArg(), { name: 'new_owner', type: 'Address' }, { name: 'live_until_ledger', type: 'u32' }],
+    code: ['ownable::transfer_ownership(e, &new_owner, live_until_ledger);'],
+  },
+  accept_ownership: {
+    args: [getSelfArg()],
+    code: ['ownable::accept_ownership(e);'],
+  },
+  renounce_ownership: {
+    args: [getSelfArg()],
+    code: ['ownable::renounce_ownership(e);'],
+  },
+});
+
+const accessControlFunctions = defineFunctions({
+  has_role: {
+    args: [getSelfArg(), { name: 'account', type: 'Address' }, { name: 'role', type: 'Symbol' }],
+    returns: 'Option<u32>',
+    code: ['access_control::has_role(e, &account, &role)'],
+  },
+  get_role_member_count: {
+    args: [getSelfArg(), { name: 'role', type: 'Symbol' }],
+    returns: 'u32',
+    code: ['access_control::get_role_member_count(e, &role)'],
+  },
+  get_role_member: {
+    args: [getSelfArg(), { name: 'role', type: 'Symbol' }, { name: 'index', type: 'u32' }],
+    returns: 'Address',
+    code: ['access_control::get_role_member(e, &role, index)'],
+  },
+  get_role_admin: {
+    args: [getSelfArg(), { name: 'role', type: 'Symbol' }],
+    returns: 'Option<Symbol>',
+    code: ['access_control::get_role_admin(e, &role)'],
+  },
+  get_admin: {
+    args: [getSelfArg()],
+    returns: 'Option<Address>',
+    code: ['access_control::get_admin(e)'],
+  },
+  grant_role: {
+    args: [
+      getSelfArg(),
+      { name: 'caller', type: 'Address' },
+      { name: 'account', type: 'Address' },
+      { name: 'role', type: 'Symbol' },
+    ],
+    code: ['access_control::grant_role(e, &caller, &account, &role);'],
+  },
+  revoke_role: {
+    args: [
+      getSelfArg(),
+      { name: 'caller', type: 'Address' },
+      { name: 'account', type: 'Address' },
+      { name: 'role', type: 'Symbol' },
+    ],
+    code: ['access_control::revoke_role(e, &caller, &account, &role);'],
+  },
+  renounce_role: {
+    args: [getSelfArg(), { name: 'caller', type: 'Address' }, { name: 'role', type: 'Symbol' }],
+    code: ['access_control::renounce_role(e, &caller, &role);'],
+  },
+  transfer_admin_role: {
+    args: [getSelfArg(), { name: 'new_admin', type: 'Address' }, { name: 'live_until_ledger', type: 'u32' }],
+    code: ['access_control::transfer_admin_role(e, &new_admin, live_until_ledger);'],
+  },
+  accept_admin_transfer: {
+    args: [getSelfArg()],
+    code: ['access_control::accept_admin_transfer(e);'],
+  },
+  set_role_admin: {
+    args: [getSelfArg(), { name: 'role', type: 'Symbol' }, { name: 'admin_role', type: 'Symbol' }],
+    code: ['access_control::set_role_admin(e, &role, &admin_role);'],
+  },
+  renounce_admin: {
+    args: [getSelfArg()],
+    code: ['access_control::renounce_admin(e);'],
+  },
+});

package/src/stablecoin.ts

@@ -1,16 +1,16 @@
-import type { Contract, ContractBuilder } from './contract';
-import { defineFunctions } from './utils/define-functions';
 import { getSelfArg } from './common-options';
-import { printContract } from './print';
+import type { Contract, ContractBuilder } from './contract';
 import type { FungibleOptions } from './fungible';
 import {
   buildFungible,
   defaults as fungibleDefaults,
-  withDefaults as withFungibleDefaults,
   functions as fungibleFunctions,
   isAccessControlRequired as fungibleIsAccessControlRequired,
+  withDefaults as withFungibleDefaults,
 } from './fungible';
+import { printContract } from './print';
 import { requireAccessControl, type Access } from './set-access-control';
+import { defineFunctions } from './utils/define-functions';
 
 export const defaults: Required<StablecoinOptions> = {
   ...fungibleDefaults,
@@ -20,13 +20,14 @@ export const defaults: Required<StablecoinOptions> = {
 } as const;
 
 export const limitationsOptions = [false, 'allowlist', 'blocklist'] as const;
+export type Limitations = (typeof limitationsOptions)[number];
 
 export function printStablecoin(opts: StablecoinOptions = defaults): string {
   return printContract(buildStablecoin(opts));
 }
 
 export interface StablecoinOptions extends FungibleOptions {
-  limitations?: false | 'allowlist' | 'blocklist';
+  limitations?: Limitations;
 }
 
 function withDefaults(opts: StablecoinOptions): Required<StablecoinOptions> {
@@ -48,13 +49,18 @@ export function buildStablecoin(opts: StablecoinOptions): Contract {
   const c = buildFungible(allOpts);
 
   if (allOpts.limitations) {
-    addLimitations(c, allOpts.access, allOpts.limitations);
+    addLimitations(c, allOpts.access, allOpts.limitations, allOpts.explicitImplementations);
   }
 
   return c;
 }
 
-function addLimitations(c: ContractBuilder, access: Access, mode: 'allowlist' | 'blocklist') {
+function addLimitations(
+  c: ContractBuilder,
+  access: Access,
+  mode: 'allowlist' | 'blocklist',
+  explicitImplementations: boolean,
+) {
   const type = mode === 'allowlist';
 
   const limitationsTrait = {
@@ -72,6 +78,8 @@ function addLimitations(c: ContractBuilder, access: Access, mode: 'allowlist' |
     c.overrideAssocType('FungibleToken', 'type ContractType = BlockList;');
   }
 
+  if (explicitImplementations) overrideFungibleReadonlyFunctionsWithBase(c);
+
   const [getterFn, addFn, removeFn] = type
     ? [functions.allowed, functions.allow_user, functions.disallow_user]
     : [functions.blocked, functions.block_user, functions.unblock_user];
@@ -85,10 +93,32 @@ function addLimitations(c: ContractBuilder, access: Access, mode: 'allowlist' |
   };
 
   c.addTraitFunction(limitationsTrait, addFn);
-  requireAccessControl(c, limitationsTrait, addFn, access, accessProps);
+  requireAccessControl(c, limitationsTrait, addFn, access, accessProps, explicitImplementations);
 
   c.addTraitFunction(limitationsTrait, removeFn);
-  requireAccessControl(c, limitationsTrait, removeFn, access, accessProps);
+  requireAccessControl(c, limitationsTrait, removeFn, access, accessProps, explicitImplementations);
+}
+
+function overrideFungibleReadonlyFunctionsWithBase(c: ContractBuilder) {
+  c.addUseClause('stellar_tokens::fungible', 'ContractOverrides');
+  const fungibleTokenTrait = {
+    traitName: 'FungibleToken',
+    structName: c.name,
+    tags: [],
+  };
+
+  const overrides: Array<[(typeof fungibleFunctions)[keyof typeof fungibleFunctions], string[]]> = [
+    [fungibleFunctions.total_supply, ['Self::ContractType::total_supply(e)']],
+    [fungibleFunctions.balance, ['Self::ContractType::balance(e, &account)']],
+    [fungibleFunctions.allowance, ['Self::ContractType::allowance(e, &owner, &spender)']],
+    [fungibleFunctions.decimals, ['Self::ContractType::decimals(e)']],
+    [fungibleFunctions.name, ['Self::ContractType::name(e)']],
+    [fungibleFunctions.symbol, ['Self::ContractType::symbol(e)']],
+  ];
+
+  for (const [fn, code] of overrides) {
+    c.setFunctionCode(fn, code, fungibleTokenTrait);
+  }
 }
 
 const functions = {

package/src/utils/compile-test.ts

@@ -1,14 +1,14 @@
-import { tmpdir } from 'os';
 import type { ExecutionContext } from 'ava';
+import { exec } from 'child_process';
+import { mkdir, mkdtemp, rm } from 'fs/promises';
+import { tmpdir } from 'os';
 import path from 'path';
 import { promisify } from 'util';
-import { exec } from 'child_process';
 import type { GenericOptions } from '../build-generic';
 import type { Contract } from '../contract';
-import { assertLayout, snapshotZipContents, expandPathsFromFilesPaths, extractPackage } from './zip-test';
-import { mkdtemp, rm } from 'fs/promises';
-import { contractOptionsToContractName } from '../zip-shared';
 import { zipRustProject } from '../zip-rust';
+import { contractOptionsToContractName } from '../zip-shared';
+import { assertLayout, expandPathsFromFilesPaths, extractPackage, snapshotZipContents } from './zip-test';
 
 const asyncExec = promisify(exec);
 
@@ -29,7 +29,6 @@ export const withTemporaryFolderDo =
   (...testFunctionArguments: Args) =>
   async (test: ExecutionContext) => {
     const temporaryFolder = await mkdtemp(path.join(tmpdir(), `compilation-test-${crypto.randomUUID()}`));
-
     try {
       await testFunction(...testFunctionArguments, test, temporaryFolder);
     } finally {
@@ -37,33 +36,61 @@ export const withTemporaryFolderDo =
     }
   };
 
+const doRunRustCompilationTest = async (
+  makeContract: MakeContract,
+  opts: GenericOptions,
+  testOptions: { snapshotResult: boolean },
+  test: ExecutionContext,
+  folderPath: string,
+) => {
+  test.timeout(3_000_000);
+
+  await mkdir(folderPath, { recursive: true });
+
+  const scaffoldContractName = contractOptionsToContractName(opts?.kind || 'contract');
+
+  const expectedZipFiles = [
+    `contracts/${scaffoldContractName}/src/contract.rs`,
+    `contracts/${scaffoldContractName}/src/test.rs`,
+    `contracts/${scaffoldContractName}/src/lib.rs`,
+    `contracts/${scaffoldContractName}/Cargo.toml`,
+    'Cargo.toml',
+    '.gitignore',
+    'README.md',
+  ];
+
+  const zip = await zipRustProject(makeContract(opts), opts);
+
+  assertLayout(test, zip, expandPathsFromFilesPaths(expectedZipFiles));
+  await extractPackage(zip, folderPath);
+  await runCargoTest(test, folderPath);
+
+  if (testOptions.snapshotResult) await snapshotZipContents(test, zip, expectedZipFiles);
+};
+
 export const runRustCompilationTest = withTemporaryFolderDo(
   async (
     makeContract: MakeContract,
     opts: GenericOptions,
-    testOptions: { snapshotResult: boolean },
+    testOptions: { snapshotResult: boolean; excludeExplicitTraitTest?: boolean },
     test: ExecutionContext,
     folderPath: string,
   ) => {
-    test.timeout(3_000_000);
+    await doRunRustCompilationTest(makeContract, opts, testOptions, test, `${folderPath}/default`);
 
-    const scaffoldContractName = contractOptionsToContractName(opts?.kind || 'contract');
+    const shouldBeExcludedOrHasAlreadyRun = testOptions.excludeExplicitTraitTest || opts.explicitImplementations;
+    if (shouldBeExcludedOrHasAlreadyRun) return;
 
-    const expectedZipFiles = [
-      `contracts/${scaffoldContractName}/src/contract.rs`,
-      `contracts/${scaffoldContractName}/src/test.rs`,
-      `contracts/${scaffoldContractName}/src/lib.rs`,
-      `contracts/${scaffoldContractName}/Cargo.toml`,
-      'Cargo.toml',
-      'README.md',
-    ];
-
-    const zip = await zipRustProject(makeContract(opts), opts);
-
-    assertLayout(test, zip, expandPathsFromFilesPaths(expectedZipFiles));
-    await extractPackage(zip, folderPath);
-    await runCargoTest(test, folderPath);
-
-    if (testOptions.snapshotResult) await snapshotZipContents(test, zip, expectedZipFiles);
+    try {
+      await doRunRustCompilationTest(
+        makeContract,
+        { ...opts, explicitImplementations: true },
+        testOptions,
+        test,
+        `${folderPath}/explicit`,
+      );
+    } catch (error) {
+      throw new Error(`EXPLICIT IMPLEMENTATION ERROR: ${error}`);
+    }
   },
 );

package/src/zip-rust.ts

@@ -25,6 +25,10 @@ Continue your development journey with [Stellar CLI](https://github.com/stellar/
 - See [Git installation guide](https://github.com/git-guides/install-git).
 `;
 
+const gitIgnore = `\
+target/
+`;
+
 export const createRustZipEnvironment = (c: Contract, opts: GenericOptions) => {
   const zip = new JSZip();
 
@@ -35,6 +39,7 @@ export const createRustZipEnvironment = (c: Contract, opts: GenericOptions) => {
   zip.file(`contracts/${contractName}/src/lib.rs`, createRustLibFile);
   zip.file(`contracts/${contractName}/Cargo.toml`, printContractCargo(contractName));
   zip.file('Cargo.toml', workspaceCargo);
+  zip.file('.gitignore', gitIgnore);
 
   return zip;
 };