# chat_contract

<!-- livebook:{"chunks":null,"kind":"Elixir.Spiral.Kino.SmartCell","attrs":{"timeout":300,"source":"open rust\nopen rust.rust_operators\nopen sm'_operators","print_code":false},"livebook_object":"smart_cell"} -->

```elixir
Spiral.Kino.eval!(
  ~S"""
  open rust
  open rust.rust_operators
  open sm'_operators
  """,
  timeout: 300_000
)
```

<!-- livebook:{"chunks":null,"kind":"Elixir.Spiral.Kino.SmartCell","attrs":{"timeout":300,"source":"///- --test static\n\nopen testing","print_code":false},"livebook_object":"smart_cell"} -->

```elixir
Spiral.Kino.eval!(
  ~S"""
  ///- --test static

  open testing
  """,
  timeout: 300_000
)
```

## chat_contract

<!-- livebook:{"break_markdown":true} -->

### state

<!-- livebook:{"chunks":null,"kind":"Elixir.Spiral.Kino.SmartCell","attrs":{"timeout":300,"source":"nominal alias_accounts = $'std::collections::HashMap<String, (u64, u32)>'\n\ntype state =\n    {\n        version : u32\n        account_set : near.iterable_set near.account_id\n        alias_set : near.iterable_set sm'.std_string\n        account_map : near.lookup_map near.account_id sm'.std_string\n        alias_map : near.lookup_map sm'.std_string alias_accounts\n    }","print_code":false},"livebook_object":"smart_cell"} -->

```elixir
Spiral.Kino.eval!(
  ~S"""
  nominal alias_accounts = $'std::collections::HashMap<String, (u64, u32)>'

  type state =
      {
          version : u32
          account_set : near.iterable_set near.account_id
          alias_set : near.iterable_set sm'.std_string
          account_map : near.lookup_map near.account_id sm'.std_string
          alias_map : near.lookup_map sm'.std_string alias_accounts
      }
  """,
  timeout: 300_000
)
```

<!-- livebook:{"chunks":null,"kind":"Elixir.Spiral.Kino.SmartCell","attrs":{"timeout":300,"source":"///- --test\n///> rust -c\n\n()","print_code":false},"livebook_object":"smart_cell"} -->

```elixir
Spiral.Kino.eval!(
  ~S"""
  ///- --test
  ///> rust -c

  ()
  """,
  timeout: 300_000
)
```

### new

<!-- livebook:{"chunks":null,"kind":"Elixir.Spiral.Kino.SmartCell","attrs":{"timeout":300,"source":"inl new () : state =\n    {\n        version = 2\n        account_set = \"account_set\" |> sm'.byte_slice |> near.new_iterable_set\n        alias_set = \"alias_set\" |> sm'.byte_slice |> near.new_iterable_set\n        account_map = \"account_map\" |> sm'.byte_slice |> near.new_lookup_map\n        alias_map = \"alias_map\" |> sm'.byte_slice |> near.new_lookup_map\n    }","print_code":false},"livebook_object":"smart_cell"} -->

```elixir
Spiral.Kino.eval!(
  ~S"""
  inl new () : state =
      {
          version = 2
          account_set = "account_set" |> sm'.byte_slice |> near.new_iterable_set
          alias_set = "alias_set" |> sm'.byte_slice |> near.new_iterable_set
          account_map = "account_map" |> sm'.byte_slice |> near.new_lookup_map
          alias_map = "alias_map" |> sm'.byte_slice |> near.new_lookup_map
      }
  """,
  timeout: 300_000
)
```

### is_valid_alias

<!-- livebook:{"chunks":null,"kind":"Elixir.Spiral.Kino.SmartCell","attrs":{"timeout":300,"source":"inl is_valid_alias (alias : sm'.std_string) : bool =\n    $'{ let alias: &str = &(!alias); alias.len() > 0 && alias.len() < 64 && \\!alias.starts_with(\\'-\\') && \\!alias.ends_with(\\'-\\') && alias.chars().all(|c| c.is_alphanumeric() || c == \\'-\\') }' : bool","print_code":false},"livebook_object":"smart_cell"} -->

