Near Grant Program

[layla1994]

What is the name of your project?
BytePay
Are you applying for a grant (non-equity) or venture funding (equity)?
Grant
Grant Category
NFT

Please describe your project in 2-3 sentences.
Coding to earn, sell opensource product as NFT!
BytePay is a platform that supports paid tasks to complete open-source projects on Github.
You can not only code to earn but also sell open-source product as NFT.

Let’s get to know each other :) What is your name?
First Name Richard
Last Name Fang

Provide a link to your social media account (Twitter, LinkedIn etc)
Account will be provided in private.

Richard Fang:
Fugen Wang:
Yang Li:
Sun Long:
Wei Zhang:
Layla Zhou:

Contact Email
[email protected]

Tell us more about your rockstar team and your achievements
Richard Fang: Team leader, core developer. As an expert in the field of cloud computing in one of the biggest Internet listed companies with 7 years of rich working experience. The author of a well-known cloud native project which has more than 8K stars and 4K paid enterprise users.
Fugen Wang: Background development. CEO of an Internet start-up company and manages more than a dozen employees with 7 years working experience.
Yang Li: Front-end development. Android/IOS front-end engineer with 5 years working experience.
Sun Long: A core member of AI Research Institute which is one of the top AI-listed companies in China with 5 years working experience.
Wei Zhang: An advertising director, one of the top AI-listed companies in China with 7 years of rich working experience.
Layla Zhou: PD/PMO. Familiar with product design and project schedule management.

Github - Team Members
Richard Fang: https://github.com/fanux
Fugen Wang: https://github.com/maslow
Yang Li: https://github.com/geekFeier
Sun Long: https://github.com/sulnong
Wei Zhang: N/A
Layla Zhou: https://github.com/layla1994

How much funding are you requesting?
45,000 USD

What are you building and why?

BytePay is a platform that supports paid tasks to complete open-source projects on Github.
Our mission is to make open source better with the ecosystem of multiple public-chain ：

• Attract more Github developers, especially those who are not familiar with blockchain to expand the user number of NEAR ecosystem.
• Coding to earn! Earn tokens by completing open-source tasks to encourage Github developers to communicate, cooperate and innovate with each other.
• Open-source project owners also can sell open-source products as NFT to hire more developers to contribute to the project.

What makes you different from your competitors? Why are you the one? :)
There are 5 outstanding engineers from top global companies in our team. We all have passion in crypto and we have strong ambition to make it success.
As far as we are concerned, there are no similar projects in NEAR ecosystem.
In crypto industry, Gitcoin is the direct competitor to BytePay. However, Gitcoin does not release open source project products as NFTs, it only solves the problem of developer remuneration, and does not solve the problem of how to commercialize software owners, and Gitcoin will not support cryptocurrency payments other than GTC.
In traditional industries, the biggest competitor to BytePay is Github Sponsor. It does not support payment by cryptocurrency.

What are your project milestones and estimated budget for each step (Please list)? And when are the expected delivery dates for each milestone?

Overview
Total Estimated Duration: 10 weeks
Full-time equivalent (FTE): 5
Total Costs: 45,000 USD

Milestone 1 — User account management & repo management & mnemonic management & Transfer contract
Estimated Duration: 4 weeks
FTE: 5
Costs: 15,000 USD

• User management, create an NEAR account for each developer
  We will provide login function, you can login our website using Github, and we will create a NEAR account for each user by default
• Repo & webhook management
  We will fetch your GitHub repo list, so you can activate the repo you want to integrate with NEAR, the webhook module will listen to the pay event and trigger the transform module to pay developer NEAR
• Address binding
  Develop using GitHub issue comments to bind their NEAR address.
• Recharge management
  Recharge NEAR to your platform account
• Transfer contract
  We will provide a contract, provide transfer limit, whitelist, and transfer function.

Milestone 2 — Transfer module, task module, informal, withdraw module
Estimated Duration: 4 weeks
FTE: 5
Costs: 15,000 USD

