1   module Hello {
2       use 0x1::Signer;
3       use 0x1::Event;
4   
5       struct AnyWordEvent has drop, store {
6           words: vector,
7       }
8   
9       struct EventHolder has key {
10          any_word_events: Event::EventHandle,
11      }
12  
13      public(script) fun hello(account: &signer) acquires EventHolder {
14          let addr = Signer::address_of(account);
15          if (!exists(copy addr)){
16              move_to(account, EventHolder {
17                  any_word_events: Event::new_event_handle(account),
18              });
19          };
20          let hello_world = x"68656c6c6f20776f726c64";//hello world
21          let holder = borrow_global_mut(addr);
22          Event::emit_event(&mut holder.any_word_events, AnyWordEvent { words:hello_world });
23      }
24  }

1   module MyToken {
2       use 0x1::Token;
3       use 0x1::Account;
4   
5       struct MyToken has copy, drop, store { }
6   
7       public(script) fun init(account: &signer) {
8           Token::register_token(account, 3);
9           Account::do_accept_token(account);
10      }
11  
12      public(script) fun mint(account: &signer, amount: u128) {
13         let token = Token::mint(account, amount);
14         Account::deposit_to_self(account, token)
15      }
16  }

1   module NFTExample {
2       use 0x1::Signer;
3       struct NFT has key, store { name: vector }
4   
5       struct UniqIdList has key, store {
6           data: vector>
7       }
8       public fun initialize(account: &signer) {
9           move_to(account, UniqIdList {data: Vector::empty>()});
10      }
11      public fun new(account: &signer, name: vector): NFT acquires UniqIdList {
12          let account_address = Signer::address_of(account);
13          let exist = Vector::contains>(&borrow_global(account_address).data, &name);
14          assert(!exist, 1);
15          let id_list = borrow_global_mut(account_address);
16          Vector::push_back>(&mut id_list.data, copy name);
17          NFT { name }
18      }
19      public fun destroy(account_address: address, nft: NFT) acquires UniqIdList {
20          let NFT { name } = nft;
21          let (exist, index) = Vector::index_of>(&borrow_global(account_address).data, &name);
22          assert(!exist, 2);
23          let id_list = borrow_global_mut(account_address);
24          Vector::remove>(&mut id_list.data, index);
25      }
26  }

1   module ResourceExample {
2       use 0x1::Signer;
3   
4       struct R has key, store { x: bool }
5   
6       public fun new(): R {
7           R { x: true }
8       }
9   
10      public fun destroy(r: R) {
11          R { x: _ } = r;
12      }
13  
14      public fun save(account: &signer, r: R){
15          move_to(account, r);
16      }
17  
18      public fun get_x(account: &signer): bool acquires R {
19          let sender = Signer::address_of(account);
20          assert(exists(sender), 1);
21          let r = borrow_global(sender);
22          r.x
23      }
24  }

1   script {
2       use 0x1::Dao;
3       use {{coder}}::MyToken::MyToken;
4       use 0x1::Config;
5   
6       fun set_dao_config(signer: signer) {
7           let cap = Config::extract_modify_config_capability>(
8               &signer
9           );
10  
11          Dao::set_voting_delay(&mut cap, 30 * 1000);
12          Dao::set_voting_period(&mut cap, 30 * 30 * 1000);
13          Dao::set_voting_quorum_rate(&mut cap, 50);
14          Dao::set_min_action_delay(&mut cap, 30 * 30 * 1000);
15  
16          Config::restore_modify_config_capability(cap);
17      }
18  }