@0xpolygonid/js-sdk 1.0.0-beta.0

package/dist/types/circuits/models.d.ts

@@ -0,0 +1,181 @@
+import { Signature } from '@iden3/js-crypto';
+import { Claim, Claim as CoreClaim, Id } from '@iden3/js-iden3-core';
+import { Hash, Proof } from '@iden3/js-merkletree';
+/**
+ * TreeState is model for merkle tree roots
+ *
+ * @export
+ * @beta
+ * @interface   TreeState
+ */
+export interface TreeState {
+    state: Hash;
+    claimsRoot: Hash;
+    revocationRoot: Hash;
+    rootOfRoots: Hash;
+}
+/**
+ * claim non revocation status for circuit
+ * TreeState and Proof of inclusion / non-inclusion
+ *
+ * @export
+ * @beta
+ * @interface   ClaimNonRevStatus
+ */
+export interface ClaimNonRevStatus {
+    treeState: TreeState;
+    proof: Proof;
+}
+/**
+ * Query represents basic request to claim slot verification
+ *
+ * @export
+ * @beta
+ * @class Query
+ */
+export declare class Query {
+    slotIndex: number;
+    values: bigint[];
+    operator: number;
+    valueProof?: ValueProof;
+    /**
+     * Validates Query instance
+     *
+     */
+    validate(): void;
+}
+/**
+ * CircuitID is alias for circuit identifier
+ *
+ * @export
+ * @enum {number}
+ */
+export declare enum CircuitId {
+    AuthV2 = "authV2",
+    StateTransition = "stateTransition",
+    AtomicQueryMTPV2 = "credentialAtomicQueryMTPV2",
+    AtomicQuerySigV2 = "credentialAtomicQuerySigV2"
+}
+/**
+ * Claim structure for circuit inputs
+ *
+ * @export
+ * @beta
+ * @class CircuitClaim
+ */
+export declare class CircuitClaim {
+    issuerId: Id;
+    claim: CoreClaim;
+    treeState: TreeState;
+    proof: Proof;
+    nonRevProof: ClaimNonRevStatus;
+    signatureProof: BJJSignatureProof;
+}
+/**
+ *
+ * Claim for circuit with non revocation proof and signature proof
+ * @export
+ * @beta
+ * @interface   ClaimWithSigProof
+ */
+export interface ClaimWithSigProof {
+    issuerID: Id;
+    claim: Claim;
+    nonRevProof: MTProof;
+    signatureProof: BJJSignatureProof;
+}
+/**
+ * Claim for circuit with non revocation proof and proof of merkle tree inclusion
+ *
+ * @export
+ * @beta
+ * @interface   ClaimWithMTPProof
+ */
+export interface ClaimWithMTPProof {
+    issuerID?: Id;
+    claim: Claim;
+    incProof: MTProof;
+    nonRevProof: MTProof;
+}
+/**
+ * prepared bjj signature for circuits with auth bjj claim data
+ *
+ * @export
+ * @beta
+ * @interface   BJJSignatureProof
+ */
+export interface BJJSignatureProof {
+    signature: Signature;
+    issuerAuthClaim?: Claim;
+    issuerAuthIncProof: MTProof;
+    issuerAuthNonRevProof: MTProof;
+}
+/**
+ * prepared mtp with a tree state
+ *
+ * @export
+ * @beta
+ * @interface   MTProof
+ */
+export interface MTProof {
+    proof: Proof;
+    treeState?: TreeState;
+}
+/**
+ * global identity state proof
+ *
+ * @export
+ * @beta
+ * @interface   GISTProof
+ */
+export interface GISTProof {
+    root: Hash;
+    proof: Proof;
+}
+/**
+ * List of errors of circuit inputs processing
+ *
+ * @export
+ * @enum {number}
+ */
+export declare enum CircuitError {
+    EmptyAuthClaimProof = "empty auth claim mtp proof",
+    EmptyAuthClaimProofInTheNewState = "empty auth claim mtp proof in the new state",
+    EmptyAuthClaimNonRevProof = "empty auth claim non-revocation mtp proof",
+    EmptyChallengeSignature = "empty challenge signature",
+    EmptyClaimSignature = "empty claim signature",
+    EmptyClaimProof = "empty claim mtp proof",
+    EmptyClaimNonRevProof = "empty claim non-revocation mtp proof",
+    EmptyIssuerAuthClaimProof = "empty issuer auth claim mtp proof",
+    EmptyIssuerAuthClaimNonRevProof = "empty issuer auth claim non-revocation mtp proof",
+    EmptyJsonLDQueryProof = "empty JSON-LD query mtp proof",
+    EmptyJsonLDQueryValue = "empty JSON-LD query value",
+    EmptyJsonLDQueryPath = "empty JSON-LD query path",
+    EmptyQueryValue = "empty query value",
+    EmptyJsonLDQueryValues = "empty JSON-LD query values",
+    EmptyId = "empty Id",
+    EmptyChallenge = "empty challenge",
+    EmptyGlobalProof = "empty global identity mtp proof",
+    EmptyRequestID = "empty request ID"
+}
+/**
+ * ValueProof represents a Merkle Proof for a value stored as MT
+ *
+ * @export
+ * @beta
+ * @class ValueProof
+ */
+export declare class ValueProof {
+    path: bigint;
+    value: bigint;
+    mtp: Proof;
+    /**
+     * Creates an instance of ValueProof.
+     */
+    constructor();
+    /**
+     * validates instance of ValueProof
+     *
+     */
+    validate(): void;
+}