• Task management
  Create a paid task by comment an issue, it will trigger the create task event through the webhook, and the webhook server will save the task and show it on our page, when the developer complete the task, will trigger transfer module to pay the developer
• Transfer module
  Trigger a payment by comment an issue, like /pay Bob NEAR, the NEAR will be transferred to the developer platform account
• Withdraw module
  Withdraw the NEAR from our platform to developer's own wallet, if the developer bind its own address, payment will be transferred to the account directly
• Informal
  The developer will receive the event, tell him how to withdraw NEAR from our platform, the robot will comment on the issue.

Milestone 3 — NFT
Estimated Duration: 2 weeks
FTE: 5
Costs: 15,000 USD
Open-source product NFT

• Mint NFT
  Using Open-source Product like bin apk docker image to mint NFT.
  Mange the NFT price, circulation, and other metadata.

• NFT market
  Marketplace to show all open-source NFTs, and search NFT what you want.

• NFT details and buy NFT
  Details to show the NFT metadata like price, owner, version.
  Anyone can buy what open-source product they need.

Which components of the project will be open source? Please provide as much detail as possible.
BytePay is 100% open-source. Details can be found above (milestone 1- 3).

How will this impact the NEAR Ecosystem?

1. It enables all open-source project owners to pay developers with NEAR token by BytePay, thus attracting more developers to use NEAR token.
2. It enables owners of NEAR ecosystem projects to pay developers by BytePay. Therefore, more and more developers will take part in NEAR ecosystem projects.

让更多项目的owner使用near支付开源开发者酬劳，从而让更多开发者使用near token.
near生态的项目可以使用bytepay来吸引更多开发者参与生态开发

What makes you excited about NEAR?

1. Developer friendly, simple to use. It has an enthusiastic and large developer community as well as very good tools support.
2. There are great number of good projects and active global users in NEAR ecosystem.
3. NEAR’s sharded infrastructure scales infinitely with low, stable gas fees.

near的友好的开发体验，完善的开发者社区和工具链，以及庞大的生态项目和活跃用户
near无限扩展的分片机制

How will you measure project success?
怎么衡量项目的成功，下面是提示：比如注册人数，活跃用户数，near生态影响等
（What will success look like for your project? An example can be number of sign ups, active users, total TVL, NEAR ecosystem impact etc.）
In the year of 2023, we believe we can achieve

1. 500 open-source projects support BytePay
2. 50,000 registered developers get paid by using BytePay
3. 100,000$ monthly transaction volume

2023:

1. 500个开源项目使用bytepay
2. 50k开发者注册bytepay并使用bytepay赚取酬劳
3. 100k$每个月的支付流水

Are you currently raising a round? (or do you have plans to do so in the future)
No.

How did you hear about the NEAR Grants Program?
Github.

Did someone refer you to the NF Grants Program?
No.

[layla1994]

done

[hankeke]

Bytepay
Laf
Doc

Milestone 1 — User account management & repo management & mnemonic management & Transfer contract

• User management, create an NEAR account for each developer
  We will provide login function, you can login our website using Github, and we will create a NEAR account for each user by default
  

• Repo & webhook management
  We will fetch your GitHub repo list, so you can activate the repo you want to integrate with NEAR, the webhook module will listen to the pay event and trigger the transform module to pay developer NEAR
  
  

• Address binding
  /bytepay bind near 5DTestUPts3kjeXSTMyerHihn1uwMfLj8vU8sqF7qYrFabHE
  

• Recharge management
  Withdraw the NEAR from our platform to developer's own wallet, if the developer bind its own address, payment will be transferred to the account directly
  

• Transfer contract
  We will provide a contract, provide transfer limit, whitelist, and transfer function.

