update dependencies, code structure, tests, README

Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "fungible-token"
+version = "1.0.0"
+authors = ["Near Inc <[email protected]>"]
+edition = "2018"
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+near-sdk = "5.5.0"
+near-contract-standards = "5.5.0"
+
+[dev-dependencies] 
+near-sdk = { version = "5.5.0", features = ["unit-testing"] }
+near-workspaces = { version = "0.14.1", features = ["unstable"] }
+anyhow = "1.0"
+tokio = { version = "1.41.0", features = ["full"] }

README.md

@@ -1,144 +1,58 @@
-Fungible Token (FT)
-===================
+Fungible Token (FT) Example 👋 
 
-Example implementation of a [Fungible Token] contract which uses [near-contract-standards] and [simulation] tests. This is a contract-only example.
+[![](https://img.shields.io/badge/⋈%20Examples-Basics-green)](https://docs.near.org/tutorials/welcome)
+[![](https://img.shields.io/badge/Contract-Rust-red)](contract-rs)
 
-  [Fungible Token]: https://nomicon.io/Standards/FungibleToken/Core
-  [near-contract-standards]: https://github.com/near/near-sdk-rs/tree/master/near-contract-standards
-  [simulation]: https://github.com/near/near-sdk-rs/tree/master/near-sdk-sim
+This repository contains an example implementation of a [fungible token] contract in Rust which uses [near-contract-standards] and workspaces-rs tests.
 
-Prerequisites
-=============
+[fungible token]: https://nomicon.io/Standards/FungibleToken/Core
+[near-contract-standards]: https://github.com/near/near-sdk-rs/tree/master/near-contract-standards
+[near-workspaces-rs]: https://github.com/near/near-workspaces-rs
 
-If you're using Gitpod, you can skip this step.
+<br />
 
-1. Make sure Rust is installed per the prerequisites in [`near-sdk-rs`](https://github.com/near/near-sdk-rs#pre-requisites)
-2. Ensure `near-cli` is installed by running `near --version`. If not installed, install with: `npm install -g near-cli`
+## How to Build Locally?
 
-## Building
+Install [`cargo-near`](https://github.com/near/cargo-near) and run:
 
-To build run:
 ```bash
-./scripts/build.sh
+cargo near build
 ```
 
-Using this contract
-===================
-
-### Quickest deploy
-
-You can build and deploy this smart contract to a development account. [Dev Accounts](https://docs.near.org/concepts/basics/account#dev-accounts) are auto-generated accounts to assist in developing and testing smart contracts. Please see the [Standard deploy](#standard-deploy) section for creating a more personalized account to deploy to.
+## How to Test Locally?
 
 ```bash
-near dev-deploy --wasmFile res/fungible_token.wasm --helperUrl https://near-contract-helper.onrender.com
+cargo test
 ```
 
-Behind the scenes, this is creating an account and deploying a contract to it. On the console, notice a message like:
+## How to Deploy?
 
->Done deploying to dev-1234567890123
-
-In this instance, the account is `dev-1234567890123`. A file has been created containing a key pair to
-the account, located at `neardev/dev-account`. To make the next few steps easier, we're going to set an
-environment variable containing this development account id and use that when copy/pasting commands.
-Run this command to the environment variable:
+To deploy manually, install [`cargo-near`](https://github.com/near/cargo-near) and run:
 
 ```bash
-source neardev/dev-account.env
-```
-
-You can tell if the environment variable is set correctly if your command line prints the account name after this command:
-```bash
-echo $CONTRACT_NAME
-```
+# Create a new account
+cargo near create-dev-account
 
-The next command will initialize the contract using the `new` method:
+# Deploy the contract on it
+cargo near deploy <contract-account-id>
 
-```bash
-near call $CONTRACT_NAME new '{"owner_id": "'$CONTRACT_NAME'", "total_supply": "1000000000000000", "metadata": { "spec": "ft-1.0.0", "name": "Example Token Name", "symbol": "EXLT", "decimals": 8 }}' --accountId $CONTRACT_NAME
+# Initialize the contract
+near call <contract-account-id> new '{"owner_id": "<contract-account-id>", "total_supply": "1000000000000000", "metadata": { "spec": "ft-1.0.0", "name": "Example Token Name", "symbol": "EXLT", "decimals": 8 }}' --accountId <contract-account-id>
 ```
 
-To get the fungible token metadata:
-
+## Basic methods
 ```bash
-near view $CONTRACT_NAME ft_metadata
-```
-
-### Standard deploy
-
-This smart contract will get deployed to your NEAR account. For this example, please create a new NEAR account. Because NEAR allows the ability to upgrade contracts on the same account, initialization functions must be cleared. If you'd like to run this example on a NEAR account that has had prior contracts deployed, please use the `near-cli` command `near delete`, and then recreate it in Wallet. To create (or recreate) an account, please follow the directions on [NEAR Wallet](https://wallet.near.org/).
-
-Switch to `mainnet`. You can skip this step to use `testnet` as a default network.
-
-    export NEAR_ENV=mainnet
-
-In the project root, log in to your newly created account  with `near-cli` by following the instructions after this command:
-
-    near login
-
-To make this tutorial easier to copy/paste, we're going to set an environment variable for your account id. In the below command, replace `MY_ACCOUNT_NAME` with the account name you just logged in with, including the `.near`:
-
-    ID=MY_ACCOUNT_NAME
-
-You can tell if the environment variable is set correctly if your command line prints the account name after this command:
-
-    echo $ID
-
-Now we can deploy the compiled contract in this example to your account:
-
-    near deploy --wasmFile res/fungible_token.wasm --accountId $ID
-
-FT contract should be initialized before usage. You can read more about metadata at ['nomicon.io'](https://nomicon.io/Standards/FungibleToken/Metadata.html#reference-level-explanation). Modify the parameters and create a token:
-
-    near call $ID new '{"owner_id": "'$ID'", "total_supply": "1000000000000000", "metadata": { "spec": "ft-1.0.0", "name": "Example Token Name", "symbol": "EXLT", "decimals": 8 }}' --accountId $ID
-
-Get metadata:
-
-    near view $ID ft_metadata
+# View metadata
+near view <contract-account-id> ft_metadata
 
+# Make a storage deposit
+near call <contract-account-id> storage_deposit '' --accountId <account-id> --amount 0.00125
 
-Transfer Example
----------------
+# View balance
+near view <contract-account-id> ft_balance_of '{"account_id": "<account-id>"}'
 
-Let's set up an account to transfer some tokens to. These account will be a sub-account of the NEAR account you logged in with.
-
-    near create-account bob.$ID --masterAccount $ID --initialBalance 1
-
-Add storage deposit for Bob's account:
-
-    near call $ID storage_deposit '' --accountId bob.$ID --amount 0.00125
-
-
-Check balance of Bob's account, it should be `0` for now:
-
-    near view $ID ft_balance_of '{"account_id": "'bob.$ID'"}'
-
-Transfer tokens to Bob from the contract that minted these fungible tokens, exactly 1 yoctoNEAR of deposit should be attached:
-
-    near call $ID ft_transfer '{"receiver_id": "'bob.$ID'", "amount": "19"}' --accountId $ID --amount 0.000000000000000000000001
-
-
-Check the balance of Bob again with the command from before and it will now return `19`.
-
-## Testing
-
-As with many Rust libraries and contracts, there are tests in the main fungible token implementation at `ft/src/lib.rs`.
-
-Additionally, this project has [simulation] tests in `tests/sim`. Simulation tests allow testing cross-contract calls, which is crucial to ensuring that the `ft_transfer_call` function works properly. These simulation tests are the reason this project has the file structure it does. Note that the root project has a `Cargo.toml` which sets it up as a workspace. `ft` and `test-contract-defi` are both small & focused contract projects, the latter only existing for simulation tests. The root project imports `near-sdk-sim` and tests interaction between these contracts.
-
-You can run unit tests with the following command:
-
-```bash
-cd ft && cargo test -- --nocapture --color=always
-```
-
-You can run integration tests with the following commands:
-*Rust*
-```bash
-cd integration-tests/rs && cargo run --example integration-tests
-```
-*TypeScript*
-```bash
-cd integration-tests/ts && yarn && yarn test
+# Transfer tokens
+near call <contract-account-id> ft_transfer '{"receiver_id": "<account-id>", "amount": "19"}' --accountId <contract-account-id> --amount 0.000000000000000000000001
 ```
 
 ## Notes
@@ -147,14 +61,13 @@ cd integration-tests/ts && yarn && yarn test
  - JSON calls should pass U128 as a base-10 string. E.g. "100".
  - This does not include escrow functionality, as `ft_transfer_call` provides a superior approach. An escrow system can, of course, be added as a separate contract or additional functionality within this contract.
 
-## No AssemblyScript?
-
-[near-contract-standards] is currently Rust-only. We strongly suggest using this library to create your own Fungible Token contract to ensure it works as expected.
-
-Someday NEAR core or community contributors may provide a similar library for AssemblyScript, at which point this example will be updated to include both a Rust and AssemblyScript version.
-
-## Contributing
-
-When making changes to the files in `ft` or `test-contract-defi`, remember to use `./build.sh` to compile all contracts and copy the output to the `res` folder. If you forget this, **the simulation tests will not use the latest versions**.
+## Useful Links
 
-Note that if the `rust-toolchain` file in this repository changes, please make sure to update the `.gitpod.Dockerfile` to explicitly specify using that as default as well.
+- [cargo-near](https://github.com/near/cargo-near) - NEAR smart contract development toolkit for Rust
+- [near CLI](https://near.cli.rs) - Iteract with NEAR blockchain from command line
+- [NEAR Rust SDK Documentation](https://docs.near.org/sdk/rust/introduction)
+- [NEAR Documentation](https://docs.near.org)
+- [NEAR StackOverflow](https://stackoverflow.com/questions/tagged/nearprotocol)
+- [NEAR Discord](https://near.chat)
+- [NEAR Telegram Developers Community Group](https://t.me/neardev)
+- NEAR DevHub: [Telegram](https://t.me/neardevhub), [Twitter](https://twitter.com/neardevhub)