package/dist/types/circuits/state-transition.d.ts

@@ -0,0 +1,50 @@
+import { Signature } from '@iden3/js-crypto';
+import { Id } from '@iden3/js-iden3-core';
+import { Hash, Proof } from '@iden3/js-merkletree';
+import { BaseConfig } from './common';
+import { ClaimWithMTPProof, TreeState } from './models';
+/**
+ * StateTransition circuit representation
+ * Inputs and public signals declaration, marshalling and parsing
+ *
+ * @export
+ * @beta
+ * @class StateTransitionInputs
+ * @extends {BaseConfig}
+ */
+export declare class StateTransitionInputs extends BaseConfig {
+    id: Id;
+    oldTreeState: TreeState;
+    newTreeState: TreeState;
+    isOldStateGenesis: boolean;
+    authClaim: ClaimWithMTPProof;
+    authClaimNewStateIncProof: Proof;
+    signature: Signature;
+    /**
+     * CircuitInputMarshal returns Circom private inputs for stateTransition.circom
+     *
+     * @returns Uint8Array
+     */
+    inputsMarshal(): Uint8Array;
+}
+/**
+ * Public signals of StateTransition circuit
+ *
+ * @export
+ * @beta
+ * @class StateTransitionPubSignals
+ */
+export declare class StateTransitionPubSignals {
+    userId: Id;
+    oldUserState: Hash;
+    newUserState: Hash;
+    isOldStateGenesis: boolean;
+    /**
+     *
+     *
+     * PubSignalsUnmarshal unmarshal stateTransition.circom public signal
+     * @param {Uint8Array} data
+     * @returns StateTransitionPubSignals
+     */
+    pubSignalsUnmarshal(data: Uint8Array): StateTransitionPubSignals;
+}

package/dist/types/credentials/credential-wallet.d.ts

