create-near-app 8.4.1 → 9.0.0

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

@@ -0,0 +1,47 @@
+# Basic Auction Contract
+
+This directory contains a JavaScript 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 the [NEAR CLI](https://docs.near.org/tools/near-cli#installation) and run:
+
+Install the dependencies:
+
+```bash
+npm install
+```
+
+Build the contract:
+
+```bash
+npm run build
+```
+
+## How to Test Locally?
+
+```bash
+npm run test
+```
+
+## How to Deploy?
+
+Install the [NEAR CLI](https://docs.near.org/tools/near-cli#installation) and run:
+
+```bash
+# Create a new account
+near create <contractId> --useFaucet
+
+# Deploy the contract
+near deploy <contractId> ./build/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/ts/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "auction-contract",
+  "version": "1.0.0",
+  "license": "(MIT AND Apache-2.0)",
+  "type": "module",
+  "scripts": {
+    "build": "near-sdk-js build src/contract.ts build/auction-contract.wasm",
+    "test": "$npm_execpath run build && ava -- ./build/auction-contract.wasm"
+  },
+  "dependencies": {
+    "near-sdk-js": "2.0.0"
+  },
+  "devDependencies": {
+    "ava": "^6.1.3",
+    "near-workspaces": "^3.5.0",
+    "typescript": "^5.4.5"
+  },
+  "ava": {
+    "timeout": "50000",
+    "files": ["sandbox-test/*.ava.js"]
+  }
+}

package/templates/contracts/auction/ts/sandbox-test/main.ava.js

@@ -0,0 +1,88 @@
+import anyTest from 'ava';
+import { NEAR, Worker } from 'near-workspaces';
+import { setDefaultResultOrder } from 'dns'; setDefaultResultOrder('ipv4first'); // temp fix for node >v17
+
+/**
+ *  @typedef {import('near-workspaces').NearAccount} NearAccount
+ *  @type {import('ava').TestFn<{worker: Worker, accounts: Record<string, NearAccount>}>}
+ */
+const test = anyTest;
+test.beforeEach(async (t) => {
+  // Init the worker and start a Sandbox server
+  const worker = t.context.worker = await Worker.init();
+
+  // Create accounts
+  const root = worker.rootAccount;
+
+  const alice = await root.createSubAccount("alice", { initialBalance: NEAR.parse("10 N").toString() });
+  const bob = await root.createSubAccount("bob", { initialBalance: NEAR.parse("10 N").toString() });
+  const auctioneer = await root.createSubAccount("auctioneer", { initialBalance: NEAR.parse("10 N").toString() });
+  const contract = await root.createSubAccount("contract", { initialBalance: NEAR.parse("10 N").toString() });
+
+  // Deploy contract (input from package.json)
+  await contract.deploy(process.argv[2]);
+
+  // Initialize contract, finishes in 1 minute
+  await contract.call(contract, "init", {
+    end_time: String((Date.now() + 60000) * 10 ** 6),
+    auctioneer: auctioneer.accountId,
+  });
+
+  // Save state for test runs, it is unique for each test
+  t.context.worker = worker;
+  t.context.accounts = { alice, bob, contract, auctioneer };
+});
+
+test.afterEach.always(async (t) => {
+  // Stop Sandbox server
+  await t.context.worker.tearDown().catch((error) => {
+    console.log('Failed to stop the Sandbox:', error);
+  });
+});
+
+test("Test full contract", async (t) => {
+  const { alice, bob, auctioneer, contract } = t.context.accounts;
+
+  // Alice makes first bid
+  await alice.call(contract, "bid", {}, { attachedDeposit: NEAR.parse("1 N").toString() });
+  let highest_bid = await contract.view("get_highest_bid", {});
+  t.is(highest_bid.bidder, alice.accountId);
+  t.is(highest_bid.bid, NEAR.parse("1 N").toString());
+  const aliceBalance = await alice.balance();
+
+  // Bob makes a higher bid
+  await bob.call(contract, "bid", {}, { attachedDeposit: NEAR.parse("2 N").toString() });
+  highest_bid = await contract.view("get_highest_bid", {});
+  t.is(highest_bid.bidder, bob.accountId);
+  t.is(highest_bid.bid, NEAR.parse("2 N").toString());
+
+  // Check that alice was returned her bid
+  const aliceNewBalance = await alice.balance();
+  t.deepEqual(aliceNewBalance.available, aliceBalance.available.add(NEAR.parse("1 N")));
+
+  // Alice tires to make a bid with less NEAR than the previous 
+  await t.throwsAsync(alice.call(contract, "bid", {}, { attachedDeposit: NEAR.parse("1 N").toString() }));
+
+  // Auctioneer claims auction but did not finish
+  await t.throwsAsync(auctioneer.call(contract, "claim", {}, { gas: "300000000000000" }));
+
+  // Fast forward 200 blocks
+  await t.context.worker.provider.fastForward(200)
+
+  const auctioneerBalance = await auctioneer.balance();
+  const available = parseFloat(auctioneerBalance.available.toHuman());
+
+  // Auctioneer claims the auction
+  await auctioneer.call(contract, "claim", {}, { gas: "300000000000000" });
+
+  // Checks that the auctioneer has the correct balance
+  const contractNewBalance = await auctioneer.balance();
+  const new_available = parseFloat(contractNewBalance.available.toHuman());
+  t.is(new_available.toFixed(1), (available + 2).toFixed(1));
+
+  // Auctioneer tries to claim the auction again
+  await t.throwsAsync(auctioneer.call(contract, "claim", {}, { gas: "300000000000000" }))
+
+  // Alice tries to make a bid when the auction is over
+  await t.throwsAsync(alice.call(contract, "bid", {}, { attachedDeposit: NEAR.parse("1 N").toString() }));
+});

package/templates/contracts/auction/ts/src/contract.ts

@@ -0,0 +1,72 @@
+// Find all our documentation at https://docs.near.org
+import { NearBindgen, near, call, view, AccountId, NearPromise, initialize, assert } from "near-sdk-js";
+
+class Bid {
+  bidder: AccountId;
+  bid: bigint;
+}
+
+@NearBindgen({ requireInit: true })
+class AuctionContract {
+  highest_bid: Bid = { bidder: '', bid: BigInt(0) };
+  auction_end_time: bigint = BigInt(0);
+  auctioneer: AccountId = "";
+  claimed: boolean = false;
+
+  @initialize({ privateFunction: true })
+  init({ end_time, auctioneer}: { end_time: bigint, auctioneer: AccountId}) {
+    this.auction_end_time = end_time;
+    this.highest_bid = { bidder: near.currentAccountId(), bid: BigInt(1) };
+    this.auctioneer = auctioneer;
+  }
+
+  @call({ payableFunction: true })
+  bid(): NearPromise {
+    // Assert the auction is still ongoing
+    assert(this.auction_end_time > near.blockTimestamp(), "Auction has ended");
+
+    // Current bid
+    const bid = near.attachedDeposit();
+    const bidder = near.predecessorAccountId();
+
+    // Last bid
+    const { bidder: lastBidder, bid: lastBid } = this.highest_bid;
+
+    // Check if the deposit is higher than the current bid
+    assert(bid > lastBid, "You must place a higher bid");
+
+    // Update the highest bid
+    this.highest_bid = { bidder, bid }; // Save the new bid
+
+    // Transfer tokens back to the last bidder
+    return NearPromise.new(lastBidder).transfer(lastBid);
+  }
+
+  @call({})
+  claim() {
+    assert(this.auction_end_time <= near.blockTimestamp(), "Auction has not ended yet");
+    assert(!this.claimed, "Auction has been claimed");
+    this.claimed = true;
+    return NearPromise.new(this.auctioneer).transfer(this.highest_bid.bid)
+  }
+
+  @view({})
+  get_highest_bid(): Bid {
+    return this.highest_bid;
+  }
+
+  @view({})
+  get_auction_end_time(): BigInt {
+    return this.auction_end_time;
+  }
+
+  @view({})
+  get_auctioneer(): AccountId {
+    return this.auctioneer;
+  }
+
+  @view({})
+  get_claimed(): boolean {
+    return this.claimed;
+  }
+}

package/templates/contracts/auction/ts/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "target": "ES5",
+    "noEmit": true,
+    "noImplicitAny": false,
+  },
+  "files": [
+    "src/contract.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ],
+}

package/templates/contracts/{rs → auction-adv/rs}/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "hello-rs"
+name = "cargo-near-new-project-name"
 description = "cargo-near-new-project-description"
 version = "0.1.0"
 edition = "2021"
@@ -15,9 +15,9 @@ crate-type = ["cdylib", "rlib"]
 # 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.16.0-rust-1.86.0"
+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:3220302ebb7036c1942e772810f21edd9381edf9a339983da43487c77fbad488"
+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
@@ -36,13 +36,15 @@ container_build_command = [
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [dependencies]
-near-sdk = "5.14"
+near-sdk = "5.23"
 
 [dev-dependencies]
-near-sdk = { version = "5.14", features = ["unit-testing"] }
-near-workspaces = { version = "0.20", features = ["unstable"] }
+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"] }
-serde_json = "1"
+testresult = "0.4.1"
 
 [profile.release]
 codegen-units = 1

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

@@ -0,0 +1,35 @@
+# Auction contract with FTs
+
+This directory contains a Rust contract that is used as part of the [Bidding with FTs](https://docs.near.org/tutorials/auction/bidding-with-fts) section of the auction tutorial.
+
+In this part the contract is adapted so users can bid in fungible tokens (FTs) instead of NEAR tokens. It is a great way to learn how to work with FTs in NEAR.
+
+## 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>", "ft_contract": "<ftContractId>", "nft_contract": "<nftContractId>", "token_id": "<tokenId>", "starting_price": "<startingPrice>"}' --accountId <contractId>
+```

package/templates/contracts/{rs → auction-adv/rs}/rust-toolchain.toml

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

package/templates/contracts/auction-adv/rs/src/ext.rs

@@ -0,0 +1,17 @@
+// Find all our documentation at https://docs.near.org
+use near_sdk::json_types::U128;
+use near_sdk::{ext_contract, AccountId};
+
+use crate::TokenId;
+
+// FT interface for cross-contract calls
+#[ext_contract(ft_contract)]
+trait FT {
+    fn ft_transfer(&self, receiver_id: AccountId, amount: U128);
+}
+
+// NFT interface for cross-contract calls
+#[ext_contract(nft_contract)]
+trait NFT {
+    fn nft_transfer(&self, receiver_id: AccountId, token_id: TokenId);
+}

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

@@ -0,0 +1,159 @@
+// Find all our documentation at https://docs.near.org
+use near_sdk::json_types::{U128, U64};
+use near_sdk::{env, near, require, AccountId, Gas, NearToken, PanicOnDefault};
+
+pub mod ext;
+pub use crate::ext::*;
+
+#[near(serializers = [json, borsh])]
+#[derive(Clone)]
+pub struct Bid {
+    pub bidder: AccountId,
+    pub bid: U128,
+}
+
+pub type TokenId = String;
+
+#[near(contract_state, serializers = [json, borsh])]
+#[derive(PanicOnDefault)]
+pub struct Contract {
+    highest_bid: Bid,
+    auction_end_time: U64,
+    auctioneer: AccountId,
+    claimed: bool,
+    ft_contract: AccountId,
+    nft_contract: AccountId,
+    token_id: TokenId,
+}
+
+#[near]
+impl Contract {
+    #[init]
+    #[private] // only callable by the contract's account
+    pub fn init(
+        end_time: U64,
+        auctioneer: AccountId,
+        ft_contract: AccountId,
+        nft_contract: AccountId,
+        token_id: TokenId,
+        starting_price: U128,
+    ) -> Self {
+        Self {
+            highest_bid: Bid {
+                bidder: env::current_account_id(),
+                bid: starting_price,
+            },
+            auction_end_time: end_time,
+            auctioneer,
+            claimed: false,
+            ft_contract,
+            nft_contract,
+            token_id,
+        }
+    }
+
+    // Users bid by transferring FT tokens
+    pub fn ft_on_transfer(&mut self, sender_id: AccountId, amount: U128, msg: String) -> U128 {
+        require!(
+            env::block_timestamp() < self.auction_end_time.into(),
+            "Auction has ended"
+        );
+
+        let ft = env::predecessor_account_id();
+        require!(ft == self.ft_contract, "The token is not supported");
+
+        // 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!(amount > last_bid, "You must place a higher bid");
+
+        // Update the highest bid
+        self.highest_bid = Bid {
+            bidder: sender_id,
+            bid: amount,
+        };
+
+        // Transfer FTs back to the last bidder
+        let _ = ft_contract::ext(self.ft_contract.clone())
+            .with_attached_deposit(NearToken::from_yoctonear(1))
+            .with_static_gas(Gas::from_tgas(30))
+            .ft_transfer(last_bidder, last_bid);
+
+        U128(0)
+    }
+
+    pub fn claim(&mut self) {
+        require!(
+            env::block_timestamp() > self.auction_end_time.into(),
+            "Auction has not ended yet"
+        );
+
+        require!(!self.claimed, "Auction has been claimed");
+
+        self.claimed = true;
+
+        // Transfer FTs to the auctioneer
+        // Assumes the auctioneer account is already registered with the FT contract
+        let _ = ft_contract::ext(self.ft_contract.clone())
+            .with_attached_deposit(NearToken::from_yoctonear(1))
+            .with_static_gas(Gas::from_tgas(30))
+            .ft_transfer(self.auctioneer.clone(), self.highest_bid.bid);
+
+        // Transfer the NFT to the highest bidder
+        let _ = nft_contract::ext(self.nft_contract.clone())
+            .with_static_gas(Gas::from_tgas(30))
+            .with_attached_deposit(NearToken::from_yoctonear(1))
+            .nft_transfer(self.highest_bid.bidder.clone(), self.token_id.clone());
+    }
+
+    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_auction_info(&self) -> &Contract {
+        self
+    }
+}
+
+#[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 ft_contract: AccountId = "ft.near".parse().unwrap();
+        let nft_contract: AccountId = "nft.near".parse().unwrap();
+        let token_id: TokenId = "1".to_string();
+        let starting_price: U128 = U128(100);
+        let contract = Contract::init(
+            end_time.clone(),
+            alice.clone(),
+            ft_contract.clone(),
+            nft_contract.clone(),
+            token_id.clone(),
+            starting_price.clone(),
+        );
+
+        let default_bid = contract.get_highest_bid();
+        assert_eq!(default_bid.bidder, env::current_account_id());
+        assert_eq!(default_bid.bid, starting_price);
+
+        let auction_info = contract.get_auction_info();
+        assert_eq!(auction_info.auction_end_time, end_time);
+        assert_eq!(auction_info.auctioneer, alice);
+        assert_eq!(auction_info.ft_contract, ft_contract);
+        assert_eq!(auction_info.nft_contract, nft_contract);
+        assert_eq!(auction_info.token_id, token_id);
+        assert_eq!(auction_info.claimed, false);
+    }
+}