```elixir
Spiral.Kino.eval!(
  ~S"""
  inl is_valid_alias (alias : sm'.std_string) : bool =
      $'{ let alias: &str = &(!alias); alias.len() > 0 && alias.len() < 64 && \!alias.starts_with(\'-\') && \!alias.ends_with(\'-\') && alias.chars().all(|c| c.is_alphanumeric() || c == \'-\') }' : bool
  """,
  timeout: 300_000
)
```

<!-- livebook:{"chunks":null,"kind":"Elixir.Spiral.Kino.SmartCell","attrs":{"timeout":300,"source":"///- --test\n///> rust -c\n\n\"\"\n|> sm'.to_std_string\n|> is_valid_alias\n|> _assert_eq false","print_code":false},"livebook_object":"smart_cell"} -->

```elixir
Spiral.Kino.eval!(
  ~S"""
  ///- --test
  ///> rust -c

  ""
  |> sm'.to_std_string
  |> is_valid_alias
  |> _assert_eq false
  """,
  timeout: 300_000
)
```

<!-- livebook:{"chunks":null,"kind":"Elixir.Spiral.Kino.SmartCell","attrs":{"timeout":300,"source":"///- --test\n///> rust -c\n\n\"a-\"\n|> sm'.to_std_string\n|> is_valid_alias\n|> _assert_eq false","print_code":false},"livebook_object":"smart_cell"} -->

```elixir
Spiral.Kino.eval!(
  ~S"""
  ///- --test
  ///> rust -c

  "a-"
  |> sm'.to_std_string
  |> is_valid_alias
  |> _assert_eq false
  """,
  timeout: 300_000
)
```

<!-- livebook:{"chunks":null,"kind":"Elixir.Spiral.Kino.SmartCell","attrs":{"timeout":300,"source":"///- --test\n///> rust -c\n\n\"a-a\"\n|> sm'.to_std_string\n|> is_valid_alias\n|> _assert_eq true","print_code":false},"livebook_object":"smart_cell"} -->

```elixir
Spiral.Kino.eval!(
  ~S"""
  ///- --test
  ///> rust -c

  "a-a"
  |> sm'.to_std_string
  |> is_valid_alias
  |> _assert_eq true
  """,
  timeout: 300_000
)
```

### generate_cid

<!-- livebook:{"chunks":null,"kind":"Elixir.Spiral.Kino.SmartCell","attrs":{"timeout":300,"source":"inl generate_cid (content : am'.vec u8) : sm'.std_string =\n    $'{ let mut varint = unsigned_varint::encode::u64_buffer(); let codec_bytes = unsigned_varint::encode::u64(0x55, &mut varint).to_vec(); let mut hasher: sha2::Sha256 = sha2::Digest::new(); sha2::Digest::update(&mut hasher, &(!content)); let multihash: Vec<u8> = [0x12u8, 32].into_iter().chain(sha2::Digest::finalize(hasher).into_iter()).collect(); let cid_bytes = [vec\\![1u8], codec_bytes, multihash].concat(); multibase::encode(multibase::Base::Base32Lower, &cid_bytes) }' : sm'.std_string","print_code":false},"livebook_object":"smart_cell"} -->

```elixir
Spiral.Kino.eval!(
  ~S"""
  inl generate_cid (content : am'.vec u8) : sm'.std_string =
      $'{ let mut varint = unsigned_varint::encode::u64_buffer(); let codec_bytes = unsigned_varint::encode::u64(0x55, &mut varint).to_vec(); let mut hasher: sha2::Sha256 = sha2::Digest::new(); sha2::Digest::update(&mut hasher, &(!content)); let multihash: Vec<u8> = [0x12u8, 32].into_iter().chain(sha2::Digest::finalize(hasher).into_iter()).collect(); let cid_bytes = [vec\![1u8], codec_bytes, multihash].concat(); multibase::encode(multibase::Base::Base32Lower, &cid_bytes) }' : sm'.std_string
  """,
  timeout: 300_000
)
```