@@ -0,0 +1,248 @@
+import { DID } from '@iden3/js-iden3-core';
+import { IDataStorage } from '../storage/interfaces';
+import { W3CCredential, ProofQuery, SubjectPosition, MerklizedRootPosition, CredentialStatus, RHSCredentialStatus, RevocationStatus, IssuerData } from './../verifiable';
+import { JSONSchema } from '../schema-processor';
+/**
+ * Request to core library to create Core Claim from W3C Verifiable Credential
+ *
+ * @export
+ * @beta
+ * @interface CredentialRequest
+ */
+export interface CredentialRequest {
+    /**
+     * JSON credential schema
+     */
+    credentialSchema: string;
+    /**
+     * Credential type
+     */
+    type: string;
+    /**
+     * Credential subject, usually contains claims and identifier
+     */
+    credentialSubject: {
+        [key: string]: string | object | number;
+    };
+    /**
+     * expiration time
+     */
+    expiration?: number;
+    /**
+     * claim version
+     */
+    version?: number;
+    /**
+     * revocation nonce
+     */
+    revNonce?: number;
+    /**
+     * subject position (index / value / none)
+     */
+    subjectPosition?: SubjectPosition;
+    /**
+     * merklizedRootPosition (index / value / none)
+     */
+    merklizedRootPosition?: MerklizedRootPosition;
+}
+/**
+ * Interface to work with credential wallets
+ *
+ * @export
+ * @beta
+ * @interface   ICredentialWallet
+ */
+export interface ICredentialWallet {
+    /**
+     * List of W3C Credential
+     *
+     * @returns `Promise<W3CCredential[]`
+     */
+    list(): Promise<W3CCredential[]>;
+    /**
+     * saves W3C credential (upsert)
+     * @param {W3CCredential} credential - credential to save
+     * @returns `Promise<void>`
+     *
+     */
+    save(credential: W3CCredential): Promise<void>;
+    /**
+     * saves the batch of W3C credentials (upsert)
+     * @param {W3CCredential[]} credentials - credentials to save
+     * @returns `Promise<void>`
+     */
+    saveAll(credentials: W3CCredential[]): Promise<void>;
+    /**
+     *
+     * removes W3C credentials from data storage
+     * @param {string} id
+     * @returns `Promise<void>`
+     */
+    remove(id: string): Promise<void>;
+    /**
+     * Find credential using iden3 query language
+     *
+     * @param {ProofQuery} query  - protocol query to find credential
+     * @returns `Promise<W3CCredential[]>`
+     */
+    findByQuery(query: ProofQuery): Promise<W3CCredential[]>;
+    /**
+     * Finds the credential by its id
+     *
+     * @param {string} id - id of credential
+     * @returns `Promise<W3CCredential | undefined>`
+     */
+    findById(id: string): Promise<W3CCredential | undefined>;
+    /**
+     * Finds credentials by JSON-LD schema and type
+     *
+     * @param {string} context - the URL of JSON-LD schema where type is defined
+     * @returns `Promise<W3CCredential[]>`
+     */
+    findByContextType(context: string, type: string): Promise<W3CCredential[]>;
+    /**
+     * Filters given credentials with given credential subject
+     *
+     * @param {W3CCredential[]} credentials - credentials to filter
+     * @param {DID} subject - credential subject id
+     * @returns `Promise<W3CCredential[]>`
+     */
+    filterByCredentialSubject(credentials: W3CCredential[], subject: DID): Promise<W3CCredential[]>;
+    /**
+     * Finds Auth BJJ credential for given user
+     *
+     * @param {DID} did - the issuer of Auth BJJ credential
+     * @returns `Promise<W3CCredential>` W3CCredential with AuthBJJCredential type
+     */
+    getAuthBJJCredential(did: DID): Promise<W3CCredential>;
+    /**
+     * Fetches or Builds a revocation status for a given credential
+     * Supported types for credentialStatus field: SparseMerkleTreeProof, Iden3ReverseSparseMerkleTreeProof
+     *
+     * @param {W3CCredential} cred - credential for which lib should build revocation status
+     * @returns `Promise<RevocationStatus>`
+     */
+    getRevocationStatusFromCredential(cred: W3CCredential): Promise<RevocationStatus>;
+    /**
+     * Fetches Revocation status depended on type
+     *
+     * @param {(CredentialStatus | RHSCredentialStatus)} credStatus - credentialStatus field of the Verifiable Credential.  Supported types for credentialStatus field: SparseMerkleTreeProof, Iden3ReverseSparseMerkleTreeProof
+     * @param {DID} issuerDID  - credential issuer identity
+     * @param {IssuerData} issuerData - metadata of the issuer, usually contained in the BjjSignature / Iden3SparseMerkleTreeProof
+     * @returns `Promise<RevocationStatus>`
+     */
+    getRevocationStatus(credStatus: CredentialStatus | RHSCredentialStatus, issuerDID: DID, issuerData: IssuerData): Promise<RevocationStatus>;
+    /**
+     * Creates a W3C verifiable Credential object
+     *
+     * @param {string} hostUrl - URL that will be used as a prefix for credential identifier
+     * @param {DID} issuer - issuer identity
+     * @param {CredentialRequest} request - specification of claim creation parameters
+     * @param {JSONSchema} schema - JSON schema for W3C Verifiable Credential
+     * @param {string} [rhsUrl] - URL of reverse hash service, if it's not set - host url is used for 'SparseMerkleTreeProof' credential status type
+     * @returns W3CCredential
+     */
+    createCredential(hostUrl: string, issuer: DID, request: CredentialRequest, schema: JSONSchema, rhsUrl?: string): W3CCredential;
+    /**
+     * Finds non-revoked credential from a given list by resolving their credential status
+     *
+     * @param {W3CCredential[]} creds
+     * @returns `{Promise<{
+     *     cred: W3CCredential;
+     *     revStatus: RevocationStatus;
+     *   }>` not revoked credential and it's revocation status
+     */
+    findNonRevokedCredential(creds: W3CCredential[]): Promise<{
+        cred: W3CCredential;
+        revStatus: RevocationStatus;
+    }>;
+}
+/**
+ *
+ * Wallet instance is a wrapper of CRUD logic for W3C credentials,
+ * also it allows to fetch revocation statuses.
+ *
+ * @export
+ * @beta
+ * @class CredentialWallet
+ * @implements implements ICredentialWallet interface
+ */
+export declare class CredentialWallet implements ICredentialWallet {
+    private readonly _storage;
+    /**
+     * Creates an instance of CredentialWallet.
+     * @param {IDataStorage} _storage - - data storage to access credential / identity / Merkle tree data
+     */
+    constructor(_storage: IDataStorage);
+    /**
+     * {@inheritDoc ICredentialWallet.getAuthBJJCredential}
+     */
+    getAuthBJJCredential(did: DID): Promise<W3CCredential>;
+    /**
+     * {@inheritDoc ICredentialWallet.getRevocationStatusFromCredential}
+     */
+    getRevocationStatusFromCredential(cred: W3CCredential): Promise<RevocationStatus>;
+    /**
+     * {@inheritDoc ICredentialWallet.getRevocationStatus}
+     */
+    getRevocationStatus(credStatus: CredentialStatus | RHSCredentialStatus, issuerDID: DID, issuerData: IssuerData): Promise<RevocationStatus>;
+    /**
+     * {@inheritDoc ICredentialWallet.createCredential}
+     */
+    createCredential: (hostUrl: string, issuer: DID, request: CredentialRequest, schema: JSONSchema, rhsUrl?: string) => W3CCredential;
+    /**
+     * {@inheritDoc ICredentialWallet.findById}
+     */
+    findById(id: string): Promise<W3CCredential | undefined>;
+    /**
+     * {@inheritDoc ICredentialWallet.findByContextType}
+     */
+    findByContextType(context: string, type: string): Promise<W3CCredential[]>;
+    /**
+     * {@inheritDoc ICredentialWallet.save}
+     */
+    save(credential: W3CCredential): Promise<void>;
+    /**
+     * {@inheritDoc ICredentialWallet.saveAll}
+     */
+    saveAll(credentials: W3CCredential[]): Promise<void>;
+    /**
+     * {@inheritDoc ICredentialWallet.remove}
+     */
+    remove(id: string): Promise<void>;
+    /**
+     * {@inheritDoc ICredentialWallet.list}
+     */
+    list(): Promise<W3CCredential[]>;
+    /**
+     * {@inheritDoc ICredentialWallet.findByQuery}
+     */
+    findByQuery(query: ProofQuery): Promise<W3CCredential[]>;
+    /**
+     * {@inheritDoc ICredentialWallet.filterByCredentialSubject}
+     */
+    filterByCredentialSubject(credentials: W3CCredential[], subject: DID): Promise<W3CCredential[]>;
+    findNonRevokedCredential(creds: W3CCredential[]): Promise<{
+        cred: W3CCredential;
+        revStatus: RevocationStatus;
+    }>;
+}
+/**
+ * Checks if issuer did is created from given state is genesis
+ *
+ * @export
+ * @param {string} issuer - did (string)
+ * @param {string} state  - hex state
+ * @returns boolean
+ */
+export declare function isIssuerGenesis(issuer: string, state: string): boolean;
+/**
+ * Checks if id is created from given state and type is genesis
+ *
+ * @export
+ * @param {bigint} id
+ * @param {bigint} state
+ * @param {Uint8Array} type
+ * @returns boolean - returns if id is genesis
+ */
+export declare function isGenesisStateId(id: bigint, state: bigint, type: Uint8Array): boolean;

