create-near-app 1.3.6 → 3.0.0-pre.7.0

package/README.md

@@ -25,12 +25,12 @@ Using [npm's npx](https://blog.npmjs.org/post/162869356040/introducing-npx-an-np
 
     yarn create near-app [options] new-awesome-project
 
-Without any options, this will create a project with a **vanilla JavaScript** frontend and an [AssemblyScript](https://docs.near.org/docs/roles/developer/contracts/assemblyscript) smart contract
+Without any options, this will create a project with a **vanilla JavaScript** frontend and an [AssemblyScript](https://docs.near.org/docs/develop/contracts/as/intro) smart contract
 
 Other options:
 
 * `--frontend=react` – use [React](https://reactjs.org/) for your frontend template
-* `--contract=rust` – use [Rust](https://docs.near.org/docs/roles/developer/contracts/near-sdk-rs) for your smart contract
+* `--contract=rust` – use [Rust](https://docs.near.org/docs/develop/contracts/rust/near-sdk-rs) for your smart contract
 
 
 Develop your own Dapp
@@ -64,7 +64,7 @@ about commit messages
 
 Real world examples can look like this:
 
-    chore: run tests on travis ci
+    chore: run tests with GitHub Actions
 
     fix(server): send cors headers
 

package/{common/contracts → contracts}/assemblyscript/README.md

@@ -13,13 +13,12 @@ Before you compile this code, you will need to install [Node.js] ≥ 12
 Exploring The Code
 ==================
 
-1. The main smart contract code lives in `assembly/index.ts`. You can compile
-   it with the `./compile` script.
+1. The main smart contract code lives in `assembly/index.ts`.
 2. Tests: You can run smart contract tests with the `./test` script. This runs
    standard AssemblyScript tests using [as-pect].
 
 
-  [smart contract]: https://docs.near.org/docs/roles/developer/contracts/intro
+  [smart contract]: https://docs.near.org/docs/develop/contracts/overview
   [AssemblyScript]: https://www.assemblyscript.org/
   [create-near-app]: https://github.com/near/create-near-app
   [Node.js]: https://nodejs.org/en/download/package-manager/

package/contracts/assemblyscript/assembly/__tests__/main.spec.ts

@@ -0,0 +1,11 @@
+import { set_greeting, get_greeting } from '..'
+
+describe('Greeting ', () => {
+  it('should get the default greeting', () => {
+    expect(get_greeting()).toBe('Hello')
+  })
+  it('should change the greeting', () => {
+    set_greeting('howdy')
+    expect(get_greeting()).toBe('howdy')
+  })
+})

package/contracts/assemblyscript/assembly/index.ts

@@ -0,0 +1,23 @@
+/*
+ * Example smart contract written in AssemblyScript
+ *
+ * Learn more about writing NEAR smart contracts with AssemblyScript:
+ * https://near-docs.io/develop/welcome
+ *
+ */
+
+import { logging, storage } from 'near-sdk-as'
+
+const DEFAULT_MESSAGE = 'Hello'
+
+// Public method - returns the greeting saved, defaulting to DEFAULT_MESSAGE
+export function get_greeting(): string {
+  return storage.getPrimitive<string>('message', DEFAULT_MESSAGE)
+}
+
+// Public method - accepts a greeting, such as 'howdy', and records it
+export function set_greeting(message: string): void {
+  // Use logging.log to record logs permanently to the blockchain!
+  logging.log(`Saving greeting '${message}'`)
+  storage.set<string>('message', message)
+}

package/{common/contracts → contracts}/assemblyscript/package.json

@@ -1,17 +1,13 @@
 {
   "name": "greeter",
-  "version": "0.0.1",
+  "version": "1.0.0",
   "license": "UNLICENSED",
   "private": true,
   "scripts": {
     "build": "asb",
-    "build:debug": "asb --target debug",
     "test": "asp --nologo"
   },
   "dependencies": {
-    "near-sdk-as": "2.2.4"
-  },
-  "devDependencies": {
-    "shelljs": "^0.8.4"
+    "near-sdk-as": "^3.2.3"
   }
 }

package/{common/contracts → contracts}/rust/Cargo.toml

@@ -1,23 +1,22 @@
 [package]
 name = "greeter"
-version = "0.1.0"
+version = "1.0.0"
 authors = ["Near Inc <hello@near.org>"]
-edition = "2018"
+edition = "2021"
 
 [lib]
 crate-type = ["cdylib", "rlib"]
 
 [dependencies]
-near-sdk = "2.0.1"
+near-sdk = "4.0.0"
+uint = { version = "0.9.3", default-features = false }
 
 [profile.release]
 codegen-units = 1
-# Tell `rustc` to optimize for small code size.
 opt-level = "z"
 lto = true
 debug = false
 panic = "abort"
-# Opt into extra safety checks on arithmetic operations https://stackoverflow.com/a/64136471/249801
 overflow-checks = true
 
 [workspace]

package/{common/contracts → contracts}/rust/README.md

@@ -13,14 +13,13 @@ Before you compile this code, you will need to install Rust with [correct target
 Exploring The Code
 ==================
 
-1. The main smart contract code lives in `src/lib.rs`. You can compile it with
-   the `./compile` script.
+1. The main smart contract code lives in `src/lib.rs`.
 2. Tests: You can run smart contract tests with the `./test` script. This runs
    standard Rust tests using [cargo] with a `--nocapture` flag so that you
    can see any debug info you print to the console.
 
 
-  [smart contract]: https://docs.near.org/docs/roles/developer/contracts/intro
+  [smart contract]: https://docs.near.org/docs/develop/contracts/overview
   [Rust]: https://www.rust-lang.org/
   [create-near-app]: https://github.com/near/create-near-app
   [correct target]: https://github.com/near/near-sdk-rs#pre-requisites

package/contracts/rust/src/lib.rs

@@ -0,0 +1,72 @@
+/*
+ * Example smart contract written in RUST
+ *
+ * Learn more about writing NEAR smart contracts with Rust:
+ * https://near-docs.io/develop/Contract
+ *
+ */
+
+use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
+use near_sdk::{log, near_bindgen};
+
+// Define the default message
+const DEFAULT_MESSAGE: &str = "Hello";
+
+// Define the contract structure
+#[near_bindgen]
+#[derive(BorshDeserialize, BorshSerialize)]
+pub struct Contract {
+    message: String,
+}
+
+// Define the default, which automatically initializes the contract
+impl Default for Contract{
+    fn default() -> Self{
+        Self{message: DEFAULT_MESSAGE.to_string()}
+    }
+}
+
+// Implement the contract structure
+#[near_bindgen]
+impl Contract {
+    // Public method - returns the greeting saved, defaulting to DEFAULT_MESSAGE
+    pub fn get_greeting(&self) -> String {
+        return self.message.clone();
+    }
+
+    // Public method - accepts a greeting, such as "howdy", and records it
+    pub fn set_greeting(&mut self, message: String) {
+        // Use env::log to record logs permanently to the blockchain!
+        log!("Saving greeting {}", message);
+        self.message = message;
+    }
+}
+
+/*
+ * The rest of this file holds the inline tests for the code above
+ * Learn more about Rust tests: https://doc.rust-lang.org/book/ch11-01-writing-tests.html
+ */
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn get_default_greeting() {
+        let contract = Contract::default();
+        // this test did not call set_greeting so should return the default "Hello" greeting
+        assert_eq!(
+            contract.get_greeting(),
+            "Hello".to_string()
+        );
+    }
+
+    #[test]
+    fn set_then_get_greeting() {
+        let mut contract = Contract::default();
+        contract.set_greeting("howdy".to_string());
+        assert_eq!(
+            contract.get_greeting(),
+            "howdy".to_string()
+        );
+    }
+}

package/index.js

@@ -1,24 +1,26 @@
 #!/usr/bin/env node
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
 const yargs = require('yargs')
-const { basename, resolve } = require('path')
+
 const replaceInFiles = require('replace-in-files')
-const ncp = require('ncp').ncp
-ncp.limit = 16
-const fs = require('fs')
 const spawn = require('cross-spawn')
 const chalk = require('chalk')
 const which = require('which')
-const sh = require('shelljs')
-const path = require('path')
+const ncp = require('ncp').ncp
+ncp.limit = 16
 
-const renameFile = async function(oldPath, newPath) {
+const rustSetup = require('./utils/rust-setup')
+const mixpanel = require('./utils/tracking')
+
+const renameFile = async function (oldPath, newPath) {
   return new Promise((resolve, reject) => {
     fs.rename(oldPath, newPath, (err) => {
       if (err) {
         console.error(err)
         return reject(err)
       }
-      console.log(`Renamed ${oldPath} to ${newPath}`)
       resolve()
     })
   })
@@ -26,7 +28,7 @@ const renameFile = async function(oldPath, newPath) {
 
 // Wrap `ncp` tool to wait for the copy to finish when using `await`
 // Allow passing `skip` variable to skip copying an array of filenames
-function copyDir (source, dest, { skip, veryVerbose } = {}) {
+function copyDir(source, dest, { skip, veryVerbose } = {}) {
   return new Promise((resolve, reject) => {
     const copied = []
     const skipped = []
@@ -51,65 +53,50 @@ function copyDir (source, dest, { skip, veryVerbose } = {}) {
   })
 }
 
-const createProject = async function({ contract, frontend, projectDir, veryVerbose }) {
-  const templateDir = `/templates/${frontend}`
-  const sourceTemplateDir = __dirname + templateDir
-
-  console.log(`Copying files to new project directory (${projectDir}) from template source (${sourceTemplateDir}).`)
-
-  await copyDir(sourceTemplateDir, projectDir, { veryVerbose, skip: [
-    // our frontend templates are set up with symlinks for easy development,
-    // developing right in these directories also results in build artifacts;
-    // we don't want to copy these
-    path.join(sourceTemplateDir, '.cache'),
-    path.join(sourceTemplateDir, 'dist'),
-    path.join(sourceTemplateDir, 'out'),
-    path.join(sourceTemplateDir, 'node_modules'),
-    path.join(sourceTemplateDir, 'yarn.lock'),
-    path.join(sourceTemplateDir, 'package-lock.json'),
-    path.join(sourceTemplateDir, 'contract'),
-    ...sh.ls(`${__dirname}/common/frontend`).map(f => path.join('src', f))
-  ]})
-
-
-  // copy common files
-  await copyDir(`${__dirname}/common/frontend`, `${projectDir}/src`)
-  const contractSourceDir = `${__dirname}/common/contracts/${contract}`
-  await copyDir(contractSourceDir, `${projectDir}/contract`, { veryVerbose, skip: [
-    // as above, skip rapid-development build artifacts
-    path.join(contractSourceDir, 'node_modules'),
-    path.join(contractSourceDir, 'yarn.lock'),
-    path.join(contractSourceDir, 'package-lock.json'),
-  ]})
-
-  // update package name
-  let projectName = basename(resolve(projectDir))
-  await replaceInFiles({
-    files: [
-      // NOTE: These can use globs if necessary later
-      `${projectDir}/README.md`,
-      `${projectDir}/package.json`,
-      `${projectDir}/contract/README.md`,
-      `${projectDir}/src/config.js`,
-      `${projectDir}/src/App.vue`,
-      `${projectDir}/angular.json`,
-      `${projectDir}/karma.conf.js`,
-      `${projectDir}/set-contract-name.js`,
-    ],
-    from: /near-blank-project/g,
-    to: projectName
-  })
+const createProject = async function ({ contract, frontend, projectDir, veryVerbose }) {
+  if (os.platform() === 'win32') {
+    console.log('Sorry, create-near-app is not compatible with Windows. Please consider using Windows Subsystem for Linux.\n')
+    return
+  }
+  // track used options
+  mixpanel.track(frontend, contract)
+
+  console.log(chalk`Creating {bold ${projectDir}} with a contract in {bold ${contract}}, and a frontend using {bold ${frontend} js}.`)
+  console.log('Remember that you can change these settings using the --frontend and --contract flags. \n')
+
+  // skip rapid-development build artifacts and symlinks
+  const skip = ['.cache', 'dist', 'out', 'node_modules', 'yarn.lock', 'package-lock.json', 'contract', 'integration-tests']
 
+  // copy frontend
+  const sourceTemplateDir = __dirname + `/templates/${frontend}`
+  await copyDir(sourceTemplateDir, projectDir, { veryVerbose, skip: skip.map(f => path.join(sourceTemplateDir, f)) })
+
+  // copy tests
+  const sourceTestDir = __dirname + '/integration-tests'
+  await copyDir(sourceTestDir, `${projectDir}/integration-tests`, { veryVerbose, skip: skip.map(f => path.join(sourceTestDir, f)) })
+
+  // copy contract files
+  const contractSourceDir = `${__dirname}/contracts/${contract}`
+  await copyDir(contractSourceDir, `${projectDir}/contract`, { veryVerbose, skip: skip.map(f => path.join(contractSourceDir, f)) })
+
+  // changes in package.json for rust
   if (contract === 'rust') {
-    await replaceInFiles({ files: `${projectDir}/src/**/*`, from: /getGreeting/g, to: 'get_greeting' })
-    await replaceInFiles({ files: `${projectDir}/src/**/*`, from: /setGreeting/g, to: 'set_greeting' })
-    await replaceInFiles({ files: `${projectDir}/src/**/*`, from: /{ accountId:/g, to: '{ account_id:' })
-    await replaceInFiles({ files: `${projectDir}/package.json`, from: 'cd contract && npm run test', to: 'cd contract && cargo test -- --nocapture' })
-    await replaceInFiles({ files: `${projectDir}/package.json`, from: 'watch contract -e ts', to: 'watch contract/src -e rs' })
+    await replaceInFiles({
+      files: `${projectDir}/package.json`,
+      from: 'cd contract && npm run build && mkdir -p ../out && rm -f ./out/main.wasm && cp ./build/release/greeter.wasm ../out/main.wasm',
+      to: 'mkdir -p out && cd contract && rustup target add wasm32-unknown-unknown && cargo build --all --target wasm32-unknown-unknown --release && rm -f ./out/main.wasm && cp ./target/wasm32-unknown-unknown/release/greeter.wasm ../out/main.wasm'
+    })
+    await replaceInFiles({
+      files: `${projectDir}/package.json`,
+      from: '"test:unit": "cd contract && npm i && npm run test"',
+      to: '"test:unit": "cd contract && cargo test"'
+    })
   }
 
+  // add .gitignore
   await renameFile(`${projectDir}/near.gitignore`, `${projectDir}/.gitignore`)
-  console.log('Copying project files complete.\n')
+
+  console.log('Project created! Lets set it up.\n')
 
   const hasNpm = which.sync('npm', { nothrow: true })
   const hasYarn = which.sync('yarn', { nothrow: true })
@@ -119,6 +106,12 @@ const createProject = async function({ contract, frontend, projectDir, veryVerbo
     await replaceInFiles({ files: `${projectDir}/README.md`, from: /npm\b( run)?/g, to: 'yarn' })
   }
 
+  // setup rust
+  let wasRustupInstalled = false
+  if (contract === 'rust') {
+    wasRustupInstalled = await rustSetup.setupRustAndWasm32Target()
+  }
+
   if (hasNpm || hasYarn) {
     console.log('Installing project dependencies...')
     spawn.sync(hasYarn ? 'yarn' : 'npm', ['install'], { cwd: projectDir, stdio: 'inherit' })
@@ -129,6 +122,7 @@ const createProject = async function({ contract, frontend, projectDir, veryVerbo
 
   const runCommand = hasYarn ? 'yarn' : 'npm run'
 
+  // print success message
   console.log(chalk`
 Success! Created ${projectDir}
 Inside that directory, you can run several commands:
@@ -140,34 +134,37 @@ Inside that directory, you can run several commands:
   {bold ${runCommand} test}
     Starts the test runner.
 
-  {bold ${runCommand} deploy}
-    Deploys contract in permanent location (as configured in {bold src/config.js}).
-    Also deploys web frontend using GitHub Pages.
-    Consult with {bold README.md} for details on how to deploy and {bold package.json} for full list of commands.
-
-We suggest that you begin by typing:
-
-  {bold cd ${projectDir}}
-  {bold ${runCommand} dev}
+We suggest that you begin by typing:`)
+
+  if (wasRustupInstalled) {
+    console.log(chalk`
+    {bold source $HOME/.cargo/env}
+    {bold cd ${projectDir}}
+    {bold ${runCommand} dev}`)
+  } else {
+    console.log(chalk`
+    {bold cd ${projectDir}}
+    {bold ${runCommand} dev}`)
+  }
 
-Happy hacking!
-`)
+  console.log(chalk`
+Happy hacking!`)
 }
 
 const opts = yargs
   .strict()
   .usage('$0 <projectDir>', 'Create a new NEAR project')
-// BUG: does not work; https://github.com/yargs/yargs/issues/1331
+  // BUG: does not work; https://github.com/yargs/yargs/issues/1331
   .example('$0 new-app', 'Create a project called "new-app"')
   .option('frontend', {
     desc: 'template to use',
-    choices: ['vanilla', 'react', 'vue', 'angular'],
+    choices: ['vanilla', 'react'],
     default: 'vanilla',
   })
   .option('contract', {
     desc: 'language for smart contract',
     choices: ['assemblyscript', 'rust'],
-    default: 'assemblyscript'
+    default: 'rust'
   })
   .option('very-verbose', {
     desc: 'turn on very verbose logging',

package/integration-tests/rs/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "integration-tests"
+version = "1.0.0"
+publish = false
+edition = "2018"
+
+[dev-dependencies]
+anyhow = "1.0"
+borsh = "0.9"
+maplit = "1.0"
+near-units = "0.2.0"
+# arbitrary_precision enabled for u128 types that workspaces requires for Balance types
+serde_json = { version = "1.0", features = ["arbitrary_precision"] }
+tokio = { version = "1.18.1", features = ["full"] }
+tracing = "0.1"
+tracing-subscriber = { version = "0.3.11", features = ["env-filter"] }
+workspaces = "0.2.1"
+pkg-config = "0.3.1"
+
+[[example]]
+name = "integration-tests"
+path = "src/tests.rs"

package/integration-tests/rs/src/tests.rs

@@ -0,0 +1,66 @@
+use near_units::parse_near;
+use serde_json::json;
+use workspaces::prelude::*;
+use workspaces::{network::Sandbox, Account, Contract, Worker};
+
+const WASM_FILEPATH: &str = "../../out/main.wasm";
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let worker = workspaces::sandbox().await?;
+    let wasm = std::fs::read(WASM_FILEPATH)?;
+    let contract = worker.dev_deploy(&wasm).await?;
+
+    // create accounts
+    let owner = worker.root_account();
+    let alice = owner
+        .create_subaccount(&worker, "alice")
+        .initial_balance(parse_near!("30 N"))
+        .transact()
+        .await?
+        .into_result()?;
+
+    // begin tests
+    test_default_message(&alice, &contract, &worker).await?;
+    test_changes_message(&alice, &contract, &worker).await?;
+    Ok(())
+}
+
+async fn test_default_message(
+    user: &Account,
+    contract: &Contract,
+    worker: &Worker<Sandbox>,
+) -> anyhow::Result<()> {
+    let message: String = user
+        .call(&worker, contract.id(), "get_greeting")
+        .args_json(json!({}))?
+        .transact()
+        .await?
+        .json()?;
+
+    assert_eq!(message, "Hello".to_string());
+    println!("      Passed ✅ gets default message");
+    Ok(())
+}
+
+async fn test_changes_message(
+    user: &Account,
+    contract: &Contract,
+    worker: &Worker<Sandbox>,
+) -> anyhow::Result<()> {
+    user.call(&worker, contract.id(), "set_greeting")
+        .args_json(json!({"message": "Howdy"}))?
+        .transact()
+        .await?;
+
+    let message: String = user
+        .call(&worker, contract.id(), "get_greeting")
+        .args_json(json!({}))?
+        .transact()
+        .await?
+        .json()?;
+
+    assert_eq!(message, "Howdy".to_string());
+    println!("      Passed ✅ changes message");
+    Ok(())
+}

package/integration-tests/ts/ava.config.cjs

@@ -0,0 +1,9 @@
+require("util").inspect.defaultOptions.depth = 5; // Increase AVA's printing depth
+
+module.exports = {
+  timeout: "300000",
+  files: ["src/*.ava.ts"],
+  failWithoutAssertions: false,
+  extensions: ["ts"],
+  require: ["ts-node/register"],
+};

package/integration-tests/ts/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "ava-testing",
+  "version": "1.0.0",
+  "license": "(MIT AND Apache-2.0)",
+  "scripts": {
+    "test": "ava --verbose"
+  },
+  "devDependencies": {
+    "ava": "^4.2.0",
+    "near-workspaces": "^2.0.0",
+    "typescript": "^4.7.2",
+    "ts-node": "^10.8.0",
+    "@types/bn.js": "^5.1.0"
+  },
+  "dependencies": {}
+}

package/integration-tests/ts/src/main.ava.ts

@@ -0,0 +1,44 @@
+import { Worker, NEAR, NearAccount } from 'near-workspaces'
+import anyTest, { TestFn } from 'ava'
+
+const test = anyTest as TestFn<{
+  worker: Worker;
+  accounts: Record<string, NearAccount>;
+}>
+
+test.beforeEach(async (t) => {
+  // Init the worker and start a Sandbox server
+  const worker = await Worker.init()
+
+  // deploy contract
+  const root = worker.rootAccount
+  const contract = await root.createAndDeploy(
+    root.getSubAccount('greeter').accountId,
+    './out/main.wasm',
+    { initialBalance: NEAR.parse('30 N').toJSON() }
+  )
+
+  // Save state for test runs, it is unique for each test
+  t.context.worker = worker
+  t.context.accounts = { root, contract }
+})
+
+test.afterEach(async (t) => {
+  // Stop Sandbox server
+  await t.context.worker.tearDown().catch((error) => {
+    console.log('Failed to stop the Sandbox:', error)
+  })
+})
+
+test('returns the default greeting', async (t) => {
+  const { contract } = t.context.accounts
+  const message: string = await contract.view('get_greeting', {})
+  t.is(message, 'Hello')
+})
+
+test('changes the message', async (t) => {
+  const { root, contract } = t.context.accounts
+  await root.call(contract, 'set_greeting', { message: 'Howdy' })
+  const message: string = await contract.view('get_greeting', {})
+  t.is(message, 'Howdy')
+})