<!-- livebook:{"chunks":null,"kind":"Elixir.Spiral.Kino.SmartCell","attrs":{"timeout":300,"source":"///- --test\n///> rust -c -d multibase='=0.9.1' sha2 unsigned-varint\n\n;[]\n|> am'.to_vec\n|> generate_cid\n|> sm'.from_std_string\n|> _assert_eq \"bafkreihdwdcefgh4dqkjv67uzcmw7ojee6xedzdetojuzjevtenxquvyku\"","print_code":false},"livebook_object":"smart_cell"} -->

```elixir
Spiral.Kino.eval!(
  ~S"""
  ///- --test
  ///> rust -c -d multibase='=0.9.1' sha2 unsigned-varint

  ;[]
  |> am'.to_vec
  |> generate_cid
  |> sm'.from_std_string
  |> _assert_eq "bafkreihdwdcefgh4dqkjv67uzcmw7ojee6xedzdetojuzjevtenxquvyku"
  """,
  timeout: 300_000
)
```

### claim_alias

<!-- livebook:{"chunks":null,"kind":"Elixir.Spiral.Kino.SmartCell","attrs":{"timeout":300,"source":"inl panic_str (text : string) : () =\n    $'near_sdk::env::panic_str(&*!text)' : ()\n\ninl claim_alias\n    (account_set : rust.ref (rust.mut' (near.iterable_set near.account_id)))\n    (alias_set : rust.ref (rust.mut' (near.iterable_set sm'.std_string)))\n    (account_map : rust.ref (rust.mut' (near.lookup_map near.account_id sm'.std_string)))\n    (alias_map : rust.ref (rust.mut' (near.lookup_map sm'.std_string alias_accounts)))\n    (alias : sm'.std_string)\n    : ()\n    =\n    inl signer_account_id = near.signer_account_id ()\n    inl predecessor_account_id = near.predecessor_account_id ()\n    inl block_timestamp = near.block_timestamp ()\n\n    trace Debug\n        fun () => \"chat_contract.claim_alias\"\n        fun () => {\n            alias\n            block_timestamp\n            signer_account_id = signer_account_id |> sm'.to_string'\n            predecessor_account_id = predecessor_account_id |> sm'.to_string'\n        }\n\n    if alias |> is_valid_alias |> not then\n        panic_str \"chat_contract.claim_alias / invalid alias\"\n\n    inl account_alias : optionm'.option' sm'.std_string =\n        $'(!account_map).get(&(!signer_account_id)).cloned()'\n\n    match account_alias |> optionm'.unbox with\n    | Some account_alias when account_alias =. alias =>\n        trace Warning\n            fun () => \"chat_contract.claim_alias / alias already claimed\"\n            fun () => { account_alias = account_alias |> sm'.format_debug }\n    | account_alias' =>\n        trace Debug\n            fun () => \"chat_contract.claim_alias\"\n            fun () => { account_alias = account_alias' |> optionm'.box |> sm'.format_debug }\n\n        match account_alias' with\n        | Some account_alias =>\n            $'{ if let Some(accounts) = (!alias_map).get_mut(&(!account_alias)) { accounts.remove(&(!signer_account_id)); } }' : ()\n        | None => ()\n\n        $'{ (!account_map).insert((!signer_account_id).clone(), (!alias).clone()); }' : ()\n\n        account_set |> near.iterable_set_insert signer_account_id |> ignore\n        alias_set |> near.iterable_set_insert alias |> ignore\n\n        $'{ let accounts = match (!alias_map).get(&(!alias)) { None => { let mut accounts = std::collections::HashMap::new(); accounts.insert((!signer_account_id).clone(), (!block_timestamp, 0u32)); accounts } Some(previous) => { let mut ordered = previous.iter().collect::<Vec<_>>(); ordered.sort_unstable_by_key(|(_, (_, index))| *index); let mut accounts = ordered.iter().enumerate().map(|(i, (account_id, (timestamp, _)))| ((*account_id).clone(), (*timestamp, i as u32))).collect::<std::collections::HashMap<_, _>>(); accounts.insert((!signer_account_id).clone(), (!block_timestamp, ordered.len() as u32)); accounts } }; (!alias_map).insert((!alias).clone(), accounts); }' : ()","print_code":false},"livebook_object":"smart_cell"} -->