package/dist/types/credentials/index.d.ts

@@ -0,0 +1 @@
+export * from './credential-wallet';

package/dist/types/credentials/revocation.d.ts

@@ -0,0 +1,97 @@
+import { Hash, Merkletree } from '@iden3/js-merkletree';
+import { IStateStorage } from '../storage/interfaces';
+import { DID } from '@iden3/js-iden3-core';
+import { CredentialStatus, RevocationStatus, RHSCredentialStatus } from '../verifiable';
+/**
+ * Interface to unite contains three trees: claim, revocation and rootOfRoots
+ * Also contains the current state of identity
+ * @export
+ * @beta
+ * @interface TreesModel
+ */
+export interface TreesModel {
+    claimsTree: Merkletree;
+    revocationTree: Merkletree;
+    rootsTree: Merkletree;
+    state: Hash;
+}
+declare enum NodeType {
+    Unknown = 0,
+    Middle = 1,
+    Leaf = 2,
+    State = 3
+}
+/**
+ * ProofNode is a partial Reverse Hash Service result
+ * it contains the current node hash and its children
+ *
+ * @export
+ * @beta
+ * @class ProofNode
+ */
+export declare class ProofNode {
+    hash: Hash;
+    children: Hash[];
+    /**
+     *
+     * Creates an instance of ProofNode.
+     * @param {Hash} [hash=ZERO_HASH] - current node hash
+     * @param {Hash[]} [children=[]] -  children of the node
+     */
+    constructor(hash?: Hash, children?: Hash[]);
+    /**
+     * Determination of Node type
+     * Can be: Leaf, Middle or State node
+     *
+     * @returns NodeType
+     */
+    nodeType(): NodeType;
+    /**
+     * JSON Representation of ProofNode with a hex values
+     *
+     * @returns {*} - ProofNode with hexes
+     */
+    toJSON(): {
+        hash: string;
+        children: string[];
+    };
+    /**
+     * Creates ProofNode Hashes from hex values
+     *
+     * @static
+     * @param {ProofNodeHex} hexNode
+     * @returns ProofNode
+     */
+    static fromHex(hexNode: ProofNodeHex): ProofNode;
+}
+interface ProofNodeHex {
+    hash: string;
+    children: string[];
+}
+/**
+ *
+ * Fetches and Builds a revocation status for a given credential
+ * Supported types for credentialStatus field: SparseMerkleTreeProof, Iden3ReverseSparseMerkleTreeProof
+ *
+ * @export
+ * @param {DID} issuer - issuer identity
+ * @param {(CredentialStatus | RHSCredentialStatus)} credStatus - credentialStatus field from the W3C verifiable credential
+ * @param {IStateStorage} stateStorage - storage to fetch current issuer status
+ * @returns Promise<RevocationStatus>
+ */
+export declare function getStatusFromRHS(issuer: DID, credStatus: CredentialStatus | RHSCredentialStatus, stateStorage: IStateStorage): Promise<RevocationStatus>;
+/**
+ * Pushes identity state information to a reverse hash service.
+ *
+ * A reverse hash service (RHS) is a centralized or decentralized service for storing publicly available data about identity.
+ * Such data are identity state and state of revocation tree and roots tree root tree.
+ *
+ * @export
+ * @param {Hash} state - current state of identity
+ * @param {TreesModel} trees - current trees of identity (claims, revocation, rootOfRoots )
+ * @param {string} rhsUrl - URL of service
+ * @param {number[]} [revokedNonces] - revoked nonces since last published info
+ * @returns void
+ */
+export declare function pushHashesToRHS(state: Hash, trees: TreesModel, rhsUrl: string, revokedNonces?: number[]): Promise<void>;
+export {};