1. config env

  Near cli : https://gist.github.com/think-in-universe/019671d56a949ec8a475126f22d21248
  export NEAR_CLI_MAINNET_RPC_SERVER_URL=https://public-rpc.blockpi.io/http/near
  export NEAR_ENV=mainnet

 near deploy --accountId ff3e8979eb1eac55858651bb40e51760bdfcf12ef57b1edbdd75f53fb0ed6c06 --wasmFile ./build/bytepay_contract_near.wasm

  Near cli : https://gist.github.com/think-in-universe/019671d56a949ec8a475126f22d21248
  export NEAR_CLI_TESTNET_RPC_SERVER_URL=https://public-rpc.blockpi.io/http/near-testnet
  export NEAR_ENV=testnet
  near deploy --accountId lafyun.testnet  --wasmFile ./build/bytepay_contract_near.wasm

2. contract code

pub mod bytepay_near {
    use near_sdk::{AccountId, Balance, env, log, near_bindgen, Promise};
    use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
    use near_sdk::collections::LookupMap;

    near_sdk::setup_alloc!();

    #[near_bindgen]
    #[derive(BorshDeserialize, BorshSerialize)]
    pub struct BytePayNearContract {
        pub owner: AccountId,
        pub balances: LookupMap<AccountId, Balance>,
        pub whitelist: LookupMap<(AccountId, AccountId), Balance>,
    }

    impl Default for BytePayNearContract {
        fn default() -> Self {
            Self {
                owner: env::current_account_id(),
                balances: LookupMap::new(b"b".to_vec()),
                whitelist: LookupMap::new(b"w".to_vec()),
            }
        }
    }

    #[near_bindgen]
    impl BytePayNearContract {
        pub fn get_owner(&self) -> AccountId {
            self.owner.clone()
        }

        pub fn get_balance(&self, account: &AccountId) -> Option<Balance> {
            self.balances.get(&account)
        }

        pub fn get_whitelist(&self, current: AccountId, account: AccountId) -> Option<Balance> {
            self.whitelist.get(&(current, account))
        }

        pub fn recharge(&mut self, amount: Balance) -> &'static str {
            let signer_account = env::signer_account_id();
            let balance = self.balances.get(&signer_account).unwrap_or_default();

            Promise::new(env::current_account_id()).transfer(amount);
            self.balances.insert(&signer_account, &(amount + balance));

            "END"
        }

        pub fn set_whitelist(&mut self, account: AccountId, amount: Balance) -> &'static str {
            let signer_account = env::signer_account_id();
            let balances = self.balances.get(&signer_account).unwrap_or_default();

            if amount > balances {
                log!("INSUFFICIENT_BALANCE");
                return "INSUFFICIENT_BALANCE";
            }
            let key = (signer_account, account);
            let old = self.whitelist.get(&key).unwrap_or_default();
            self.whitelist.insert(&key, &(old + amount));

