@openzeppelin/wizard-stellar 0.1.0 → 0.2.0

package/src/print.ts

@@ -1,4 +1,4 @@
-import type { Contract, Argument, ContractFunction, ImplementedTrait, UseClause } from './contract';
+import type { Contract, Argument, ContractFunction, TraitImplBlock, UseClause } from './contract';
 
 import type { Lines } from './utils/format-lines';
 import { formatLines, spaceBetween } from './utils/format-lines';
@@ -16,6 +16,7 @@ export function printContract(contract: Contract): string {
       [
         `// SPDX-License-Identifier: ${contract.license}`,
         `// Compatible with OpenZeppelin Stellar Soroban Contracts ${compatibleContractsSemver}`,
+        `#![no_std]`,
       ],
       spaceBetween(
         printUseClauses(contract),
@@ -30,7 +31,13 @@ export function printContract(contract: Contract): string {
 }
 
 function printContractStruct(contract: Contract): Lines[] {
-  return ['#[contract]', `pub struct ${contract.name};`];
+  const lines = [];
+  if (contract.derives.length > 0) {
+    lines.push(`#[derive(${contract.derives.sort().join(', ')})]`);
+  }
+  lines.push('#[contract]');
+  lines.push(`pub struct ${contract.name};`);
+  return lines;
 }
 
 function printContractErrors(contract: Contract): Lines[] {
@@ -150,28 +157,25 @@ function printImplementedTraits(contract: Contract): Lines[] {
     if (a.tags.length !== b.tags.length) {
       return a.tags.length - b.tags.length;
     }
-    return a.name.localeCompare(b.name);
+    return a.traitName.localeCompare(b.traitName);
   });
 
   // group by section
-  const grouped = sortedTraits.reduce(
-    (result: { [section: string]: ImplementedTrait[] }, current: ImplementedTrait) => {
-      // default to no section
-      const section = current.section ?? DEFAULT_SECTION;
-      (result[section] = result[section] || []).push(current);
-      return result;
-    },
-    {},
-  );
+  const grouped = sortedTraits.reduce((result: { [section: string]: TraitImplBlock[] }, current: TraitImplBlock) => {
+    // default to no section
+    const section = current.section ?? DEFAULT_SECTION;
+    (result[section] = result[section] || []).push(current);
+    return result;
+  }, {});
 
   const sections = Object.entries(grouped)
     .sort((a, b) => a[0].localeCompare(b[0]))
-    .map(([section, impls]) => printImplementedTraitsSection(section, impls as ImplementedTrait[]));
+    .map(([section, impls]) => printImplementedTraitsSection(section, impls as TraitImplBlock[]));
 
   return spaceBetween(...sections);
 }
 
-function printImplementedTraitsSection(section: string, impls: ImplementedTrait[]): Lines[] {
+function printImplementedTraitsSection(section: string, impls: TraitImplBlock[]): Lines[] {
   const lines = [];
   const isDefaultSection = section === DEFAULT_SECTION;
   if (!isDefaultSection) {
@@ -188,13 +192,33 @@ function printImplementedTraitsSection(section: string, impls: ImplementedTrait[
   return lines;
 }
 
-function printImplementedTrait(trait: ImplementedTrait): Lines[] {
+function printImplementedTrait(trait: TraitImplBlock): Lines[] {
   const implLines = [];
   implLines.push(...trait.tags.map(t => `#[${t}]`));
-  implLines.push(`impl ${trait.name} for ${trait.for} {`);
-  const fns = trait.functions.map(fn => printFunction(fn));
-  implLines.push(spaceBetween(...fns));
-  implLines.push('}');
+
+  const head = `impl ${trait.traitName} for ${trait.structName}`;
+
+  const assocTypeLines =
+    trait.assocType !== undefined && trait.assocType.trim().length > 0 ? [TAB + trait.assocType.trim(), ''] : [];
+
+  const functionLines = trait.functions.map(fn => printFunction(fn));
+
+  const hasBodyContent = assocTypeLines.length > 0 || functionLines.length > 0;
+
+  if (!hasBodyContent) {
+    // Empty impl
+    implLines.push(`${head} {}`);
+  } else {
+    implLines.push(`${head} {`);
+    if (assocTypeLines.length > 0) {
+      implLines.push(...assocTypeLines);
+    }
+    if (functionLines.length > 0) {
+      implLines.push(spaceBetween(...functionLines));
+    }
+    implLines.push('}');
+  }
+
   return implLines;
 }
 
@@ -215,26 +239,45 @@ function printFunction(fn: ContractFunction): Lines[] {
     }
   }
 
-  return printFunction2(head, args, fn.tag, fn.returns, undefined, codeLines);
+  return printFunction2(fn.pub, head, args, fn.tag, fn.returns, undefined, codeLines);
 }
 
 function printContractFunctions(contract: Contract): Lines[] {
-  const implLines = [];
-  implLines.push('#[contractimpl]');
-  implLines.push(`impl ${contract.name} {`);
-  implLines.push(printConstructor(contract));
-  implLines.push('}');
-  return implLines;
+  const constructorLines = printConstructor(contract);
+  const freeFunctionLines = contract.freeFunctions.map(fn => printFunction(fn));
+
+  if (constructorLines.length === 0 && freeFunctionLines.length === 0) {
+    return [];
+  }
+
+  const implBlock: Lines[] = ['#[contractimpl]', `impl ${contract.name} {`];
+
+  if (constructorLines.length > 0) {
+    implBlock.push(constructorLines);
+  }
+
+  if (constructorLines.length > 0 && freeFunctionLines.length > 0) {
+    // Add line break between constructor and first free function
+    implBlock.push('');
+  }
+
+  if (freeFunctionLines.length > 0) {
+    implBlock.push(spaceBetween(...freeFunctionLines));
+  }
+
+  implBlock.push('}');
+  return implBlock;
 }
 
 function printConstructor(contract: Contract): Lines[] {
   if (contract.constructorCode.length > 0) {
-    const head = 'pub fn __constructor';
+    const head = 'fn __constructor';
     const args = [getSelfArg(), ...contract.constructorArgs];
 
     const body = spaceBetween(withSemicolons(contract.constructorCode));
 
     const constructor = printFunction2(
+      true,
       head,
       args.map(a => printArgument(a)),
       undefined,
@@ -251,6 +294,7 @@ function printConstructor(contract: Contract): Lines[] {
 // generic for functions and constructors
 // kindedName = 'fn foo'
 function printFunction2(
+  pub: boolean | undefined,
   kindedName: string,
   args: string[],
   tag: string | undefined,
@@ -264,7 +308,13 @@ function printFunction2(
     fn.push(`#[${tag}]`);
   }
 
-  let accum = `${kindedName}(`;
+  let accum = '';
+
+  if (pub) {
+    accum += 'pub ';
+  }
+
+  accum += `${kindedName}(`;
 
   if (args.length > 0) {
     const formattedArgs = args.join(', ');

package/src/set-access-control.ts

@@ -1,4 +1,4 @@
-import type { BaseFunction, BaseImplementedTrait, ContractBuilder } from './contract';
+import type { BaseFunction, BaseTraitImplBlock, ContractBuilder } from './contract';
 
 export const accessOptions = [false, 'ownable'] as const;
 export const DEFAULT_ACCESS_CONTROL = 'ownable';
@@ -37,7 +37,7 @@ export function setAccessControl(c: ContractBuilder, access: Access): void {
  */
 export function requireAccessControl(
   c: ContractBuilder,
-  trait: BaseImplementedTrait,
+  trait: BaseTraitImplBlock | undefined,
   fn: BaseFunction,
   access: Access,
   caller?: string,
@@ -54,14 +54,13 @@ export function requireAccessControl(
       if (caller) {
         c.addUseClause('soroban_sdk', 'panic_with_error');
         c.addError('Unauthorized', 1); // TODO: Ensure there are no conflicts in error codes
-        c.addFunctionCodeBefore(trait, fn, [
-          getOwner,
-          'if owner != caller {',
-          `    panic_with_error!(e, ${c.name}Error::Unauthorized)`,
-          '}',
-        ]);
+        c.addFunctionCodeBefore(
+          fn,
+          [getOwner, `if owner != ${caller} {`, `    panic_with_error!(e, ${c.name}Error::Unauthorized)`, '}'],
+          trait,
+        );
       } else {
-        c.addFunctionCodeBefore(trait, fn, [getOwner, 'owner.require_auth();']);
+        c.addFunctionCodeBefore(fn, [getOwner, 'owner.require_auth();'], trait);
       }
       break;
     }

package/src/test.ts

@@ -17,6 +17,10 @@ test.serial('fungible result generated', async t => {
   await testGenerate(t, 'Fungible');
 });
 
+test.serial('non-fungible result generated', async t => {
+  await testGenerate(t, 'NonFungible');
+});
+
 async function testGenerate(t: ExecutionContext<Context>, kind: keyof KindedOptions) {
   const generatedSourcesPath = path.join(os.tmpdir(), 'oz-wizard-stellar');
   await fs.rm(generatedSourcesPath, { force: true, recursive: true });

package/src/utils/version.ts

@@ -1,10 +1,10 @@
 /**
  * The actual latest version to use in links.
  */
-export const contractsVersion = '0.1.0';
+export const contractsVersion = '0.2.0';
 export const contractsVersionTag = `v${contractsVersion}`;
 
 /**
  * Semantic version string representing of the minimum compatible version of Contracts to display in output.
  */
-export const compatibleContractsSemver = '^0.1.0';
+export const compatibleContractsSemver = '^0.2.0';