```elixir
Spiral.Kino.eval!(
  ~S"""
  inl panic_str (text : string) : () =
      $'near_sdk::env::panic_str(&*!text)' : ()

  inl claim_alias
      (account_set : rust.ref (rust.mut' (near.iterable_set near.account_id)))
      (alias_set : rust.ref (rust.mut' (near.iterable_set sm'.std_string)))
      (account_map : rust.ref (rust.mut' (near.lookup_map near.account_id sm'.std_string)))
      (alias_map : rust.ref (rust.mut' (near.lookup_map sm'.std_string alias_accounts)))
      (alias : sm'.std_string)
      : ()
      =
      inl signer_account_id = near.signer_account_id ()
      inl predecessor_account_id = near.predecessor_account_id ()
      inl block_timestamp = near.block_timestamp ()

      trace Debug
          fun () => "chat_contract.claim_alias"
          fun () => {
              alias
              block_timestamp
              signer_account_id = signer_account_id |> sm'.to_string'
              predecessor_account_id = predecessor_account_id |> sm'.to_string'
          }

      if alias |> is_valid_alias |> not then
          panic_str "chat_contract.claim_alias / invalid alias"

      inl account_alias : optionm'.option' sm'.std_string =
          $'(!account_map).get(&(!signer_account_id)).cloned()'

      match account_alias |> optionm'.unbox with
      | Some account_alias when account_alias =. alias =>
          trace Warning
              fun () => "chat_contract.claim_alias / alias already claimed"
              fun () => { account_alias = account_alias |> sm'.format_debug }
      | account_alias' =>
          trace Debug
              fun () => "chat_contract.claim_alias"
              fun () => { account_alias = account_alias' |> optionm'.box |> sm'.format_debug }

          match account_alias' with
          | Some account_alias =>
              $'{ if let Some(accounts) = (!alias_map).get_mut(&(!account_alias)) { accounts.remove(&(!signer_account_id)); } }' : ()
          | None => ()

          $'{ (!account_map).insert((!signer_account_id).clone(), (!alias).clone()); }' : ()

          account_set |> near.iterable_set_insert signer_account_id |> ignore
          alias_set |> near.iterable_set_insert alias |> ignore

          $'{ let accounts = match (!alias_map).get(&(!alias)) { None => { let mut accounts = std::collections::HashMap::new(); accounts.insert((!signer_account_id).clone(), (!block_timestamp, 0u32)); accounts } Some(previous) => { let mut ordered = previous.iter().collect::<Vec<_>>(); ordered.sort_unstable_by_key(|(_, (_, index))| *index); let mut accounts = ordered.iter().enumerate().map(|(i, (account_id, (timestamp, _)))| ((*account_id).clone(), (*timestamp, i as u32))).collect::<std::collections::HashMap<_, _>>(); accounts.insert((!signer_account_id).clone(), (!block_timestamp, ordered.len() as u32)); accounts } }; (!alias_map).insert((!alias).clone(), accounts); }' : ()
  """,
  timeout: 300_000
)
```

<!-- livebook:{"chunks":null,"kind":"Elixir.Spiral.Kino.SmartCell","attrs":{"timeout":300,"source":"///- --test\n///> rust \"-c=-e=\\\"chat_contract.claim_alias / invalid alias\\\"\"\n\ninl state = new ()\n\"\"\n|> sm'.to_std_string\n|> claim_alias\n    (state.account_set |> rust.to_ref_mut)\n    (state.alias_set |> rust.to_ref_mut)\n    (state.account_map |> rust.to_ref_mut)\n    (state.alias_map |> rust.to_ref_mut)","print_code":false},"livebook_object":"smart_cell"} -->

