@tonconnect/protocol reference

npm i @tonconnect/protocol

new SessionCrypto(keyPair?: KeyPair)

encrypt(message: string, receiverPublicKey: Uint8Array): Uint8Array;

decrypt(message: Uint8Array, senderPublicKey: Uint8Array): string;

stringifyKeypair(): KeyPair;

interface KeyPair {
    publicKey: string;
    secretKey: string;
}

interface TonAddressItem {
    name: 'ton_addr';
    network?: ChainId;
}

interface TonProofItem {
    name: 'ton_proof';
    payload: string;
}

interface ConnectRequest {
    manifestUrl: string;
    items: ConnectItem[];
}

interface DisconnectRpcRequest {
    method: 'disconnect';
    params: [];
    id: string;
}

interface SendTransactionRpcRequest {
    method: 'sendTransaction';
    params: [string];
    id: string;
}

interface SignDataRpcRequest {
    method: 'signData';
    params: [string];
    id: string;
}

interface SignMessageRpcRequest {
    method: 'signMessage';
    params: [string];
    id: string;
}

interface DeviceInfo {
    platform: 'iphone' | 'ipad' | 'android' | 'windows' | 'mac' | 'linux' | 'browser';
    appName: string;
    appVersion: string;
    maxProtocolVersion: number;
    features: Feature[];
}

interface WireSendTransaction {
    m: 'st';
    f?: string;
    n?: string;
    vu?: number;
    ms?: WireMessage[];
    i?: WireItem[];
}

interface WireSignMessage {
    m: 'sm';
    f?: string;
    n?: string;
    vu?: number;
    ms?: WireMessage[];
    i?: WireItem[];
}

interface WireSignDataText {
    t: 'text';
    tx: string;
}

interface WireSignDataBinary {
    t: 'binary';
    b: string;
}

interface WireSignDataCell {
    t: 'cell';
    s: string;
    c: string;
}

interface WireMessage {
    a: string;
    am: string;
    p?: string;
    si?: string;
    ec?: { [k: number]: string };
}

interface WireTonItem {
    t: 'gram';
    a: string;
    am: string;
    p?: string;
    si?: string;
    ec?: { [k: number]: string };
}

interface WireJettonItem {
    t: 'jetton';
    ma: string;
    d: string;
    am: string;
    aa?: string;
    rd?: string;
    cp?: string;
    fa?: string;
    fp?: string;
    qi?: string;
}

interface WireNftItem {
    t: 'nft';
    na: string;
    no: string;
    aa?: string;
    rd?: string;
    cp?: string;
    fa?: string;
    fp?: string;
    qi?: string;
}

interface RpcTonItem {
    type: 'gram';
    address: string;
    amount: string;
    payload?: string;
    stateInit?: string;
    extra_currency?: { [k: number]: string };
}

interface RpcJettonItem {
    type: 'jetton';
    master: string;
    destination: string;
    amount: string;
    attachAmount?: string;
    responseDestination?: string;
    customPayload?: string;
    forwardAmount?: string;
    forwardPayload?: string;
    queryId?: string;
}

interface RpcNftItem {
    type: 'nft';
    nftAddress: string;
    newOwner: string;
    attachAmount?: string;
    responseDestination?: string;
    customPayload?: string;
    forwardAmount?: string;
    forwardPayload?: string;
    queryId?: string;
}

interface ConnectEventSuccess {
    event: 'connect';
    id: number;
    payload: { items: ConnectItemReply[]; device: DeviceInfo };
    response?: WalletResponse<RpcMethod>;
}

interface ConnectEventError {
    event: 'connect_error';
    id: number;
    payload: { code: CONNECT_EVENT_ERROR_CODES; message: string };
}

interface TonAddressItemReply {
    name: 'ton_addr';
    address: string;
    network: ChainId;
    walletStateInit: string;
    publicKey: string;
}

interface TonProofItemReplySuccess {
    name: 'ton_proof';
    proof: { timestamp: number; domain: { lengthBytes: number; value: string }; payload: string; signature: string };
}

interface DisconnectEvent {
    event: 'disconnect';
    id: number;
    payload: {};
}

