Stellar v0.2.0 (#531)

Co-authored-by: Eric Lau <[email protected]>
Co-authored-by: Boyan Barakov <[email protected]>

Author: 3 people

.changeset/silver-mammals-lay.md

@@ -0,0 +1,5 @@
+---
+'@openzeppelin/wizard-stellar': minor
+---
+
+Add NonFungible extension and minor refactorings to Fungible (crate renamings, etc.).

.github/workflows/compile-cairo-alpha-project.yml

@@ -5,6 +5,8 @@ on:
     paths:
       - 'packages/core/cairo_alpha/**'
   push:
+    paths:
+      - 'packages/core/cairo_alpha/**'
 
 jobs:
   validate-cairo-alpha:
@@ -22,7 +24,7 @@ jobs:
         with:
           node-version: 20.x
           cache: 'yarn'
-          
+
       - name: Install dependencies
         working-directory: packages/core/cairo_alpha
         run: yarn install --network-concurrency 1
@@ -32,7 +34,7 @@ jobs:
         run: |
           SCARB_VERSION=$(grep 'scarb-version = ' Scarb.toml | sed 's/scarb-version = "\(.*\)"/\1/')
           echo "SCARB_VERSION=$SCARB_VERSION" >> "$GITHUB_ENV"
-      
+
       - name: Setup Scarb
         uses: software-mansion/setup-scarb@f6ad35129872f897bdea556c09e11af8fb3293c0 #v1.5.1
         with:
@@ -74,5 +76,5 @@ jobs:
               echo "✅ Compiled $proj_name!"
               echo "---------------------------------"
             fi
-            
+
           done

.github/workflows/compile-cairo-project.yml

@@ -5,6 +5,8 @@ on:
     paths:
       - 'packages/core/cairo/**'
   push:
+    paths:
+      - 'packages/core/cairo/**'
 
 jobs:
   validate-cairo:
@@ -22,7 +24,7 @@ jobs:
         with:
           node-version: 20.x
           cache: 'yarn'
-          
+
       - name: Install dependencies
         working-directory: packages/core/cairo
         run: yarn install --network-concurrency 1
@@ -32,7 +34,7 @@ jobs:
         run: |
           SCARB_VERSION=$(grep 'scarb-version = ' Scarb.toml | sed 's/scarb-version = "\(.*\)"/\1/')
           echo "SCARB_VERSION=$SCARB_VERSION" >> "$GITHUB_ENV"
-      
+
       - name: Setup Scarb
         uses: software-mansion/setup-scarb@f6ad35129872f897bdea556c09e11af8fb3293c0 #v1.5.1
         with:
@@ -74,5 +76,5 @@ jobs:
               echo "✅ Compiled $proj_name!"
               echo "---------------------------------"
             fi
-            
+
           done

packages/core/solidity/src/kind.ts

@@ -4,7 +4,7 @@ export type Kind = GenericOptions['kind'];
 
 export function sanitizeKind(kind: unknown): Kind {
   if (typeof kind === 'string') {
-    const sanitized = kind.replace(/^(ERC|.)/i, c => c.toUpperCase());
+    const sanitized = kind.replace(/^(ERC|.)/i, c => c.toUpperCase()).replace(/^(RealWorldAsset)$/i, 'RealWorldAsset');
     if (isKind(sanitized)) {
       return sanitized;
     }

packages/core/stellar/README.md

@@ -12,6 +12,7 @@ This package provides a programmatic API. For a web interface, see https://wizar
 
 The following contract types are supported:
 - `fungible`
+- `nonFungible`
 
 Each contract type has functions/constants as defined below.
 

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

@@ -5,19 +5,19 @@ import { requireAccessControl } from './set-access-control';
 import { defineFunctions } from './utils/define-functions';
 
 export function addPausable(c: ContractBuilder, access: Access) {
-  c.addUseClause('openzeppelin_pausable', 'self', { alias: 'pausable' });
-  c.addUseClause('openzeppelin_pausable', 'Pausable');
+  c.addUseClause('stellar_pausable', 'self', { alias: 'pausable' });
+  c.addUseClause('stellar_pausable', 'Pausable');
 
   const pausableTrait = {
-    name: 'Pausable',
-    for: c.name,
+    traitName: 'Pausable',
+    structName: c.name,
     tags: ['contractimpl'],
     section: 'Utils',
   };
 
-  c.addFunction(pausableTrait, functions.paused);
-  c.addFunction(pausableTrait, functions.pause);
-  c.addFunction(pausableTrait, functions.unpause);
+  c.addTraitFunction(pausableTrait, functions.paused);
+  c.addTraitFunction(pausableTrait, functions.pause);
+  c.addTraitFunction(pausableTrait, functions.unpause);
 
   requireAccessControl(c, pausableTrait, functions.pause, access, 'caller');
   requireAccessControl(c, pausableTrait, functions.unpause, access, 'caller');

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

@@ -0,0 +1,30 @@
+import { getSelfArg } from './common-options';
+import type { Access } from './set-access-control';
+import { requireAccessControl } from './set-access-control';
+import type { ContractBuilder } from './contract';
+import { defineFunctions } from './utils/define-functions';
+
+export function addUpgradeable(c: ContractBuilder, access: Access) {
+  const functions = defineFunctions({
+    _require_auth: {
+      args: [getSelfArg(), { name: 'operator', type: '&Address' }],
+      code: ['operator.require_auth();'],
+    },
+  });
+
+  c.addUseClause('stellar_upgradeable', 'UpgradeableInternal');
+  c.addUseClause('stellar_upgradeable_macros', 'Upgradeable');
+
+  c.addDerives('Upgradeable');
+
+  const upgradeableTrait = {
+    traitName: 'UpgradeableInternal',
+    structName: c.name,
+    tags: [],
+    section: 'Utils',
+  };
+
+  c.addTraitFunction(upgradeableTrait, functions._require_auth);
+
+  requireAccessControl(c, upgradeableTrait, functions._require_auth, access, '*operator');
+}

packages/core/stellar/src/api.ts

@@ -1,6 +1,8 @@
 import type { CommonContractOptions } from './common-options';
 import type { FungibleOptions } from './fungible';
+import type { NonFungibleOptions } from './non-fungible';
 import { printFungible, defaults as fungibledefaults } from './fungible';
+import { printNonFungible, defaults as nonFungibledefaults } from './non-fungible';
 
 export interface WizardContractAPI<Options extends CommonContractOptions> {
   /**
@@ -23,8 +25,14 @@ export interface AccessControlAPI<Options extends CommonContractOptions> {
 }
 
 export type Fungible = WizardContractAPI<FungibleOptions>; // TODO add AccessControlAPI<FungibleOptions> when access control is implemented, if useful
+export type NonFungible = WizardContractAPI<NonFungibleOptions>;
 
 export const fungible: Fungible = {
   print: printFungible,
   defaults: fungibledefaults,
 };
+
+export const nonFungible: NonFungible = {
+  print: printNonFungible,
+  defaults: nonFungibledefaults,
+};

packages/core/stellar/src/build-generic.ts

@@ -1,8 +1,11 @@
 import type { FungibleOptions } from './fungible';
 import { buildFungible } from './fungible';
+import type { NonFungibleOptions } from './non-fungible';
+import { buildNonFungible } from './non-fungible';
 
 export interface KindedOptions {
   Fungible: { kind: 'Fungible' } & FungibleOptions;
+  NonFungible: { kind: 'NonFungible' } & NonFungibleOptions;
 }
 
 export type GenericOptions = KindedOptions[keyof KindedOptions];
@@ -11,9 +14,13 @@ export function buildGeneric(opts: GenericOptions) {
   switch (opts.kind) {
     case 'Fungible':
       return buildFungible(opts);
+
+    case 'NonFungible':
+      return buildNonFungible(opts);
+
     default: {
-      const _: never = opts.kind; // TODO: When there are additional kinds above, change this assignment to just `opts` instead of `opts.kind`
-      throw new Error('Unknown ERC');
+      const _: never = opts;
+      throw new Error('Unknown kind');
     }
   }
 }

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

@@ -1,6 +1,6 @@
 import test from 'ava';
 
-import type { BaseFunction, BaseImplementedTrait } from './contract';
+import type { BaseFunction, BaseTraitImplBlock } from './contract';
 import { ContractBuilder } from './contract';
 import { printContract } from './print';
 
@@ -23,39 +23,41 @@ test('contract with constructor code with semicolon', t => {
 
 test('contract with function code before', t => {
   const Foo = new ContractBuilder('Foo');
-  const trait: BaseImplementedTrait = {
-    name: 'External',
-    for: 'ExternalTrait',
+  const trait: BaseTraitImplBlock = {
+    traitName: 'External',
+    structName: 'ExternalTrait',
     tags: ['othertag', 'contractimpl'],
   };
-  Foo.addImplementedTrait(trait);
+  Foo.addTraitImplBlock(trait);
   const fn: BaseFunction = {
+    pub: false,
     name: 'someFunction',
     args: [],
     code: ['someFunction()'],
   };
-  Foo.addFunction(trait, fn);
-  Foo.addFunctionTag(trait, fn, 'functiontag');
-  Foo.addFunctionCodeBefore(trait, fn, ['before()']);
+  Foo.addTraitFunction(trait, fn);
+  Foo.addFunctionTag(fn, 'functiontag', trait);
+  Foo.addFunctionCodeBefore(fn, ['before()'], trait);
   t.snapshot(printContract(Foo));
 });
 
 test('contract with function code before with semicolons', t => {
   const Foo = new ContractBuilder('Foo');
-  const trait: BaseImplementedTrait = {
-    name: 'External',
-    for: 'ExternalTrait',
+  const trait: BaseTraitImplBlock = {
+    traitName: 'External',
+    structName: 'ExternalTrait',
     tags: ['othertag', 'contractimpl'],
   };
-  Foo.addImplementedTrait(trait);
+  Foo.addTraitImplBlock(trait);
   const fn: BaseFunction = {
+    pub: false,
     name: 'someFunction',
     args: [],
     code: ['someFunction();'],
   };
-  Foo.addFunction(trait, fn);
-  Foo.addFunctionTag(trait, fn, 'functiontag');
-  Foo.addFunctionCodeBefore(trait, fn, ['before();']);
+  Foo.addTraitFunction(trait, fn);
+  Foo.addFunctionTag(fn, 'functiontag', trait);
+  Foo.addFunctionCodeBefore(fn, ['before();'], trait);
   t.snapshot(printContract(Foo));
 });