```elixir
Spiral.Kino.eval!(
  ~S"""
  ///- --test
  ///> rust "-c=-e=\"chat_contract.claim_alias / invalid alias\""

  inl state = new ()
  ""
  |> sm'.to_std_string
  |> claim_alias
      (state.account_set |> rust.to_ref_mut)
      (state.alias_set |> rust.to_ref_mut)
      (state.account_map |> rust.to_ref_mut)
      (state.alias_map |> rust.to_ref_mut)
  """,
  timeout: 300_000
)
```

### get_account_info

<!-- livebook:{"chunks":null,"kind":"Elixir.Spiral.Kino.SmartCell","attrs":{"timeout":300,"source":"nominal account_info = $'Option<(String, u64, u32)>'\n\ninl get_account_info\n    (account_map : rust.ref (near.lookup_map near.account_id sm'.std_string))\n    (alias_map : rust.ref (near.lookup_map sm'.std_string alias_accounts))\n    (account_id : near.account_id)\n    : account_info\n    =\n    inl result : account_info =\n        $'(!account_map).get(&(!account_id)).and_then(|alias| (!alias_map).get(alias).and_then(|accounts| accounts.get(&(!account_id)).map(|(timestamp, index)| (alias.clone(), *timestamp, *index))))'\n\n    trace Debug\n        fun () => \"chat_contract.get_account_info\"\n        fun () => { account_id result = #?*result }\n\n    result","print_code":false},"livebook_object":"smart_cell"} -->

```elixir
Spiral.Kino.eval!(
  ~S"""
  nominal account_info = $'Option<(String, u64, u32)>'

  inl get_account_info
      (account_map : rust.ref (near.lookup_map near.account_id sm'.std_string))
      (alias_map : rust.ref (near.lookup_map sm'.std_string alias_accounts))
      (account_id : near.account_id)
      : account_info
      =
      inl result : account_info =
          $'(!account_map).get(&(!account_id)).and_then(|alias| (!alias_map).get(alias).and_then(|accounts| accounts.get(&(!account_id)).map(|(timestamp, index)| (alias.clone(), *timestamp, *index))))'

      trace Debug
          fun () => "chat_contract.get_account_info"
          fun () => { account_id result = #?*result }

      result
  """,
  timeout: 300_000
)
```

### get_alias_map

<!-- livebook:{"chunks":null,"kind":"Elixir.Spiral.Kino.SmartCell","attrs":{"timeout":300,"source":"nominal alias_accounts_option = $'Option<std::collections::HashMap<String, (u64, u32)>>'\n\ninl get_alias_map\n    (alias_map : rust.ref (near.lookup_map sm'.std_string alias_accounts))\n    (alias : sm'.std_string)\n    : alias_accounts_option\n    =\n    trace Debug\n        fun () => \"chat_contract.get_alias_map\"\n        fun () => { alias }\n\n    $'(!alias_map).get(&(!alias)).cloned()' : alias_accounts_option","print_code":false},"livebook_object":"smart_cell"} -->

```elixir
Spiral.Kino.eval!(
  ~S"""
  nominal alias_accounts_option = $'Option<std::collections::HashMap<String, (u64, u32)>>'

  inl get_alias_map
      (alias_map : rust.ref (near.lookup_map sm'.std_string alias_accounts))
      (alias : sm'.std_string)
      : alias_accounts_option
      =
      trace Debug
          fun () => "chat_contract.get_alias_map"
          fun () => { alias }

      $'(!alias_map).get(&(!alias)).cloned()' : alias_accounts_option
  """,
  timeout: 300_000
)
```

### main

