Invite

  hash: vector<u8>,
  user: address

  id: sui::object::UID,
  required: bool

  id: sui::object::UID,
  registry: sui::table::Table<std::string::String, Invite>

  invite_key: std::string::String

  public fun assert_invite_exists(
    user_invite_registry: &UserInviteRegistry,
    invite_key: String
  ) {
    let has_record = has_record(
      user_invite_registry,
      invite_key
    );

    assert!(has_record, EInviteDoesNotExist);
  }

  public fun assert_invite_not_required(
    invite_config: &InviteConfig
  ) {
    let is_invite_required = is_invite_required(
      invite_config
    );

    assert!(!is_invite_required, EInviteNotAllowed);
  }

  public fun assert_invite_is_valid(
    invite_code: String,
    invite_key: String,
    invite_hash: vector<u8>
  ) {
    let is_invite_valid = is_invite_valid(
      invite_code,
      invite_key,
      invite_hash
    );

    assert!(is_invite_valid, EInviteInvalid);
  }

  public fun get_destructured_invite(
    user_invite_registry: &UserInviteRegistry,
    invite_key: String
  ): (vector<u8>, address) {
    let invite = *user_invite_registry.registry.borrow(invite_key);

    let Invite {
      hash,
      user
    } = invite;

    (hash, user)
  }

  public fun has_record(
    user_invite_registry: &UserInviteRegistry,
    invite_key: String
  ): bool {
    user_invite_registry.registry.contains(invite_key)
  }

  public fun is_invite_required(
    invite_config: &InviteConfig
  ): bool {
    invite_config.required
  }

  public fun is_invite_valid(
    invite_code: String,
    invite_key: String,
    invite_hash: vector<u8>
  ): bool {
    let mut combined = utf8(b"");

    combined.append(invite_code);
    combined.append(invite_key);

    let bytes = into_bytes(combined);

    let computed_hash_bytes = sha3_256(bytes);

    let computed_length = computed_hash_bytes.length();
    let provided_length = invite_hash.length();

    if (computed_length != provided_length) {
      return false
    };

    let mut index = 0;

    while (index < computed_length) {
      if (computed_hash_bytes[index] != invite_hash[index]) {
        return false
      };

      index = index + 1;
    };

    true
  }