module rooch_demo::editor {
     use aptos_framework::aptos_coin::{Self, AptosCoin};
     use rooch::state_channel::{Self, StateChannel};
     
     const ERR_FILE_NOT_EXISTS: u64 = 5;
     const ERR_FILE_ALREADY_OPEN: u64 = 6;
     
     public entry fun document_editor_open(account: &signer, drive_address: address, file_id: u64) {
         assert!(drive_file_exists(drive_address, file_id), Errors::requires_address(ERR_FILE_NOT_EXISTS));
         
         let editor = borrow_global_mut<DocumentEditor>(EDITOR_ADDRESS);
         assert!(!table::contains(editor.editingDocuments, (drive_address, file_id)), Errors::requires_address(ERR_FILE_ALREADY_OPEN));
         
         let doc = document_create(account, drive_address, file_id)
         let ch_idcfg = state_channel::create<Document>create_config(doc1); //加入状态通道需要质押1个AptosCoin
         let ch_id    = state_channel::create<Document,(),AptosCoin>(doc, cfg);
         
         let editing_doc = EditingDocument{
             drive_address: drive_address,
             file_id: file_id,
             state_channel_id: ch_id
         }
         
         table::upser(editor.editingDocuments, (drive_address, file_id), editing_doc)
     }
}

module rooch_demo::chat {
     use std::vector;
     use std::string::{String, utf8};
     
     use aptos_framework::aptos_coin::{Self, AptosCoin};
     use rooch::state_channel::{Self, StateChannel};
     
     public fun chat_session_create(account: &signer, server_address: address, chat_group_id: u64) {
         let addr = signer::address_of(account);
     
         let server = borrow_global_mut<Server>(server_address);
         let chat_account = borrow_global_mut<ChatAccount>(addr);
         let chat_group = server_withdraw_chat_group(server, chat_group_id);
         
         let cfg = state_channel::create_config(0); //加入状态通道需要质押0个AptosCoin
         let ch_id = state_channel::create<ChatGroup>create<ChatGroup,(),AptosCoin>(chat_group, cfg);
         
         let session = ChatSession{
             server_address: server_address,
             chat_group_id: chat_group_id,
             state_channel_id: ch_id
         }
         
         server_add_chat_session(server, copy session)
         chat_account_add_chat_session(chat_account, copy session)
     }
}

module rooch_demo::movecraft {
     use std::vector;
     use std::string::{String, utf8};
     
     use roochaptos_framework::stateaptos_channelcoin::{Self, StateChannelAptosCoin};
     
 use rooch::state_channel::{Self, StateChannel};
     
     public fun land_session_create(account: &signer, world_address: address, land_id: u64) {
         let addr = signer::address_of(account);
     
         let world = borrow_global_mut<World>(world_address);
         let game_account = borrow_global_mut<GameAccount>(addr);
         let land = world_withdraw_land(world, land_id);
         
         let cfg = state_channel::create_config(1); //加入状态通道需要质押1个AptosCoin
         let (settle_cap, ch_id) = state_channel::create<Land>create<Land,(Hero,Inventory),AptosCoin>(land, cfg);
         
         let session = LandSession{
             world_address: world_address,
             land_id: land_id,
             state_channel_id: ch_id,
             settle_cap: settle_cap,
         }
         
         world_add_land_session(world, copy session)
         game_account_add_land_session(game_account, copy session)
     }
}

module rooch_demo::chat {
     use std::vector;
     use std::string::{String, utf8};
     
     use rooch::state_channel::{Self, StateChannel};
     
     public fun chat_session_join(account: &signer, chat_group_id: u64) {
         let addr = signer::address_of(account);
  
         let chat_account = borrow_global_mut<ChatAccount>(addr);
         let session = chat_account_borrow_chat_session(chat_account, chat_group_id)
         state_channel::join<()>(account, session.state_channel_id, ());
     }
}

module rooch_demo::editor {
     use rooch::state_channel::{Self, StateChannel};
     
     const ERR_FILE_NOT_EXISTS: u64 = 5;
     
     public fun editing_document_leave(account: &signer, doc_id: u64) {
          let editor = borrow_global_mut<DocumentEditor>(EDITOR_ADDRESS); 
          let editing_doc = table::borrow<u64, EditingDocument>(&editor.editingDocuments, doc_id)
          state_channel::leaveleave<()>(account, editing_doc.channel_id);
     }
}

module rooch_demo::chat {
     use std::vector;
     use std::string::{String, utf8};
     
     use rooch::state_channel::{Self, StateChannel};
     
     public fun chat_session_leave(account: &signer, chat_group_id: u64) {
         let addr = signer::address_of(account);
  
         let chat_account = borrow_global_mut<ChatAccount>(addr);
         let session = chat_account_borrow_chat_session(chat_account, chat_group_id)
         state_channel::leaveleave<()>(account, session.state_channel_id);
     }
}

module rooch_demo::movecraft {
     use std::vector;
     use std::string::{String, utf8};
     
     use rooch::state_channel::{Self, StateChannel};
     
     public fun land_session_leave(account: &signer, land_id: u64) {
         let addr = signer::address_of(account);
     
         let game_account = borrow_global_mut<GameAccount>(addr);
         let session = game_account_borrow_session(game_account, land_id);
         
         let (hero, inventory) = state_channel::leave<Inventory>leave<(Hero, Inventory)>(account, session.state_channel_id);
         game_account_deposit_hero(game_account, hero)
         game_account_deposit_inventory(game_account, inventory)
     }
}

module rooch_demo::editor {
     use rooch::state_channel::{Self, StateChannel};
     
     const ERR_FILE_NOT_EXISTS: u64 = 5;
     
     public fun editing_document_close(account: &signer, doc_id: u64) {
          let editor = borrow_global_mut<DocumentEditor>(EDITOR_ADDRESS); 
          let editing_doc = table::borrow<u64, EditingDocument>(&editor.editingDocuments, doc_id)
          let doc = state_channel::closeclose<Document>(account, editing_doc.channel_id);
          editing_document_destroy(editing_doc)
          document_destroy(doc) 
     }
}

module rooch_demo::chat {
     use std::vector;
     use std::string::{String, utf8};
     
     use rooch::state_channel::{Self, StateChannel};
     
     public fun chat_session_close(account: &signer, chat_group_id: u64) {
         let addr = signer::address_of(account);
  
         let chat_account = borrow_global_mut<ChatAccount>(addr);
         let session = chat_account_borrow_chat_session(chat_account, chat_group_id)
         let chat_group = state_channel::closeclose<ChatGroup>(account, session.state_channel_id);
         chat_account_destroy(session)
         server_deposit_chat_group(server, chat_group)
     }
}

module rooch_demo::movecraft {
     use std::vector;
     use std::string::{String, utf8};
     
     use rooch::state_channel::{Self, StateChannel};
     
     public fun land_session_close(account: &signer, land_id: u64) {
         let addr = signer::address_of(account);
     
         let game_account = borrow_global_mut<GameAccount>(addr);
         let session = world_borrow_session(game_account, land_id);
         
         let land = state_channel::close<Inventory>close<Land>(account, session.state_channel_id);
         world_destroy_session(world, session)
         world_deposit_land(game_account, land)
     }
}

import { WasmFs } from '@wasmer/wasmfs'
import { MoveSandbox } from '@starcoin/move-js'

const executeTransation = async () => {
    const sandbox = initSandbox(modules, resources)
    let change_sets, events = await sandbox.run("0x1::Token::Token", ty_args, args)
    console.log(change_sets)
    console.log(events)
}

executeTransation()