package/dist/types/iden3comm/constants.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Constants for Iden3 protocol
+ */
+export declare const PROTOCOL_MESSAGE_TYPE: Readonly<{
+    AUTHORIZATION_REQUEST_MESSAGE_TYPE: string;
+    AUTHORIZATION_RESPONSE_MESSAGE_TYPE: string;
+    CREDENTIAL_ISSUANCE_REQUEST_MESSAGE_TYPE: string;
+    CREDENTIAL_FETCH_REQUEST_MESSAGE_TYPE: string;
+    CREDENTIAL_OFFER_MESSAGE_TYPE: string;
+    CREDENTIAL_ISSUANCE_RESPONSE_MESSAGE_TYPE: string;
+    DEVICE_REGISTRATION_REQUEST_MESSAGE_TYPE: string;
+    MESSAGE_FETCH_REQUEST_MESSAGE_TYPE: string;
+    PROOF_GENERATION_REQUEST_MESSAGE_TYPE: string;
+    PROOF_GENERATION_RESPONSE_MESSAGE_TYPE: string;
+    REVOCATION_STATUS_REQUEST_MESSAGE_TYPE: string;
+    REVOCATION_STATUS_RESPONSE_MESSAGE_TYPE: string;
+}>;
+/**
+ * Media types for iden3 comm communication protocol
+ *
+ * @export
+ * @enum {number}
+ */
+export declare enum MediaType {
+    ZKPMessage = "application/iden3-zkp-json",
+    PlainMessage = "application/iden3comm-plain-json"
+}