interface DisconnectRpcResponseSuccess {
    id: string;
    result: {};
}

interface DisconnectRpcResponseError {
    error: { code: DISCONNECT_ERROR_CODES; message: string; data?: unknown };
    id: string;
}

interface SendTransactionRpcResponseSuccess {
    result: string;
    id: string;
}

interface SendTransactionRpcResponseError {
    error: { code: SEND_TRANSACTION_ERROR_CODES; message: string; data?: unknown };
    id: string;
}

interface SignDataRpcResponseSuccess {
    result: { signature: string; address: string; timestamp: number; domain: string; payload: SignDataPayload };
    id: string;
}

interface SignDataRpcResponseError {
    error: { code: SIGN_DATA_ERROR_CODES; message: string };
    id: string;
}

interface SignMessageRpcResponseSuccess {
    result: { internalBoc: string };
    id: string;
}

interface SignMessageRpcResponseError {
    error: { code: SIGN_MESSAGE_ERROR_CODES; message: string; data?: unknown };
    id: string;
}

interface WalletResponseTemplateSuccess {
    result: string;
    id: string;
}

interface WalletResponseTemplateError {
    error: { code: number; message: string; data?: unknown };
    id: string;
}

type ChainId = CHAIN | string;

type AppMessage = ConnectRequest | AppRequest<keyof RpcRequests>;

type ConnectItem = TonAddressItem | TonProofItem;

type RpcRequests = {
    sendTransaction: SendTransactionRpcRequest;
    signData: SignDataRpcRequest;
    signMessage: SignMessageRpcRequest;
    disconnect: DisconnectRpcRequest;
};

type AppRequest<T extends RpcMethod> = RpcRequests[T];

type WireEmbeddedRequest = WireSendTransaction | WireSignMessage | WireSignData;

type WireSignData = { m: 'sd'; n?: string; f?: string } & (WireSignDataText | WireSignDataBinary | WireSignDataCell);

type WireItem = WireTonItem | WireJettonItem | WireNftItem;

type DecodedEmbeddedRequest = Omit<AppRequest<'sendTransaction' | 'signMessage' | 'signData'>, 'id'>;

type Feature =
    | SendTransactionFeatureDeprecated
    | SendTransactionFeature
    | SignDataFeature
    | SignMessageFeature
    | EmbeddedRequestFeature;

type FeatureName = Exclude<Feature, 'SendTransaction'>['name'];

type SendTransactionFeatureDeprecated = 'SendTransaction';

type StructuredItemType = 'gram' | 'jetton' | 'nft';

type SendTransactionFeature = {
    name: 'SendTransaction';
    maxMessages: number;
    extraCurrencySupported?: boolean;
    itemTypes?: StructuredItemType[];
};

type SignDataType = 'text' | 'binary' | 'cell';

type SignDataFeature = { name: 'SignData'; types: SignDataType[] };

type SignMessageFeature = {
    name: 'SignMessage';
    maxMessages: number;
    extraCurrencySupported?: boolean;
    itemTypes?: StructuredItemType[];
};

type EmbeddedRequestFeature = { name: 'EmbeddedRequest' };

type RpcMethod = 'disconnect' | 'sendTransaction' | 'signData' | 'signMessage';

type RpcStructuredItem = RpcTonItem | RpcJettonItem | RpcNftItem;

type ConnectEvent = ConnectEventSuccess | ConnectEventError;

type ConnectItemReply = TonAddressItemReply | TonProofItemReply;

type TonProofItemReply = TonProofItemReplySuccess | TonProofItemReplyError;

type TonProofItemReplyError = ConnectItemReplyError<TonProofItemReplySuccess['name']>;

type ConnectItemReplyError<T> = { name: T; error: { code: CONNECT_ITEM_ERROR_CODES; message?: string } };

type WalletEvent = ConnectEvent | DisconnectEvent;

type WalletMessage = WalletEvent | WalletResponse<RpcMethod>;

type DisconnectRpcResponse = DisconnectRpcResponseSuccess | DisconnectRpcResponseError;

type SendTransactionRpcResponse = SendTransactionRpcResponseSuccess | SendTransactionRpcResponseError;