<!-- livebook:{"chunks":null,"kind":"Elixir.Spiral.Kino.SmartCell","attrs":{"timeout":300,"source":"///> _\n\ninl main_native () : () =\n    global \"#[near_sdk::near_bindgen]\\n#[derive(near_sdk::PanicOnDefault, borsh::BorshDeserialize, borsh::BorshSerialize)]\\npub struct State((u32, near_sdk::store::IterableSet<String>, near_sdk::store::IterableSet<String>, near_sdk::store::LookupMap<String, String>, near_sdk::store::LookupMap<String, std::collections::HashMap<String, (u64, u32)>>));\"\n    global \"#[near_sdk::near_bindgen]\\nimpl State {\\n    #[init]\\n    pub fn new() -> Self {\\n        Self(chat_contract_new())\\n    }\\n    pub fn is_valid_alias(&self, alias: String) -> bool {\\n        chat_contract_is_valid_alias(alias)\\n    }\\n    pub fn generate_cid(&self, content: Vec<u8>) -> String {\\n        chat_contract_generate_cid(content)\\n    }\\n    #[result_serializer(borsh)]\\n    pub fn generate_cid_borsh(&self, #[serializer(borsh)] content: Vec<u8>) -> String {\\n        self.generate_cid(content)\\n    }\\n    pub fn claim_alias(&mut self, alias: String) {\\n        let state = &mut self.0;\\n        chat_contract_claim_alias(&mut state.1, &mut state.2, &mut state.3, &mut state.4, alias)\\n    }\\n    pub fn get_account_info(&self, account_id: near_sdk::AccountId) -> Option<(String, u64, u32)> {\\n        chat_contract_get_account_info(&self.0.3, &self.0.4, account_id.to_string())\\n    }\\n    pub fn get_alias_map(&self, alias: String) -> Option<std::collections::HashMap<String, (u64, u32)>> {\\n        chat_contract_get_alias_map(&self.0.4, alias)\\n    }\\n    #[result_serializer(borsh)]\\n    pub fn get_alias_map_borsh(&self, #[serializer(borsh)] alias: String) -> Option<std::collections::HashMap<String, (u64, u32)>> {\\n        self.get_alias_map(alias)\\n    }\\n}\"\n    inl quiet () : () = set_trace_level Info\n    !!!!Export(\"chat_contract_new\", ((fun () => inl () = quiet () in inl x = new () in x.version, x.account_set, x.alias_set, x.account_map, x.alias_map) : () -> u32 * near.iterable_set near.account_id * near.iterable_set sm'.std_string * near.lookup_map near.account_id sm'.std_string * near.lookup_map sm'.std_string alias_accounts))\n    !!!!Export(\"chat_contract_is_valid_alias\", ((fun alias => inl () = quiet () in is_valid_alias alias) : sm'.std_string -> bool))\n    !!!!Export(\"chat_contract_generate_cid\", ((fun content => inl () = quiet () in generate_cid content) : am'.vec u8 -> sm'.std_string))\n    !!!!Export(\"chat_contract_claim_alias\", ((fun (account_set, alias_set, account_map, alias_map, alias) => inl () = quiet () in claim_alias account_set alias_set account_map alias_map alias) : rust.ref (rust.mut' (near.iterable_set near.account_id)) * rust.ref (rust.mut' (near.iterable_set sm'.std_string)) * rust.ref (rust.mut' (near.lookup_map near.account_id sm'.std_string)) * rust.ref (rust.mut' (near.lookup_map sm'.std_string alias_accounts)) * sm'.std_string -> ()))\n    !!!!Export(\"chat_contract_get_account_info\", ((fun (account_map, alias_map, account_id) => inl () = quiet () in get_account_info account_map alias_map account_id) : rust.ref (near.lookup_map near.account_id sm'.std_string) * rust.ref (near.lookup_map sm'.std_string alias_accounts) * near.account_id -> account_info))\n    !!!!Export(\"chat_contract_get_alias_map\", ((fun (alias_map, alias) => inl () = quiet () in get_alias_map alias_map alias) : rust.ref (near.lookup_map sm'.std_string alias_accounts) * sm'.std_string -> alias_accounts_option))\n\ninl main () =\n    if is_rust ()\n    then main_native ()\n    else ()","print_code":false},"livebook_object":"smart_cell"} -->