package/dist/types/iden3comm/errors.d.ts

@@ -0,0 +1,8 @@
+export declare const ErrNotProtocolMessage = "the envelope is not a protocol message";
+export declare const ErrNotEnvelopeStub = "the envelope doesn't contain field protected";
+export declare const ErrNotHeaderStub = "the envelope doesn't contain field typ";
+export declare const ErrUnknownCircuitID = "unknown circuit ID. can't verify msg sender";
+export declare const ErrSenderNotUsedTokenCreation = "sender of message is not used for jwz token creation";
+export declare const ErrPackedWithUnsupportedCircuit = "message was packed with unsupported circuit";
+export declare const ErrProofIsInvalid = "message proof is invalid";
+export declare const ErrStateVerificationFailed = "message state verification failed";

package/dist/types/iden3comm/index.d.ts

@@ -0,0 +1,5 @@
+export * from './packageManager';
+export * from './packers';
+export * from './types';
+import * as PROTOCOL_CONSTANTS from './constants';
+export { PROTOCOL_CONSTANTS };

package/dist/types/iden3comm/packageManager.d.ts

@@ -0,0 +1,31 @@
+import { BasicMessage, IPackageManager, IPacker, PackerParams } from './types';
+import { MediaType } from './constants';
+/**
+ * Basic package manager for iden3 communication protocol
+ *
+ * @export
+ * @beta
+ * @class PackageManager
+ * @implements implements IPackageManager interface
+ */
+export declare class PackageManager implements IPackageManager {
+    packers: Map<MediaType, IPacker>;
+    /**
+     * Creates an instance of PackageManager.
+     */
+    constructor();
+    /** {@inheritDoc IPackageManager.registerPackers} */
+    registerPackers(packers: Array<IPacker>): void;
+    /** {@inheritDoc IPackageManager.pack} */
+    pack(mediaType: MediaType, payload: Uint8Array, params: PackerParams): Promise<Uint8Array>;
+    /** {@inheritDoc IPackageManager.unpack} */
+    unpack(envelope: Uint8Array): Promise<{
+        unpackedMessage: BasicMessage;
+        unpackedMediaType: MediaType;
+    }>;
+    /** {@inheritDoc IPackageManager.unpackWithType} */
+    unpackWithType(mediaType: MediaType, envelope: Uint8Array): Promise<BasicMessage>;
+    private unpackWithSafeEnvelope;
+    /** {@inheritDoc IPackageManager.getMediaType} */
+    getMediaType(envelope: string): MediaType;
+}

package/dist/types/iden3comm/packers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './zkp';
+export * from './plain';

package/dist/types/iden3comm/packers/plain.d.ts

@@ -0,0 +1,34 @@
+import { PlainPackerParams } from './../types/packer';
+import { BasicMessage, IPacker } from '../types';
+import { MediaType } from '../constants';
+/**
+ * Plain packer just serializes bytes to JSON and adds media type
+ *
+ * @export
+ * @beta
+ * @class PlainPacker
+ * @implements implements IPacker interface
+ */
+export declare class PlainPacker implements IPacker {
+    /**
+     * Pack returns packed message to transport envelope
+     *
+     * @param {Uint8Array} payload - json message serialized
+     * @param {PlainPackerParams} _params - not used here
+     * @returns `Promise<Uint8Array>`
+     */
+    pack(payload: Uint8Array, _params: PlainPackerParams): Promise<Uint8Array>;
+    /**
+     * Unpack returns unpacked message from transport envelope
+     *
+     * @param {Uint8Array} envelope - packed envelope (serialized json with media type)
+     * @returns `Promise<BasicMessage>`
+     */
+    unpack(envelope: Uint8Array): Promise<BasicMessage>;
+    /**
+     * returns media type for plain message
+     *
+     * @returns MediaType
+     */
+    mediaType(): MediaType;
+}