Draft: Add languages

packages/core/stellar/.gitignore

@@ -0,0 +1,4 @@
+/cache
+/artifacts
+/contracts/generated
+/openzeppelin-contracts.json

packages/core/stellar/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## Unreleased
+
+- Initial version. ([#439](https://github.com/OpenZeppelin/contracts-wizard/pull/439))

packages/core/stellar/NOTICE

@@ -0,0 +1,8 @@
+OpenZeppelin Contracts Wizard
+Copyright (C) 2021-2025  Zeppelin Group Ltd
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, version 3.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.

packages/core/stellar/README.md

@@ -0,0 +1,57 @@
+# OpenZeppelin Contracts Wizard for Stellar
+
+Interactively build a contract out of components from OpenZeppelin Stellar Soroban Contracts. Provide parameters and desired features for the kind of contract that you want, and the Wizard will generate all of the code necessary. The resulting code is ready to be compiled and deployed, or it can serve as a starting point and customized further with application specific logic.
+
+This package provides a programmatic API. For a web interface, see https://wizard.openzeppelin.com/stellar
+
+### Installation
+
+`npm install @openzeppelin/wizard-stellar`
+
+### Contract types
+
+The following contract types are supported:
+- `fungible`
+
+Each contract type has functions/constants as defined below.
+
+### Functions
+
+#### `print`
+```js
+function print(opts?: FungibleOptions): string
+```
+Returns a string representation of a contract generated using the provided options. If `opts` is not provided, uses [`defaults`](#defaults).
+
+#### `defaults`
+```js
+const defaults: Required<FungibleOptions>
+```
+The default options that are used for [`print`](#print).
+
+### Examples
+
+Import the contract type(s) (for example, `fungible`) that you want to use from the `@openzeppelin/wizard-stellar` package:
+
+```js
+import { fungible } from '@openzeppelin/wizard-stellar';
+```
+
+To generate the source code for an Fungible contract with all of the default settings:
+```js
+const contract = fungible.print();
+```
+
+To generate the source code for an Fungible contract with some custom settings:
+```js
+const contract = fungible.print({
+  pausable: true,
+});
+```
+or
+```js
+const contract = fungible.print({
+  ...fungible.defaults,
+  pausable: true,
+});
+```

packages/core/stellar/ava.config.js

@@ -0,0 +1,13 @@
+module.exports = {
+  extensions: ['ts'],
+  require: ['ts-node/register'],
+  watchmode: {
+    ignoreChanges: [
+      'contracts',
+      'artifacts',
+      'cache',
+    ],
+  },
+  timeout: '10m',
+  workerThreads: false,
+};

packages/core/stellar/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@openzeppelin/wizard-stellar",
+  "version": "0.0.1",
+  "description": "A boilerplate generator to get started with OpenZeppelin Stellar Soroban Contracts",
+  "license": "AGPL-3.0-only",
+  "repository": "https://github.com/OpenZeppelin/contracts-wizard",
+  "main": "dist/index.js",
+  "ts:main": "src/index.ts",
+  "files": [
+    "LICENSE",
+    "NOTICE",
+    "/dist",
+    "/src",
+    "!**/*.test.*"
+  ],
+  "scripts": {
+    "prepare": "tsc",
+    "prepublish": "rimraf dist *.tsbuildinfo",
+    "test": "ava",
+    "test:watch": "ava --watch",
+    "version": "node ../../../scripts/bump-changelog.js"
+  },
+  "devDependencies": {
+    "@types/node": "^18.0.0",
+    "@types/semver": "^7.5.7",
+    "ava": "^6.0.0",
+    "rimraf": "^5.0.0",
+    "ts-node": "^10.4.0",
+    "typescript": "^5.0.0",
+    "semver": "^7.6.0"
+  }
+}

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

@@ -0,0 +1,55 @@
+import { getSelfArg } from './common-options';
+import type { ContractBuilder } from './contract';
+import { Access, 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');
+
+  const pausableTrait = {
+    name: 'Pausable',
+    for: c.name,
+    tags: [
+      'contractimpl',
+    ],
+    section: 'Utils',
+  };
+
+  c.addFunction(pausableTrait, functions.paused);
+  c.addFunction(pausableTrait, functions.pause);
+  c.addFunction(pausableTrait, functions.unpause);
+
+  requireAccessControl(c, pausableTrait, functions.pause, access, 'caller');
+  requireAccessControl(c, pausableTrait, functions.unpause, access, 'caller');
+}
+
+const functions = defineFunctions({
+  paused: {
+    args: [
+      getSelfArg(),
+    ],
+    returns: 'bool',
+    code: [
+      'pausable::paused(e)'
+    ],
+  },
+  pause: {
+    args: [
+      getSelfArg(),
+      { name: 'caller', type: 'Address' },
+    ],
+    code: [
+      'pausable::pause(e, &caller)'
+    ],
+  },
+  unpause: {
+    args: [
+      getSelfArg(),
+      { name: 'caller', type: 'Address' },
+    ],
+    code: [
+      'pausable::unpause(e, &caller)'
+    ],
+  },
+});

packages/core/stellar/src/api.ts

@@ -0,0 +1,29 @@
+import type { CommonContractOptions } from './common-options';
+import { printFungible, defaults as fungibledefaults, FungibleOptions } from './fungible';
+
+export interface WizardContractAPI<Options extends CommonContractOptions> {
+  /**
+   * Returns a string representation of a contract generated using the provided options. If opts is not provided, uses `defaults`.
+   */
+  print: (opts?: Options) => string;
+
+  /**
+   * The default options that are used for `print`.
+   */
+  defaults: Required<Options>;
+}
+
+export interface AccessControlAPI<Options extends CommonContractOptions> {
+  /**
+   * Whether any of the provided options require access control to be enabled. If this returns `true`, then calling `print` with the 
+   * same options would cause the `access` option to default to `'ownable'` if it was `undefined` or `false`.
+   */
+  isAccessControlRequired: (opts: Partial<Options>) => boolean;
+}
+
+export type Fungible = WizardContractAPI<FungibleOptions>; // TODO add AccessControlAPI<FungibleOptions> when access control is implemented, if useful
+
+export const fungible: Fungible = {
+  print: printFungible,
+  defaults: fungibledefaults,
+};

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

@@ -0,0 +1,18 @@
+import { FungibleOptions, buildFungible } from './fungible';
+
+export interface KindedOptions {
+  Fungible:    { kind: 'Fungible' }    & FungibleOptions;
+}
+
+export type GenericOptions = KindedOptions[keyof KindedOptions];
+
+export function buildGeneric(opts: GenericOptions) {
+  switch (opts.kind) {
+    case 'Fungible':
+      return buildFungible(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');
+  }
+}

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

@@ -0,0 +1,38 @@
+import type { Argument } from "./contract";
+import type { Access } from "./set-access-control";
+import type { Info } from "./set-info";
+import { defaults as infoDefaults } from "./set-info";
+
+export const defaults: Required<CommonOptions> = {
+  info: infoDefaults,
+} as const;
+
+export const contractDefaults: Required<CommonContractOptions> = {
+  ...defaults,
+  access: false,
+} as const;
+
+export interface CommonOptions {
+  info?: Info;
+}
+
+export interface CommonContractOptions extends CommonOptions {
+  access?: Access;
+}
+
+export function withCommonDefaults(opts: CommonOptions): Required<CommonOptions> {
+  return {
+    info: opts.info ?? defaults.info,
+  };
+}
+
+export function withCommonContractDefaults(opts: CommonContractOptions): Required<CommonContractOptions> {
+  return {
+    ...withCommonDefaults(opts),
+    access: opts.access ?? contractDefaults.access,
+  };
+}
+
+export function getSelfArg(): Argument {
+  return { name: 'e', type: '&Env' };
+}

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

@@ -0,0 +1,91 @@
+import test from 'ava';
+
+import { ContractBuilder, BaseFunction, BaseImplementedTrait } from './contract';
+import { printContract } from './print';
+
+test('contract basics', t => {
+  const Foo = new ContractBuilder('Foo');
+  t.snapshot(printContract(Foo));
+});
+
+test('contract with constructor code', t => {
+  const Foo = new ContractBuilder('Foo');
+  Foo.addConstructorCode('someFunction()');
+  t.snapshot(printContract(Foo));
+});
+
+test('contract with constructor code with semicolon', t => {
+  const Foo = new ContractBuilder('Foo');
+  Foo.addConstructorCode('someFunction();');
+  t.snapshot(printContract(Foo));
+});
+
+test('contract with function code before', t => {
+  const Foo = new ContractBuilder('Foo');
+  const trait: BaseImplementedTrait = {
+    name: 'External',
+    for: 'ExternalTrait',
+    tags: [
+      'othertag',
+      'contractimpl',
+    ],
+  };
+  Foo.addImplementedTrait(trait);
+  const fn: BaseFunction = {
+    name: 'someFunction',
+    args: [],
+    code: [
+      'someFunction()'
+    ]
+  };
+  Foo.addFunction(trait, fn);
+  Foo.addFunctionTag(trait, fn, 'functiontag');
+  Foo.addFunctionCodeBefore(trait, fn, ['before()']);
+  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',
+    tags: [
+      'othertag',
+      'contractimpl',
+    ],
+  };
+  Foo.addImplementedTrait(trait);
+  const fn: BaseFunction = {
+    name: 'someFunction',
+    args: [],
+    code: [
+      'someFunction();'
+    ]
+  };
+  Foo.addFunction(trait, fn);
+  Foo.addFunctionTag(trait, fn, 'functiontag');
+  Foo.addFunctionCodeBefore(trait, fn, ['before();']);
+  t.snapshot(printContract(Foo));
+});
+
+test('contract with standalone import', t => {
+  const Foo = new ContractBuilder('Foo');
+  Foo.addUseClause('some::library', 'SomeLibrary');
+  t.snapshot(printContract(Foo));
+});
+
+test('contract with grouped imports', t => {
+  const Foo = new ContractBuilder('Foo');
+  Foo.addUseClause('some::library', 'SomeLibrary');
+  Foo.addUseClause('some::library', 'Misc');
+  t.snapshot(printContract(Foo));
+});
+
+test('contract with sorted use clauses', t => {
+  const Foo = new ContractBuilder('Foo');
+  Foo.addUseClause('some::library', 'SomeLibrary');
+  Foo.addUseClause('another::library', 'AnotherLibrary');
+  Foo.addUseClause('another::library', 'self', { alias: 'custom2' });
+  Foo.addUseClause('another::library', 'self', { alias: 'custom1' });
+  t.snapshot(printContract(Foo));
+});