```elixir
Spiral.Kino.eval!(
  ~S"""
  ///> _

  inl main_native () : () =
      global "#[near_sdk::near_bindgen]\n#[derive(near_sdk::PanicOnDefault, borsh::BorshDeserialize, borsh::BorshSerialize)]\npub struct State((u32, near_sdk::store::IterableSet<String>, near_sdk::store::IterableSet<String>, near_sdk::store::LookupMap<String, String>, near_sdk::store::LookupMap<String, std::collections::HashMap<String, (u64, u32)>>));"
      global "#[near_sdk::near_bindgen]\nimpl State {\n    #[init]\n    pub fn new() -> Self {\n        Self(chat_contract_new())\n    }\n    pub fn is_valid_alias(&self, alias: String) -> bool {\n        chat_contract_is_valid_alias(alias)\n    }\n    pub fn generate_cid(&self, content: Vec<u8>) -> String {\n        chat_contract_generate_cid(content)\n    }\n    #[result_serializer(borsh)]\n    pub fn generate_cid_borsh(&self, #[serializer(borsh)] content: Vec<u8>) -> String {\n        self.generate_cid(content)\n    }\n    pub fn claim_alias(&mut self, alias: String) {\n        let state = &mut self.0;\n        chat_contract_claim_alias(&mut state.1, &mut state.2, &mut state.3, &mut state.4, alias)\n    }\n    pub fn get_account_info(&self, account_id: near_sdk::AccountId) -> Option<(String, u64, u32)> {\n        chat_contract_get_account_info(&self.0.3, &self.0.4, account_id.to_string())\n    }\n    pub fn get_alias_map(&self, alias: String) -> Option<std::collections::HashMap<String, (u64, u32)>> {\n        chat_contract_get_alias_map(&self.0.4, alias)\n    }\n    #[result_serializer(borsh)]\n    pub fn get_alias_map_borsh(&self, #[serializer(borsh)] alias: String) -> Option<std::collections::HashMap<String, (u64, u32)>> {\n        self.get_alias_map(alias)\n    }\n}"
      inl quiet () : () = set_trace_level Info
      !!!!Export("chat_contract_new", ((fun () => inl () = quiet () in inl x = new () in x.version, x.account_set, x.alias_set, x.account_map, x.alias_map) : () -> u32 * near.iterable_set near.account_id * near.iterable_set sm'.std_string * near.lookup_map near.account_id sm'.std_string * near.lookup_map sm'.std_string alias_accounts))
      !!!!Export("chat_contract_is_valid_alias", ((fun alias => inl () = quiet () in is_valid_alias alias) : sm'.std_string -> bool))
      !!!!Export("chat_contract_generate_cid", ((fun content => inl () = quiet () in generate_cid content) : am'.vec u8 -> sm'.std_string))
      !!!!Export("chat_contract_claim_alias", ((fun (account_set, alias_set, account_map, alias_map, alias) => inl () = quiet () in claim_alias account_set alias_set account_map alias_map alias) : rust.ref (rust.mut' (near.iterable_set near.account_id)) * rust.ref (rust.mut' (near.iterable_set sm'.std_string)) * rust.ref (rust.mut' (near.lookup_map near.account_id sm'.std_string)) * rust.ref (rust.mut' (near.lookup_map sm'.std_string alias_accounts)) * sm'.std_string -> ()))
      !!!!Export("chat_contract_get_account_info", ((fun (account_map, alias_map, account_id) => inl () = quiet () in get_account_info account_map alias_map account_id) : rust.ref (near.lookup_map near.account_id sm'.std_string) * rust.ref (near.lookup_map sm'.std_string alias_accounts) * near.account_id -> account_info))
      !!!!Export("chat_contract_get_alias_map", ((fun (alias_map, alias) => inl () = quiet () in get_alias_map alias_map alias) : rust.ref (near.lookup_map sm'.std_string alias_accounts) * sm'.std_string -> alias_accounts_option))

  inl main () =
      if is_rust ()
      then main_native ()
      else ()
  """,
  timeout: 300_000
)
```