#[near_bindgen]
#[derive(BorshDeserialize, BorshSerialize)]
pub struct SimpleP2P {
    pub accounts: UnorderedMap<AccountId, AccountInformation>,
    pub historys: LookupMap<String, History>,
}

#[derive(BorshDeserialize, BorshSerialize)]
pub struct AccountInformation {
    pub balance: Balance,   
    pub available: Balance, 
    pub price: Balance,

    pub history_buy: Vector<String>,
    pub history_sell: Vector<String>,
    
    pub bank_number: String,
    pub bank_name: String,

    pub vote_up: u128,
    pub vote_down: u128,
}

#[derive(BorshDeserialize, BorshSerialize, Serialize, Deserialize)]
#[serde(crate = "near_sdk::serde")]
pub struct SellInformation {
    pub balance: Balance, 
    pub available: Balance,
    pub price: Balance,
    
    pub bank_number: String,
    pub bank_name: String,

    pub vote_up: u128,
    pub vote_down: u128,
}

#[derive(BorshDeserialize, BorshSerialize, Serialize, Deserialize)]
#[serde(crate = "near_sdk::serde")]
pub struct History {
    pub buyer: AccountId, 
    pub seller: AccountId,  
    pub amount: Balance,    
    pub price: Balance,
    pub value: Balance,
    pub state: String,      // init, processing, cancel, success,
}

#[near_bindgen]
impl SimpleP2P {
    #[init]
    pub fn new()->Self{}

    // create and deposit money
    #[payable]
    pub fn deposit(&mut self){}

    // withdraw money to near testnet wallet
    pub fn withdraw(&mut self, amount: u128){}

    // set bank number and bank name as payment method
    pub fn set_bank_account(&mut self, number: String, bank_name: String){}

    // place order sell
    pub fn order_sell(&mut self, amount: u128, price: u128){}

    // place order buy
    pub fn order_buy(&mut self, seller_id:AccountId, amount: u128){}

    // Buyer confirms that money has been sent 
    pub fn confirm_sent(&mut self, tx:String){}

    // Seller confirms receipt of the funds and the transaction is done 
    pub fn confirm_received(&mut self, tx: String){}

    // Buyer cancels buy order 
    pub fn cancel_order_buy(&mut self, tx:String){}

    // Seller cancels sell order 
    pub fn cancel_order_sell(&mut self){}

    // Vote for seller 
    pub fn vote(&mut self, account_id:AccountId, value: i8){}

    // show all accounts with sell orders 
    pub fn get_order_sell(&self)->Vec
   {}

    
   // get information of user
    
   pub 
   fn 
   get_account(
   &
   self, account_id: AccountId)->SellInformation{}

    
   pub 
   fn 
   get_transaction(
   &
   self, tx: 
   &
   String)->History{}

    
   // Get buy history of a account
    
   pub 
   fn 
   get_history_buy(
   &
   self, account_id: AccountId)->
   Vec
   
    {}

    
    // Get sell history of a account
    
    pub 
    fn 
    get_history_sell(
    &
    self, account_id: AccountId)->
    Vec
    
     {}
    
    
     // get hash code for transaction
    
     fn 
     compute_hash
     
      (buyer:
      &
      String, seller:
      &
      String, amount:
      &Balance->
      String{}
}

     
    
   
  

near login

near create-account deploy.p2pexchange.testnet --masterAccount p2pexchange.testnet

export DEPLOY_ID=deploy.p2pexchange.testnet
export BUYER_ID=buyer1.testnet
export SELLER_ID=seller1.testnet

./build.sh
./deploy.sh

./call.sh new '{}'	

./sellercall.sh deposit '{}' --amount 10

./sellercall.sh set_bank_account '{"number":"123456789", "bank_name":"MB Bank"}'

./buyercall.sh deposit '{}' --amount 1

./sellercall.sh order_sell '{"amount": 10, "price":2}'

./buyercall.sh get_order_sell '{}'

./buyercall.sh order_buy '{"seller_id":"seller1.testnet", "amount":5}'

./buyercall.sh confirm_sent '{"tx": "something"}'

./sellercall.sh confirm_received '{"tx":"something"}'

./buyercall.sh get_transaction '{"tx":"something"}'

./buyercall.sh vote '{"account_id":"seller1.testnet", "value":1}'

./call.sh get_account '{"account_id":"seller1.testnet"}'
./call.sh get_account '{"account_id":"buyer1.testnet"}'

./sellercall.sh cancel_order_sell '{}'
./sellercall.sh withdraw '{"amount":5}'

./buyercall.sh withdraw '{"amount":5}'