Provider API#

window.okxTonWallet.tonconnect

interface TonConnectBridge {
    deviceInfo: DeviceInfo;
    walletInfo?: WalletInfo;
    protocolVersion: number;
    connect(protocolVersion: number, message: ConnectRequest): Promise<ConnectEvent>;
    restoreConnection(): Promise<ConnectEvent>;
    send(message: AppRequest): Promise<WalletResponse>;
    listen(callback: (event: WalletEvent) => void): () => void;
}

{
    platform: 'browser',
    appName: 'OKX Wallet',
    appVersion: '3.3.19',
    maxProtocolVersion: 2,
    features: [
      'SendTransaction',
      {
        name: 'SendTransaction',
        maxMessages: 4,
      },
    ],
}

{
    name: 'OKX Wallet',
    app_name: 'okxTonWallet',
    image: 'https://static.okx.com/cdn/assets/imgs/247/58E63FEA47A2B7D7.png',
    about_url: 'https://www.okx.com/web3',
    platforms: ['chrome', 'firefox', 'safari'],
}

connect(protocolVersion: number, message: ConnectRequest): Promise<ConnectEvent>;

type ConnectRequest = {
  manifestUrl: string;
  items: ConnectItem[], // Data items shared with the application
}

type ConnectItem = TonAddressItem | TonProofItem

type TonAddressItem = {
  name: "ton_addr";
}

type TonProofItem = {
  name: "ton_proof";
  payload: string; // Arbitrary payload, such as nonce + expiration timestamp.
}

type ConnectEvent = ConnectEventSuccess | ConnectEventError;

type ConnectEventSuccess = {
  event: "connect";
  id: number; // increasing event counter
  payload: {
      items: ConnectItemReply[];
      device: DeviceInfo;
  }
}

type ConnectEventError = {
  event: "connect_error",
  id: number; // increasing event counter
  payload: {
      code: number;
      message: string;
  }
}

// Identical to the deviceInfo on the window.okxTonWallet.tonconnect object
type DeviceInfo = {
  platform: "iphone" | "ipad" | "android" | "windows" | "mac" | "linux";
  appName: string;
  appVersion: string;
  maxProtocolVersion: number;
  features: Feature[];
}

type Feature = { name: 'SendTransaction', maxMessages: number } // `maxMessages` is maximum number of messages in one `SendTransaction` that the wallet supports

type ConnectItemReply = TonAddressItemReply | TonProofItemReply;

// Untrusted data returned by the wallet.
// If you need a guarantee that the user owns this address and public key, you need to additionally request a ton_proof.
type TonAddressItemReply = {
  name: "ton_addr";
  address: string; // TON address raw (`0:<hex>`)
  network: NETWORK; // network global_id
  publicKey: string; // HEX string without 0x
  walletStateInit: string; // Base64 (not url safe) encoded stateinit cell for the wallet contract
}

type TonProofItemReply = {
  name: "ton_proof";
  proof: {
    timestamp: string; // 64-bit unix epoch time of the signing operation (seconds)
    domain: {
      lengthBytes: number; // AppDomain Length
      value: string;  // app domain name (as url part, without encoding)
    };
    signature: string; // base64-encoded signature
    payload: string; // payload from the request
  }
}

// Currently supports only the mainnet
enum NETWORK {
  MAINNET = '-239',
  TESTNET = '-3'
}

const result = await window.okxTonWallet.tonconnect.connect(2, {
    manifestUrl: 'https://example.com/manifest.json',
    items: [{ name: 'ton_addr' }]
})

if (result.event === 'connect') {
    console.log(result.payload.items[0].address)
} else {
    console.log(result.payload.message)
}

const result = await window.okxTonWallet.tonconnect.connect(2, {
    manifestUrl: 'https://example.com/manifest.json',
    items: [
        { name: 'ton_addr' },
        { name: 'ton_proof', payload: '123' }
    ]
})

if(result.event === 'connect') {
    console.log(result.payload.items[0].address)
    console.log(result.payload.items[1].proof)
} else {
    console.log(result.payload.message)
}

restoreConnection(): Promise<ConnectEvent>;

const result = await window.okxTonWallet.tonconnect.restoreConnection()

if(result.event === 'connect') {
    console.log(result.payload.items[0].address)
} else {
    console.log(result.payload.message)
}

send(message: AppRequest): Promise<WalletResponse>;

interface AppRequest {
    method: string;
    params: string[];
    id: string;
}

interface SendTransactionRequest {
    method: 'sendTransaction';
    params: [<transaction-payload>];
    id: string;
}

{
  "valid_until": 1658253458,
  "network": "-239",
  "from": "0:348bcf827469c5fc38541c77fdd91d4e347eac200f6f2d9fd62dc08885f0415f",
  "messages": [
    {
      "address": "0:412410771DA82CBA306A55FA9E0D43C9D245E38133CB58F1457DFB8D5CD8892F",
      "amount": "20000000",
      "stateInit": "base64bocblahblahblah==" //deploy contract
    },{
      "address": "0:E69F10CC84877ABF539F83F879291E5CA169451BA7BCE91A37A5CED3AB8080D3",
      "amount": "60000000",
      "payload": "base64bocblahblahblah==" //transfer nft to new deployed account 0:412410771DA82CBA306A55FA9E0D43C9D245E38133CB58F1457DFB8D5CD8892F
    }
  ]
}

type SendTransactionResponse = SendTransactionResponseSuccess | SendTransactionResponseError;

interface SendTransactionResponseSuccess {
    result: <boc>;
    id: string;

}

interface SendTransactionResponseError {
   error: { code: number; message: string };
   id: string;
}

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

type DisconnectResponse = DisconnectResponseSuccess | DisconnectResponseError;

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

}

interface DisconnectResponseError {
   error: { code: number; message: string };
   id: string;
}

listen(callback: (event: WalletEvent) => void): () => void;

interface WalletEvent {
    event: WalletEventName;
    id: number; // increasing event counter
    payload: <event-payload>; // specific payload for each event
}

type WalletEventName = 'connect' | 'connect_error' | 'disconnect';

const accountChanged = () => {}
window.okxTonWallet.tonconnect.on('accountChanged', accountChanged)
window.okxTonWallet.tonconnect.off('accountChanged', accountChanged)