            "END"
        }

        pub fn transfer(&mut self, from: AccountId, to: AccountId, amount: Balance) -> &'static str {
            let call = env::signer_account_id();
            let current = env::current_account_id();
            if call != current {
                log!("PERMISSION_DENIED");
                return "PERMISSION_DENIED";
            }

            let key = (from.clone(), to.clone());
            let limit = self.whitelist.get(&key).unwrap_or_default();

            let zero = Balance::from('0');
            if amount < zero || (limit == zero && amount > limit) {
                log!("EXCEED_THE_LIMIT");
                return "EXCEED_THE_LIMIT";
            }

            Promise::new(to).transfer(amount);

            let balance = self.balances.get(&from).unwrap_or_default();
            self.balances.insert(&from, &(balance - amount));

            "END"
        }
    }

    /// test
    #[cfg(not(target_arch = "wasm32"))]
    #[cfg(test)]
    mod bytepay_near_test {
        use near_sdk::{testing_env, VMContext};
        use near_sdk::MockedBlockchain;

        use super::*;

       // use serde_json::to_string;

        fn get_context(input: Vec<u8>, is_view: bool) -> VMContext {
            VMContext {
                current_account_id: String::from("合约拥有者账户"),
                signer_account_id: String::from("签名账户"),
                signer_account_pk: vec![0, 1, 2],
                predecessor_account_id: String::from("前任账户"),
                input,
                block_index: 0,
                block_timestamp: 0,
                account_balance: 1000000,
                account_locked_balance: 0,
                storage_usage: 0,
                attached_deposit: 0,
                prepaid_gas: 10u64.pow(18),
                random_seed: vec![0, 1, 2],
                is_view,
                output_data_receivers: vec![],
                epoch_height: 0,
            }
        }

        /// 测试充值
        #[test]
        fn test_recharge() {
            let context = get_context(vec![], false);
            testing_env!(context);
            let mut contract = BytePayNearContract::default();
            // --------------------------------------------------------------------------
            let msg = contract.recharge(233);
            println!("回执消息: {}", msg);
            let balance = contract.get_balance(&AccountId::from("签名账户")).unwrap_or_default();
            assert_eq!(balance, 233);
        }

        /// 测试设置白名单
        #[test]
        fn test_set_whitelist() {
            let context = get_context(vec![], false);
            testing_env!(context);
            let mut contract = BytePayNearContract::default();
            // --------------------------------------------------------------------------

            let limit = 0;
            let msg = contract.set_whitelist(AccountId::from("test-account.near.org"), limit);
            println!("设置白名单回执消息: {}", msg);
            assert_eq!(msg, "END");

            let option = contract.get_whitelist(AccountId::from("签名账户"), AccountId::from("test-account.near.org"));
            assert_eq!(option.unwrap_or_default(), limit)
        }

        /// 测试转账
        #[test]
        fn test_transfer() {
            let context = get_context(vec![], false);
            testing_env!(context);
            let mut contract = BytePayNearContract::default();
            // --------------------------------------------------------------------------

            let msg = contract.transfer(env::current_account_id(), AccountId::from("test-account.near.org"), 233);
            println!("回执: {}", msg)
        }
    }
}

3. test contract

cargo test --lib bytepay_near::bytepay_near_test::test_recharge -- --show-output
cargo test --lib bytepay_near::bytepay_near_test::test_set_whitelist -- --show-output
cargo test --lib bytepay_near::bytepay_near_test::test_transfer -- --show-output

4. view method

View contract owner: `get_owner`

Check balance: `get_balance`

**Parameter:**

| name    | type      |
|---------|-----------|
| account | AccountId |

#### View whitelist restrictions for a specified account: `get_whitelist`

**Parameter:**

| name    | type      | description  |
|---------|-----------|--------------|
| current | AccountId | current user |
| account | AccountId | target users |

### change method

#### Recharge: `recharge`

**Parameter:**

| name   | type    | 
|--------|---------|
| amount | Balance |

#### Set up a whitelist: `set_whitelist`

**Parameter:**

| name    | type      | description       |
|---------|-----------|-------------------|
| account | AccountId | target users      |
| amount  | Balance   | target user quota |

#### The contract administrator initiates a transfer transaction: `transfer`

**Parameter:**

| name   | type      | description |
|--------|-----------|-------------|
| from   | AccountId | payer       |
| to     | AccountId | payee       |
| amount | Balance   | money       |

use `near-cli` call example:

```shell
near view <contract_account> get_balance '{"account": "account.testnet"}'
```

Milestone 2 — Transfer module, task module, informal, withdraw module

• Task management
  Create a paid task by comment an issue, it will trigger the create task event through the webhook, and the webhook server will save the task and show it on our page, when the developer complete the task, will trigger transfer module to pay the developer
  
  
• Transfer module
  Trigger a payment by comment an issue, like /pay Bob NEAR, the NEAR will be transferred to the developer platform account
  1.bob apply this task
  /bytepay apply
  
  2./bytepay task pay
  /bytepay pay
  
• Withdraw module
  Withdraw the NEAR from our platform to developer's own wallet, if the developer bind its own address, payment will be transferred to the account directly