Client API

Client manages multiple blockchain account at a time. Client listens to multiple topic for invites at a time.

abstract class Client {
  // ---------- Methods ----------------------------------------------- //

  // initializes the client with persisted storage and a network connection and keyserver URL
  public abstract init(params: {
    keyserverUrl?: string; //optional. If value not supplied default to keys.walletconnect.com
  }): Promise<void>;

  // exposed IdentityClient.register method
  // registers invite key if not yet registered on this client and starts listening on invites if private is false
  // returns the public identity key. Method should throw 'signatureRejected' if any errors comes from onSign promise. 
  public abstract register(params: {
    account: string;
    private?: boolean;
    domain: string,
    onSign: (message: string) => Promise<Cacao.Signature>
  }): Promise<string>;

  // exposed IdentityClient.unregister method
  // - must not unregister invite key but must stop listening for invites
  public abstract unregister(params: {
    account: string;
  }): Promise<void>;

  // queries the keyserver with a blockchain account
  // returns the invite key
  public abstract resolve(params: {
    account: string;
  }): Promise<string>;

  // unregisters an invite key from keyserver 
  // stops listening for invites
  public abstract goPrivate(params: {
    account: string;
  }): Promise<void>;

  // registers an invite key if not yet registered on this client from keyserver 
  // starts listening for invites
  // returns the public invite key
  public abstract goPublic(params: {
    account: string;
  }): Promise<string>;

  // sends a chat invite 
  // creates and stores SentInvite with `pending` state
  // returns an invite id
  public abstract invite(params: {
    invite: Invite;
  }): Promise<number>;

  // accepts a chat invite by id from account specified as inviteeAccount in Invite
  // returns thread topic
  public abstract accept(params: {
    inviteId: number;
  }): Promise<string>;

  // rejects a chat invite by id from account specified as inviteeAccount in Invite
  public abstract reject(params: {
    inviteId: string;
  }): Promise<void>;

  // sends a chat message to an active chat thread from account specified as selfAccount in Thread
  public abstract message(params: {
    topic: string;
    message: string;
    media?: Media
  }): Promise<void>;

  // ping its peer to evaluate if it's currently online
  public abstract ping(params: {
    topic: string;
  }): Promise<void>

  // leaves a chat thread and stops receiving messages
  public abstract leave(params: {
    topic: string;
  }): Promise<void>;

  // returns all invites matching an inviteeAccount from Invite 
  // returns maps of invites indexed by id
  public abstract getReceivedInvites(params: {
    account: string;
  }): Promise<Map<number, ReceivedInvite>>

  // returns all pending invites matching an inviterAccount from SentInvite 
  // returns maps of invites indexed by id
  public abstract getSentInvites(params: {
    account: string;
  }): Promise<Map<number, SentInvite>>;

  // returns all threads matching an selfAccount from Thread 
  // returns map of threads indexed by topic
  public abstract getThreads(params: {
    account: string;
  }): Promise<Map<string, Thread>>;

  // returns all messages matching a thread's topic / returns array of messages
  public abstract getMessages(params: {
    topic: string;
  }): Promise<[Message]>;

  // ---------- Events ----------------------------------------------- //

  // subscribe to new chat invites received
  public abstract on("chat_invite", ({ invite: ReceivedInvite }) => {}): void;

  // subscribe to chat invite being accepted
  public abstract on("chat_invite_accepted", ({ topic: string, invite: SentInvite}) => {}): void;
  
  // subscribe to chat invite being rejected
  public abstract on("chat_invite_rejected", ({ invite: SentInvite}) => {}): void;

  // subscribe to new chat messages received
  public abstract on("chat_message", ({ payload: Message }) => {}): void;

  // subscribe to new chat thread left
  public abstract on("chat_left",  ({ topic: string }) => {}): void;
}