create-near-app 8.4.1 → 9.0.0

package/dist/app.js

@@ -40,12 +40,13 @@ const utils_1 = require("./utils");
     const prompt = await (0, user_input_1.promptAndGetConfig)();
     if (prompt === undefined)
         return;
-    const { config: { projectName, contract, frontend, install, }, projectPath, } = prompt;
+    const { config: { projectName, contract, template, frontend, install, }, projectPath, } = prompt;
     show.creatingApp();
     let createSuccess;
     try {
         createSuccess = await (0, make_1.createProject)({
             contract,
+            template: template || 'auction',
             frontend,
             templatesDir: path_1.default.resolve(__dirname, '../templates'),
             projectPath,

package/dist/make.js

@@ -32,44 +32,24 @@ const fs_1 = __importDefault(require("fs"));
 const ncp_1 = require("ncp");
 const path_1 = __importDefault(require("path"));
 const show = __importStar(require("./messages"));
-const utils_1 = require("./utils");
-async function createProject({ contract, frontend, projectPath, templatesDir }) {
+async function createProject({ contract, template, frontend, projectPath, templatesDir }) {
     if (contract !== 'none') {
-        await createContract({ contract, projectPath, templatesDir });
+        await createContract({ contract, template, projectPath, templatesDir });
     }
-    else {
+    else if (frontend !== 'none') {
         await createGateway({ frontend, projectPath, templatesDir });
     }
     return true;
 }
 exports.createProject = createProject;
-async function createContract({ contract, projectPath, templatesDir }) {
-    await createContractFromTemplate({ contract, projectPath, templatesDir });
-    if (contract === 'rs') {
-        await updateTemplateFiles(projectPath);
-    }
+async function createContract({ contract, template, projectPath, templatesDir }) {
+    await createContractFromTemplate({ contract, template, projectPath, templatesDir });
 }
-async function createContractFromTemplate({ contract, projectPath, templatesDir }) {
-    // contract folder
-    const sourceContractDir = path_1.default.resolve(templatesDir, 'contracts', contract);
+async function createContractFromTemplate({ contract, template, projectPath, templatesDir }) {
+    const sourceContractDir = path_1.default.resolve(templatesDir, 'contracts', template, contract);
     fs_1.default.mkdirSync(projectPath, { recursive: true });
     await copyDir(sourceContractDir, projectPath);
 }
-async function updateTemplateFiles(projectPath) {
-    const targetDir = path_1.default.join(projectPath);
-    const cargoTomlRemotePath = 'https://raw.githubusercontent.com/near/cargo-near/refs/heads/main/cargo-near/src/commands/new/new-project-template/Cargo.template.toml';
-    const cargoTomlFilePath = path_1.default.join(targetDir, 'Cargo.toml');
-    const rustToolchainRemotePath = 'https://raw.githubusercontent.com/near/cargo-near/refs/heads/main/cargo-near/src/commands/new/new-project-template/rust-toolchain.toml';
-    const rustToolchainFilePath = path_1.default.join(targetDir, 'rust-toolchain.toml');
-    show.updatingFiles();
-    try {
-        await (0, utils_1.downloadFile)(cargoTomlRemotePath, cargoTomlFilePath);
-        await (0, utils_1.downloadFile)(rustToolchainRemotePath, rustToolchainFilePath);
-    }
-    catch (err) {
-        show.updateFilesFailed();
-    }
-}
 async function createGateway({ frontend, projectPath, templatesDir }) {
     const sourceFrontendDir = path_1.default.resolve(`${templatesDir}/frontend/${frontend}`);
     fs_1.default.mkdirSync(projectPath, { recursive: true });

package/dist/messages.js

@@ -30,8 +30,6 @@ const mapContractLanguage = (contract) => {
             return 'Typescript';
         case 'rs':
             return 'Rust';
-        case 'py':
-            return 'Python';
         default:
             return '';
     }
@@ -76,9 +74,6 @@ const contractInstructions = (projectName, contract, install, needsToInstallCarg
     if (contract === 'ts') {
         message += (0, chalk_1.default) `         {blue npm {bold run build}}\n`;
     }
-    else if (contract === 'py') {
-        message += (0, chalk_1.default) `         {blue {bold uvx nearc contract.py --create-venv}}\n`;
-    }
     else {
         message += (0, chalk_1.default) `         {blue {bold cargo near build}}\n`;
     }
@@ -86,11 +81,8 @@ const contractInstructions = (projectName, contract, install, needsToInstallCarg
     if (contract === 'ts') {
         message += (0, chalk_1.default) `         {blue npm {bold run test}}\n`;
     }
-    else if (contract === 'py') {
-        message += (0, chalk_1.default) `         {blue {bold uv run pytest}}\n`;
-    }
     else {
-        message += (0, chalk_1.default) `         {blue {bold cargo near test}}\n`;
+        message += (0, chalk_1.default) `         {blue {bold cargo test}}\n`;
     }
     message += (0, chalk_1.default) `\n🧠 Read {bold {greenBright README.md}} to explore further`;
     return message;

package/dist/types.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.APPS = exports.FRONTENDS = exports.CONTRACTS = void 0;
-exports.CONTRACTS = ['ts', 'rs', 'py', 'none'];
+exports.APPS = exports.FRONTENDS = exports.TEMPLATES = exports.CONTRACTS = void 0;
+exports.CONTRACTS = ['ts', 'rs', 'none'];
+exports.TEMPLATES = ['auction', 'auction-adv'];
 exports.FRONTENDS = ['next-app', 'next-page', 'vite-react', 'none'];
 exports.APPS = ['contract', 'gateway'];
 //# sourceMappingURL=types.js.map

package/dist/user-input.js

@@ -37,32 +37,36 @@ const fs_1 = __importDefault(require("fs"));
 async function getUserArgs() {
     commander_1.program
         .argument('[projectName]')
-        .option('--frontend [next-page|next-app|none]')
+        .option('--frontend [next-page|next-app|vite-react|none]')
         .option('--contract [ts|rs|none]')
+        .option('--template [auction-adv|auction]')
         .option('--install')
         .addHelpText('after', 'You can create a frontend or a contract with tests');
     commander_1.program.parse();
     const options = commander_1.program.opts();
     const [projectName] = commander_1.program.args;
-    const { contract, frontend, install } = options;
-    return { contract, frontend, projectName, install, error: undefined };
+    const { contract, frontend, template, install } = options;
+    return { contract, frontend, template, projectName, install, error: undefined };
 }
 exports.getUserArgs = getUserArgs;
 const appChoices = [
-    { title: 'A Web App', description: 'A Web App that talks with Near contracts', value: 'gateway' },
+    { title: 'Web Application', description: 'A Web App that talks with Near contracts', value: 'gateway' },
     {
-        title: 'A Smart Contract', description: 'A smart contract to be deployed in the Near Blockchain', value: 'contract',
+        title: 'Smart Contract', description: 'A smart contract to be deployed in the Near Blockchain', value: 'contract',
     },
 ];
+const templateChoices = [
+    { title: 'Auction', description: 'A simple auction smart contract', value: 'auction' },
+    { title: 'Auction (advance)', description: 'An auction contract were users can bid with FT and the winner gets a NFT', value: 'auction-adv' },
+];
 const contractChoices = [
-    { title: 'JS/TS Contract', description: 'A Near contract written in javascript/typescript', value: 'ts' },
-    { title: 'Rust Contract', description: 'A Near contract written in Rust', value: 'rs' },
-    { title: 'Python Contract', description: 'A Near contract written in Python', value: 'py' },
+    { title: 'Rust (recommended)', description: 'A smart contract written in Rust', value: 'rs' },
+    { title: 'Typescript (experimental)', description: 'A smart contract written in typescript', value: 'ts' },
 ];
 const frontendChoices = [
+    { title: 'Vite (React)', description: 'A web-app built using Vite with React', value: 'vite-react' },
     { title: 'NextJs (Classic)', description: 'A web-app built using Next.js Page Router', value: 'next-page' },
     { title: 'NextJS (App Router)', description: 'A web-app built using Next.js new App Router', value: 'next-app' },
-    { title: 'Vite (React)', description: 'A web-app built using Vite with React', value: 'vite-react' },
 ];
 const appPrompt = {
     type: 'select',
@@ -70,6 +74,12 @@ const appPrompt = {
     message: 'What do you want to build?',
     choices: appChoices,
 };
+const templatePrompt = {
+    type: 'select',
+    name: 'template',
+    message: 'Select a contract template',
+    choices: templateChoices,
+};
 const frontendPrompt = {
     type: 'select',
     name: 'frontend',
@@ -80,7 +90,7 @@ const contractPrompt = [
     {
         type: 'select',
         name: 'contract',
-        message: 'Select a smart contract template for your project',
+        message: 'Select a language for your contract',
         choices: contractChoices,
     }
 ];
@@ -88,7 +98,7 @@ const namePrompts = {
     type: 'text',
     name: 'projectName',
     message: 'Name your project (we will create a directory with that name)',
-    initial: 'hello-near',
+    initial: 'near-template',
 };
 const npmPrompt = {
     type: 'confirm',
@@ -113,11 +123,12 @@ async function getUserAnswers() {
         if (process.platform === 'win32') {
             return { frontend: 'none', contract: 'none', projectName: '', install: false, error: show.windowsWarning };
         }
-        // If contract, ask for the language for the contract
+        // If contract, ask for the template and language
+        const { template } = await promptUser(templatePrompt);
         let { contract } = await promptUser(contractPrompt);
         const { projectName } = await promptUser(namePrompts);
         const install = contract === 'ts' ? (await promptUser(npmPrompt)).install : false;
-        return { frontend: 'none', contract, projectName, install, error: undefined };
+        return { frontend: 'none', contract, template, projectName, install, error: undefined };
     }
 }
 exports.getUserAnswers = getUserAnswers;
@@ -159,6 +170,10 @@ const validateUserArgs = (args) => {
         show.argsError(`Invalid contract type: ${args.contract}`);
         return false;
     }
+    if (args.template && !types_1.TEMPLATES.includes(args.template)) {
+        show.argsError(`Invalid template type: ${args.template}`);
+        return false;
+    }
     if (!args.projectName) {
         show.argsError('Please provide a project name');
         return false;
@@ -167,6 +182,10 @@ const validateUserArgs = (args) => {
         show.argsError('Please create a contract OR a frontend');
         return false;
     }
+    if (args.contract !== 'none' && !args.template) {
+        show.argsError('Please specify a template for your contract');
+        return false;
+    }
     return true;
 };
 //# sourceMappingURL=user-input.js.map

package/dist/utils/index.js

@@ -3,9 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isCargoNearInstalled = exports.downloadFile = void 0;
-const donwloadFile_1 = __importDefault(require("./donwloadFile"));
-exports.downloadFile = donwloadFile_1.default;
+exports.isCargoNearInstalled = void 0;
 const checkCargoNear_1 = __importDefault(require("./checkCargoNear"));
 exports.isCargoNearInstalled = checkCargoNear_1.default;
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-near-app",
-  "version": "8.4.1",
+  "version": "9.0.0",
   "description": "Quickly scaffold your dApp on NEAR Blockchain",
   "main": "index.js",
   "engines": {
@@ -44,6 +44,7 @@
     "@types/jest": "^29.5.2",
     "@types/ncp": "^2.0.5",
     "@types/node": "^20.3.2",
+    "@types/node-dir": "^0.0.37",
     "@types/prompts": "^2.4.4",
     "@types/semver": "^7.5.0",
     "eslint": "^8.43.0",

package/templates/contracts/auction/rs/Cargo.toml

@@ -0,0 +1,57 @@
+[package]
+name = "cargo-near-new-project-name"
+description = "cargo-near-new-project-description"
+version = "0.1.0"
+edition = "2021"
+# TODO: Fill out the repository field to help NEAR ecosystem tools to discover your project.
+# NEP-0330 is automatically implemented for all contracts built with https://github.com/near/cargo-near.
+# Link to the repository will be available via `contract_source_metadata` view-function.
+repository = "https://github.com/<xxx>/<xxx>"
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+# fields to configure build with WASM reproducibility, according to specs
+# in https://github.com/near/NEPs/blob/master/neps/nep-0330.md
+[package.metadata.near.reproducible_build]
+# docker image, descriptor of build environment
+image = "sourcescan/cargo-near:0.18.0-rust-1.86.0"
+# tag after colon above serves only descriptive purpose; image is identified by digest
+image_digest = "sha256:2d0d458d2357277df669eac6fa23a1ac922e5ed16646e1d3315336e4dff18043"
+# list of environment variables names, whose values, if set, will be used as external build parameters
+# in a reproducible manner
+# supported by `sourcescan/cargo-near:0.10.1-rust-1.82.0` image or later images
+passed_env = []
+# build command inside of docker container
+# if docker image from default gallery is used https://hub.docker.com/r/sourcescan/cargo-near/tags,
+# the command may be any combination of flags of `cargo-near`,
+# supported by respective version of binary inside the container besides `--no-locked` flag
+container_build_command = [
+    "cargo",
+    "near",
+    "build",
+    "non-reproducible-wasm",
+    "--locked",
+]
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[dependencies]
+near-sdk = "5.23"
+
+[dev-dependencies]
+near-sdk = { version = "5.23", features = ["unit-testing"] }
+near-sandbox = "0.3"
+near-api = "0.8"
+cargo-near-build = "0.9.0"
+tokio = { version = "1.12.0", features = ["full"] }
+testresult = "0.4.1"
+
+[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

package/templates/contracts/auction/rs/README.md

@@ -0,0 +1,39 @@
+# Basic Auction Contract 
+
+This directory contains a Rust contract that is used as part of the [Basic Auction Tutorial](https://docs.near.org/tutorials/auction/basic-auction).
+
+The contract is a simple auction where you can place bids, view the highest bid, and claim the tokens at the end of the auction.
+
+This repo showcases the basic anatomy of a contract including how to store data in a contract, how to update the state, and then how to view it. It also looks at how to use environment variables and macros. We have also written sandbox test the contract locally.
+
+---
+
+## How to Build Locally?
+
+Install [`cargo-near`](https://github.com/near/cargo-near) and run:
+
+```bash
+cargo near build
+```
+
+## How to Test Locally?
+
+```bash
+cargo test
+```
+
+## How to Deploy?
+
+To deploy manually, install [NEAR CLI](https://docs.near.org/tools/near-cli#installation) and run:
+
+```bash
+# Create a new account
+near create <contractId> --useFaucet
+
+# Deploy the contract on it
+near deploy <contractId> ./target/near/auction-contract.wasm
+
+# Initialize the contract
+TWO_MINUTES_FROM_NOW=$(date -v+2M +%s000000000)
+near call <contractId> init '{"end_time": "'$TWO_MINUTES_FROM_NOW'", "auctioneer": "<auctioneerAccountId>"}' --accountId <contractId>
+```

package/templates/contracts/auction/rs/rust-toolchain.toml

@@ -0,0 +1,4 @@
+[toolchain]
+channel = "1.86.0"
+components = ["rustfmt", "clippy", "rust-analyzer"]
+targets = ["wasm32-unknown-unknown"]

package/templates/contracts/auction/rs/src/lib.rs

@@ -0,0 +1,118 @@
+// Find all our documentation at https://docs.near.org
+use near_sdk::json_types::U64;
+use near_sdk::{env, near, require, AccountId, NearToken, PanicOnDefault, Promise};
+
+#[near(serializers = [json, borsh])]
+#[derive(Clone)]
+pub struct Bid {
+    pub bidder: AccountId,
+    pub bid: NearToken,
+}
+
+#[near(contract_state)]
+#[derive(PanicOnDefault)]
+pub struct Contract {
+    highest_bid: Bid,
+    auction_end_time: U64,
+    auctioneer: AccountId,
+    claimed: bool,
+}
+
+#[near]
+impl Contract {
+    #[init]
+    #[private] // only callable by the contract's account
+    pub fn init(end_time: U64, auctioneer: AccountId) -> Self {
+        Self {
+            highest_bid: Bid {
+                bidder: env::current_account_id(),
+                bid: NearToken::from_yoctonear(1),
+            },
+            auction_end_time: end_time,
+            claimed: false,
+            auctioneer,
+        }
+    }
+
+    #[payable]
+    pub fn bid(&mut self) -> Promise {
+        // Assert the auction is still ongoing
+        require!(
+            env::block_timestamp() < self.auction_end_time.into(),
+            "Auction has ended"
+        );
+
+        // Current bid
+        let bid = env::attached_deposit();
+        let bidder = env::predecessor_account_id();
+
+        // Last bid
+        let Bid {
+            bidder: last_bidder,
+            bid: last_bid,
+        } = self.highest_bid.clone();
+
+        // Check if the deposit is higher than the current bid
+        require!(bid > last_bid, "You must place a higher bid");
+
+        // Update the highest bid
+        self.highest_bid = Bid { bidder, bid };
+
+        // Transfer tokens back to the last bidder
+        Promise::new(last_bidder).transfer(last_bid)
+    }
+
+    pub fn claim(&mut self) -> Promise {
+        require!(
+            env::block_timestamp() > self.auction_end_time.into(),
+            "Auction has not ended yet"
+        );
+
+        require!(!self.claimed, "Auction has already been claimed");
+        self.claimed = true;
+
+        // Transfer tokens to the auctioneer
+        Promise::new(self.auctioneer.clone()).transfer(self.highest_bid.bid)
+    }
+
+    pub fn get_highest_bid(&self) -> Bid {
+        self.highest_bid.clone()
+    }
+
+    pub fn get_auction_end_time(&self) -> U64 {
+        self.auction_end_time
+    }
+
+    pub fn get_auctioneer(&self) -> AccountId {
+        self.auctioneer.clone()
+    }
+
+    pub fn get_claimed(&self) -> bool {
+        self.claimed
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn init_contract() {
+        let end_time: U64 = U64::from(1000);
+        let alice: AccountId = "alice.near".parse().unwrap();
+        let contract = Contract::init(end_time.clone(), alice.clone());
+
+        let default_bid = contract.get_highest_bid();
+        assert_eq!(default_bid.bidder, env::current_account_id());
+        assert_eq!(default_bid.bid, NearToken::from_yoctonear(1));
+
+        let auction_end_time = contract.get_auction_end_time();
+        assert_eq!(auction_end_time, end_time);
+
+        let auctioneer = contract.get_auctioneer();
+        assert_eq!(auctioneer, alice);
+
+        let claimed = contract.get_claimed();
+        assert_eq!(claimed, false);
+    }
+}

package/templates/contracts/auction/rs/tests/test_basics.rs

@@ -0,0 +1,182 @@
+use near_api::{AccountId, NearGas, NearToken};
+use near_sdk::serde_json::json;
+
+#[derive(near_sdk::serde::Deserialize)]
+#[serde(crate = "near_sdk::serde")]
+pub struct Bid {
+    pub bidder: AccountId,
+    pub bid: NearToken,
+}
+
+#[tokio::test]
+async fn test_contract_is_operational() -> testresult::TestResult<()> {
+    let contract_wasm_path = cargo_near_build::build_with_cli(Default::default())?;
+    let contract_wasm = std::fs::read(contract_wasm_path)?;
+
+    let sandbox = near_sandbox::Sandbox::start_sandbox().await?;
+    let sandbox_network =
+        near_api::NetworkConfig::from_rpc_url("sandbox", sandbox.rpc_addr.parse()?);
+
+    // Create accounts
+    let alice = create_subaccount(&sandbox, "alice.sandbox").await?;
+    let bob = create_subaccount(&sandbox, "bob.sandbox").await?;
+    let auctioneer = create_subaccount(&sandbox, "auctioneer.sandbox").await?;
+    let contract = create_subaccount(&sandbox, "contract.sandbox")
+        .await?
+        .as_contract();
+
+    // Deploy and initialize contract
+    let signer = near_api::Signer::from_secret_key(
+        near_sandbox::config::DEFAULT_GENESIS_ACCOUNT_PRIVATE_KEY
+            .parse()
+            .unwrap(),
+    )?;
+    let now = std::time::SystemTime::now()
+        .duration_since(std::time::SystemTime::UNIX_EPOCH)?
+        .as_secs();
+    let a_minute_from_now = (now + 60) * 1000000000;
+    near_api::Contract::deploy(contract.account_id().clone())
+        .use_code(contract_wasm)
+        .with_init_call(
+            "init",
+            json!({"end_time": a_minute_from_now.to_string(), "auctioneer": auctioneer.account_id()}),
+        )?
+        .with_signer(signer.clone())
+        .send_to(&sandbox_network)
+        .await?
+        .assert_success();
+
+    // Alice makes first bid
+    contract
+        .call_function("bid", ())
+        .transaction()
+        .deposit(NearToken::from_near(1))
+        .with_signer(alice.account_id().clone(), signer.clone())
+        .send_to(&sandbox_network)
+        .await?
+        .assert_success();
+
+    let highest_bid: Bid = contract
+        .call_function("get_highest_bid", ())
+        .read_only()
+        .fetch_from(&sandbox_network)
+        .await?
+        .data;
+    assert_eq!(highest_bid.bid, NearToken::from_near(1));
+    assert_eq!(&highest_bid.bidder, alice.account_id());
+
+    let alice_balance = alice
+        .tokens()
+        .near_balance()
+        .fetch_from(&sandbox_network)
+        .await?
+        .total;
+
+    // Bob makes a higher bid
+    contract
+        .call_function("bid", ())
+        .transaction()
+        .deposit(NearToken::from_near(2))
+        .with_signer(bob.account_id().clone(), signer.clone())
+        .send_to(&sandbox_network)
+        .await?
+        .assert_success();
+
+    let highest_bid: Bid = contract
+        .call_function("get_highest_bid", ())
+        .read_only()
+        .fetch_from(&sandbox_network)
+        .await?
+        .data;
+    assert_eq!(highest_bid.bid, NearToken::from_near(2));
+    assert_eq!(&highest_bid.bidder, bob.account_id());
+
+    // Check that Alice was refunded
+    let new_alice_balance = alice
+        .tokens()
+        .near_balance()
+        .fetch_from(&sandbox_network)
+        .await?
+        .total;
+
+    assert!(new_alice_balance == alice_balance.saturating_add(NearToken::from_near(1)));
+
+    // Alice tries to make a bid with less NEAR than the previous
+    contract
+        .call_function("bid", ())
+        .transaction()
+        .deposit(NearToken::from_near(1))
+        .with_signer(alice.account_id().clone(), signer.clone())
+        .send_to(&sandbox_network)
+        .await?
+        .assert_failure();
+
+    // Auctioneer claims auction but did not finish
+    contract
+        .call_function("claim", ())
+        .transaction()
+        .gas(NearGas::from_tgas(30))
+        .with_signer(auctioneer.account_id().clone(), signer.clone())
+        .send_to(&sandbox_network)
+        .await?
+        .assert_failure();
+
+    // Fast forward 200 blocks
+    let blocks_to_advance = 200;
+    sandbox.fast_forward(blocks_to_advance).await?;
+
+    // Auctioneer claims the auction
+    contract
+        .call_function("claim", ())
+        .transaction()
+        .gas(NearGas::from_tgas(30))
+        .with_signer(auctioneer.account_id().clone(), signer.clone())
+        .send_to(&sandbox_network)
+        .await?
+        .assert_success();
+
+    // Checks the auctioneer has the correct balance
+    let auctioneer_balance = auctioneer
+        .tokens()
+        .near_balance()
+        .fetch_from(&sandbox_network)
+        .await?
+        .total;
+    assert!(auctioneer_balance <= NearToken::from_near(12));
+    assert!(auctioneer_balance > NearToken::from_millinear(11990));
+
+    // Auctioneer tries to claim the auction again
+    contract
+        .call_function("claim", ())
+        .transaction()
+        .gas(NearGas::from_tgas(30))
+        .with_signer(auctioneer.account_id().clone(), signer.clone())
+        .send_to(&sandbox_network)
+        .await?
+        .assert_failure();
+
+    // Alice tries to make a bid when the auction is over
+    contract
+        .call_function("bid", ())
+        .transaction()
+        .deposit(NearToken::from_near(1))
+        .with_signer(alice.account_id().clone(), signer.clone())
+        .send_to(&sandbox_network)
+        .await?
+        .assert_failure();
+
+    Ok(())
+}
+
+async fn create_subaccount(
+    sandbox: &near_sandbox::Sandbox,
+    name: &str,
+) -> testresult::TestResult<near_api::Account> {
+    let account_id: AccountId = name.parse().unwrap();
+    sandbox
+        .create_account(account_id.clone())
+        .initial_balance(NearToken::from_near(10))
+        .send()
+        .await?;
+    Ok(near_api::Account(account_id))
+}