[Stellar] Add toggle to switch from default to explicit trait implementation

.changeset/plain-turkeys-film.md

@@ -0,0 +1,7 @@
+---
+'@openzeppelin/wizard-stellar': patch
+'@openzeppelin/wizard-common': patch
+'@openzeppelin/contracts-mcp': patch
+---
+
+Stellar: add an explicitImplementations flag that switches from using default_impl macro to explicit definitions

packages/common/src/ai/descriptions/stellar.ts

@@ -12,6 +12,8 @@ export const stellarCommonDescriptions = {
   upgradeable: 'Whether the contract can be upgraded.',
   access:
     'The type of access control to provision. Ownable is a simple mechanism with a single account authorized for all privileged actions. Roles is a flexible mechanism with a separate role for each privileged action. A role can have many authorized accounts.',
+  explicitImplementations:
+    'Whether the contract should use explicit trait implementations instead of using the #[default_impl] macro to auto-generate trait method bodies.',
 };
 
 export const stellarFungibleDescriptions = {

packages/common/src/index.ts

@@ -3,3 +3,4 @@ export * from './ai/descriptions/cairo';
 export * from './ai/descriptions/solidity';
 export * from './ai/descriptions/stellar';
 export * from './ai/descriptions/stylus';
+export * from './utils/object';

packages/common/src/utils/object.ts

@@ -0,0 +1,2 @@
+export const pickKeys = <T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> =>
+  Object.fromEntries(keys.map(k => [k, obj[k]])) as Pick<T, K>;

packages/core/stellar/src/add-pausable.ts

@@ -1,13 +1,13 @@
 import { getSelfArg } from './common-options';
 import type { BaseFunction, ContractBuilder } from './contract';
 import type { Access } from './set-access-control';
-import { requireAccessControl } from './set-access-control';
+import { DEFAULT_ACCESS_CONTROL, requireAccessControl } from './set-access-control';
 import { defineFunctions } from './utils/define-functions';
 
-export function addPausable(c: ContractBuilder, access: Access) {
+export function addPausable(c: ContractBuilder, access: Access, explicitImplementations: boolean) {
   c.addUseClause('stellar_contract_utils::pausable', 'self', { alias: 'pausable' });
   c.addUseClause('stellar_contract_utils::pausable', 'Pausable');
-  c.addUseClause('stellar_macros', 'default_impl');
+  if (!explicitImplementations) c.addUseClause('stellar_macros', 'default_impl');
 
   const pausableTrait = {
     traitName: 'Pausable',
@@ -16,23 +16,38 @@ export function addPausable(c: ContractBuilder, access: Access) {
     section: 'Utils',
   };
 
-  const pauseFn: BaseFunction = access === 'ownable' ? functions.pause_unused_caller : functions.pause;
-  const unpauseFn: BaseFunction = access === 'ownable' ? functions.unpause_unused_caller : functions.unpause;
+  const effectiveAccess = access === false ? DEFAULT_ACCESS_CONTROL : access;
+  const pauseFn: BaseFunction = effectiveAccess === 'ownable' ? functions.pause_unused_caller : functions.pause;
+  const unpauseFn: BaseFunction = effectiveAccess === 'ownable' ? functions.unpause_unused_caller : functions.unpause;
 
   c.addTraitFunction(pausableTrait, functions.paused);
   c.addTraitFunction(pausableTrait, pauseFn);
   c.addTraitFunction(pausableTrait, unpauseFn);
-  requireAccessControl(c, pausableTrait, pauseFn, access, {
-    useMacro: true,
-    role: 'pauser',
-    caller: 'caller',
-  });
+  requireAccessControl(
+    c,
+    pausableTrait,
+    pauseFn,
+    effectiveAccess,
+    {
+      useMacro: true,
+      role: 'pauser',
+      caller: 'caller',
+    },
+    explicitImplementations,
+  );
 
-  requireAccessControl(c, pausableTrait, unpauseFn, access, {
-    useMacro: true,
-    role: 'pauser',
-    caller: 'caller',
-  });
+  requireAccessControl(
+    c,
+    pausableTrait,
+    unpauseFn,
+    effectiveAccess,
+    {
+      useMacro: true,
+      role: 'pauser',
+      caller: 'caller',
+    },
+    explicitImplementations,
+  );
 }
 
 const functions = defineFunctions({

packages/core/stellar/src/add-upgradeable.ts

@@ -4,7 +4,7 @@ import { requireAccessControl } from './set-access-control';
 import type { BaseFunction, ContractBuilder } from './contract';
 import { defineFunctions } from './utils/define-functions';
 
-export function addUpgradeable(c: ContractBuilder, access: Access) {
+export function addUpgradeable(c: ContractBuilder, access: Access, explicitImplementations: boolean) {
   const functions = defineFunctions({
     _require_auth: {
       args: [getSelfArg(), { name: 'operator', type: '&Address' }],
@@ -34,9 +34,16 @@ export function addUpgradeable(c: ContractBuilder, access: Access) {
 
   c.addTraitFunction(upgradeableTrait, upgradeFn);
 
-  requireAccessControl(c, upgradeableTrait, upgradeFn, access, {
-    useMacro: false,
-    role: 'upgrader',
-    caller: 'operator',
-  });
+  requireAccessControl(
+    c,
+    upgradeableTrait,
+    upgradeFn,
+    access,
+    {
+      useMacro: false,
+      role: 'upgrader',
+      caller: 'operator',
+    },
+    explicitImplementations,
+  );
 }

packages/core/stellar/src/common-options.ts

@@ -10,6 +10,7 @@ export const defaults: Required<CommonOptions> = {
 export const contractDefaults: Required<CommonContractOptions> = {
   ...defaults,
   access: false,
+  explicitImplementations: false,
 } as const;
 
 export interface CommonOptions {
@@ -18,6 +19,7 @@ export interface CommonOptions {
 
 export interface CommonContractOptions extends CommonOptions {
   access?: Access;
+  explicitImplementations?: boolean;
 }
 
 export function withCommonDefaults(opts: CommonOptions): Required<CommonOptions> {
@@ -30,6 +32,7 @@ export function withCommonContractDefaults(opts: CommonContractOptions): Require
   return {
     ...withCommonDefaults(opts),
     access: opts.access ?? contractDefaults.access,
+    explicitImplementations: opts.explicitImplementations ?? contractDefaults.explicitImplementations,
   };
 }
 

packages/core/stellar/src/contract.ts

@@ -185,6 +185,10 @@ export class ContractBuilder implements Contract {
     }
   }
 
+  addTraitForEachFunctions(baseTrait: BaseTraitImplBlock, functions: Record<string, BaseFunction>) {
+    Object.values(functions).forEach(fn => this.addTraitFunction(baseTrait, fn));
+  }
+
   // used for adding a function to a trait implementation block
   addTraitFunction(baseTrait: BaseTraitImplBlock, fn: BaseFunction): ContractFunction {
     const t = this.addTraitImplBlock(baseTrait);
@@ -241,6 +245,11 @@ export class ContractBuilder implements Contract {
     existingFn.tags = [...(existingFn.tags ?? []), tag];
   }
 
+  setFunctionCode(fn: BaseFunction, code: string[], baseTrait?: BaseTraitImplBlock): void {
+    const existingFn = this.getOrCreateFunction(fn, baseTrait);
+    existingFn.code = [...code];
+  }
+
   addConstructorArgument(arg: Argument): void {
     for (const existingArg of this.constructorArgs) {
       if (existingArg.name == arg.name) {

packages/core/stellar/src/fungible.test.ts

@@ -98,6 +98,10 @@ testFungible('fungible full - complex name', {
   upgradeable: true,
 });
 
+testFungible('fungible explicit trait implementations', {
+  explicitImplementations: true,
+});
+
 testAPIEquivalence('fungible API default');
 
 testAPIEquivalence('fungible API basic', { name: 'CustomToken', symbol: 'CTK' });

packages/core/stellar/src/fungible.test.ts.md

@@ -124,12 +124,12 @@ Generated by [AVA](https://avajs.dev).
         }␊
     ␊
         #[only_owner]␊
-        fn pause(e: &Env, caller: Address) {␊
+        fn pause(e: &Env, _caller: Address) {␊
             pausable::pause(e);␊
         }␊
     ␊
         #[only_owner]␊
-        fn unpause(e: &Env, caller: Address) {␊
+        fn unpause(e: &Env, _caller: Address) {␊
             pausable::unpause(e);␊
         }␊
     }␊
@@ -208,12 +208,12 @@ Generated by [AVA](https://avajs.dev).
         }␊
     ␊
         #[only_owner]␊
-        fn pause(e: &Env, caller: Address) {␊
+        fn pause(e: &Env, _caller: Address) {␊
             pausable::pause(e);␊
         }␊
     ␊
         #[only_owner]␊
-        fn unpause(e: &Env, caller: Address) {␊
+        fn unpause(e: &Env, _caller: Address) {␊
             pausable::unpause(e);␊
         }␊
     }␊
@@ -362,7 +362,7 @@ Generated by [AVA](https://avajs.dev).
     // Compatible with OpenZeppelin Stellar Soroban Contracts ^0.4.1␊
     #![no_std]␊
     ␊
-    use soroban_sdk::{Address, contract, contractimpl, Env, String};␊
+    use soroban_sdk::{Address, contract, contractimpl, Env, String, Symbol};␊
     use stellar_access::access_control::{self as access_control, AccessControl};␊
     use stellar_macros::default_impl;␊
     use stellar_tokens::fungible::{Base, FungibleToken};␊
@@ -693,3 +693,66 @@ Generated by [AVA](https://avajs.dev).
     #[contractimpl]␊
     impl Ownable for CustomToken {}␊
     `
+
+## fungible explicit trait implementations
+
+> Snapshot 1
+
+    `// SPDX-License-Identifier: MIT␊
+    // Compatible with OpenZeppelin Stellar Soroban Contracts ^0.4.1␊
+    #![no_std]␊
+    ␊
+    use soroban_sdk::{Address, contract, contractimpl, Env, String};␊
+    use stellar_tokens::fungible::{Base, FungibleToken};␊
+    ␊
+    #[contract]␊
+    pub struct MyToken;␊
+    ␊
+    #[contractimpl]␊
+    impl MyToken {␊
+        pub fn __constructor(e: &Env) {␊
+            Base::set_metadata(e, 18, String::from_str(e, "MyToken"), String::from_str(e, "MTK"));␊
+        }␊
+    }␊
+    ␊
+    #[contractimpl]␊
+    impl FungibleToken for MyToken {␊
+        type ContractType = Base;␊
+    ␊
+        fn total_supply(e: &Env) -> i128 {␊
+            Self::ContractType::total_supply(e)␊
+        }␊
+    ␊
+        fn balance(e: &Env, account: Address) -> i128 {␊
+            Self::ContractType::balance(e, &account)␊
+        }␊
+    ␊
+        fn allowance(e: &Env, owner: Address, spender: Address) -> i128 {␊
+            Self::ContractType::allowance(e, &owner, &spender)␊
+        }␊
+    ␊
+        fn transfer(e: &Env, from: Address, to: Address, amount: i128) {␊
+            Self::ContractType::transfer(e, &from, &to, amount);␊
+        }␊
+    ␊
+        fn transfer_from(e: &Env, spender: Address, from: Address, to: Address, amount: i128) {␊
+            Self::ContractType::transfer_from(e, &spender, &from, &to, amount);␊
+        }␊
+    ␊
+        fn approve(e: &Env, owner: Address, spender: Address, amount: i128, live_until_ledger: u32) {␊
+            Self::ContractType::approve(e, &owner, &spender, amount, live_until_ledger);␊
+        }␊
+    ␊
+        fn decimals(e: &Env) -> u32 {␊
+            Self::ContractType::decimals(e)␊
+        }␊
+    ␊
+        fn name(e: &Env) -> String {␊
+            Self::ContractType::name(e)␊
+        }␊
+    ␊
+        fn symbol(e: &Env) -> String {␊
+            Self::ContractType::symbol(e)␊
+        }␊
+    }␊
+    `