type SignDataRpcResponse = SignDataRpcResponseSuccess | SignDataRpcResponseError;

type SignDataPayload =
    & { network?: ChainId; from?: string }
    & (SignDataPayloadText | SignDataPayloadBinary | SignDataPayloadCell);

type SignDataPayloadText = { type: 'text'; text: string };

type SignDataPayloadBinary = { type: 'binary'; bytes: string };

type SignDataPayloadCell = { type: 'cell'; schema: string; cell: string };

type SignMessageRpcResponse = SignMessageRpcResponseSuccess | SignMessageRpcResponseError;

type WalletResponseTemplate = WalletResponseTemplateSuccess | WalletResponseTemplateError;

type RpcResponses = {
    sendTransaction: { error: SendTransactionRpcResponseError; success: SendTransactionRpcResponseSuccess };
    signData: { error: SignDataRpcResponseError; success: SignDataRpcResponseSuccess };
    signMessage: { error: SignMessageRpcResponseError; success: SignMessageRpcResponseSuccess };
    disconnect: { error: DisconnectRpcResponseError; success: DisconnectRpcResponseSuccess };
};

type WalletResponseSuccess<T extends RpcMethod> = RpcResponses[T]['success'];

type WalletResponseError<T extends RpcMethod> = RpcResponses[T]['error'];

type WalletResponse<T extends RpcMethod> = WalletResponseSuccess<T> | WalletResponseError<T>;

enum CHAIN {
    MAINNET = '-239',
    TESTNET = '-3',
}

enum CONNECT_EVENT_ERROR_CODES {
    UNKNOWN_ERROR = 0,
    BAD_REQUEST_ERROR = 1,
    MANIFEST_NOT_FOUND_ERROR = 2,
    MANIFEST_CONTENT_ERROR = 3,
    UNKNOWN_APP_ERROR = 100,
    USER_REJECTS_ERROR = 300,
    METHOD_NOT_SUPPORTED = 400,
}

enum CONNECT_ITEM_ERROR_CODES {
    UNKNOWN_ERROR = 0,
    METHOD_NOT_SUPPORTED = 400,
}

enum DISCONNECT_ERROR_CODES {
    UNKNOWN_ERROR = 0,
    BAD_REQUEST_ERROR = 1,
    UNKNOWN_APP_ERROR = 100,
    METHOD_NOT_SUPPORTED = 400,
}

enum SEND_TRANSACTION_ERROR_CODES {
    UNKNOWN_ERROR = 0,
    BAD_REQUEST_ERROR = 1,
    UNKNOWN_APP_ERROR = 100,
    USER_REJECTS_ERROR = 300,
    METHOD_NOT_SUPPORTED = 400,
}

enum SIGN_DATA_ERROR_CODES {
    UNKNOWN_ERROR = 0,
    BAD_REQUEST_ERROR = 1,
    UNKNOWN_APP_ERROR = 100,
    USER_REJECTS_ERROR = 300,
    METHOD_NOT_SUPPORTED = 400,
}

enum SIGN_MESSAGE_ERROR_CODES {
    UNKNOWN_ERROR = 0,
    BAD_REQUEST_ERROR = 1,
    UNKNOWN_APP_ERROR = 100,
    USER_REJECTS_ERROR = 300,
    METHOD_NOT_SUPPORTED = 400,
}

Base64.encode(value: string | object | Uint8Array, urlSafe: boolean = false): string;

Base64.decode(
    value: string,
    urlSafe: boolean = false
): { toString(): string; toObject<T>(): T | null; toUint8Array(): Uint8Array };

function decodeWireEmbeddedRequest(wire: WireEmbeddedRequest): DecodedEmbeddedRequest;

function decodeEmbeddedRequestParam(reqParam: string): DecodedEmbeddedRequest;

function concatUint8Arrays(buffer1: Uint8Array, buffer2: Uint8Array): Uint8Array;

function splitToUint8Arrays(array: Uint8Array, index: number): [Uint8Array, Uint8Array];

function toHexString(byteArray: Uint8Array): string;

function hexToByteArray(hexString: string): Uint8Array;

function isNode(): boolean;