Mantle Network | Building the Liquidity Chain of the Future

This guide is made for developers interested in integrating Coin98 Extension Wallet with Mantle Network.

If you are a user who wants to experience Coin98 Wallet, then please head over to https://coin98.com/wallet for more details.

⚠️ Note: For existing info on Mantle's mainnet and testnet configurations, pls refer https://docs.mantle.xyz/network/for-devs/developing-on-mantle#network-details.

Getting Started

Here's a quick example of a dApp connection requested via Coin98 Connect — https://connect.coin98.com/

Quick Start NPM Package — https://www.npmjs.com/package/@coin98-com/connect-sdk

Installation

npm install --save @coin98-com/connect-sdk

Usage

dApps Website Connection Example

import { Client, Chain } from '@coin98-com/connect-sdk'

const client = new Client()


client.connect(Chain.fantom, {
  logo: "Provide Your App Logo URL",
  name: "Your App Name",
  url: "Provide Your App URL"
})

Lite Without Any Handler (Example With React Native)

import { Client, Chain } from '@coin98-com/connect-sdk'

const client = new Client()


client.connect(Chain.fantom, {
  logo: "Provide Your App Logo URL",
  name: "Your App Name",
  url: "Provide Your App URL"
})

Common API

// Common API
client.request({
  method: "<Your Request Method Here>",
  params: [],
  redirect: "(Optional), Callback URL after handle request"
}): Promise<{ result, error }>

To detect Coin98 Extension with Mantle

To detect whether your browser is running Coin98 Extension, please use:

if(window.coin98 || window.ethereum || window.ethereum?.isCoin98){
    console.log('Coin98 Extension is installed!');
}

Notice: Coin98 Extension Testnet is under development and not available now. The Coin98 Extension on Ethereum JavaScript provider API is specified by EIP-1193. Support window.ethereum only and removal window.web3

To connect Coin98 Extension Wallet

To connect Coin98 Extension means to access the user's Mantle Network account(s).

// Connect & get accounts
window.ethereum.request({method: 'eth_accounts'});
// Alias for connection
window.ethereum.request({method: 'eth_requestAccounts'});
//Check if dapp connected
window.ethereum.isConnected();
//Check if the caller's current permissions
window.ethereum.request({method: 'wallet_getPermissions'});
//Check if request the given permissions 
window.ethereum.request({method: 'wallet_requestPermissions'});

To disconnect Coin98 Extension Wallet

To disconnect Coin98 Extension, please use:

window.ethereum.disconnect()

To experience functions

Once your account is connected, let's start experiencing more functions.

Get Current Account

return Promise<Array[String]>

- If wallet can not be found, return [] instead of throw Error

window.ethereum.request({ method: 'eth_accounts' }).then(accounts => {
  if (accounts[0]) {
    // Do something with accounts
  } else {
    // Wallet not found
  }
})

Check wallet whether exists or not

return Promise<{data: Boolean}>

window.ethereum.request({ method: 'has_wallet', params: ['mantle'] })
// Example
window.ethereum.request({ method: 'has_wallet', params: ['mantle'] }).then(() => {
  // Wallet Exists
}).catch(e => { 
  // Wallet not found
})

Sign Transaction

return: Promise<Signature | RPC: 2.0>

// Example Sign Transactionconst
const signature = window.ethereum.request({
    method: 'eth_signTransaction',
    params: [
        "from": "string",
        "to": "string",
        "gas": "string",
        "gasPrice": "string",
        "value": "string",
        "data": "string",
        "nonce": "string"
    ]
});

Transfer

return Promise<hash>

window.ethereum.request({
  method: 'eth_sendTransaction',
  params: [
    {
      from: 'string',
      to: 'string',
      gas: 'string',
      gasPrice: 'string',
      value: 'string',
      data: 'string',
      nonce: 'string'
    }
  ]
})

Decrypt

return Promise<string>

window.ethereum.request({
  method: 'eth_decrypt',
  params: [encryptedMessage, accounts[0]],
  })
   .then((decryptedMessage) =>
    console.log('The decrypted message is:', decryptedMessage)
  )
  .catch((error) => console.log(error.message));
})

Get Encryption Public Key

return Promise<string>— The public encryption key of the Ethereum account whose encryption key should be retrieved.

let encryptionPublicKey
window.ethereum.request({
  method: 'eth_getEncryptionPublicKey',
  params: [accounts[0]], // you must have access to the specified account
  })
  .then((result) => {
    encryptionPublicKey = result;
  })
  .catch((error) => {
    if (error.code === 4001) {
      // EIP-1193 userRejectedRequest error
      console.log("We can't encrypt anything without the key.");
    } else {
      console.error(error);
    }
  });

Encrypt

const ethUtil = require('ethereumjs-util');
const encryptedMessage = ethUtil.bufferToHex(
Buffer.from(
  JSON.stringify(
    sigUtil.encrypt(
      {
        publicKey: encryptionPublicKey,
        data: 'hello world!,
        version: 'x25519-xsalsa20-poly1305',
      }
    )
  ),
  'utf8'
)
);

Add Ethereum Chain

result — if the request was successful, and an error otherwise.

window.ethereum.request
interface AddEthereumChainParameter {
  chainId: string; // A 0x-prefixed hexadecimal string
  chainName: string;
  nativeCurrency: {
    name: string;
    symbol: string; // 2-6 characters long
    decimals: 18;
  };
  rpcUrls: string[];
  blockExplorerUrls?: string[];
  iconUrls?: string[]; // Currently ignored.
}

Switch Ethereum Chain

result— if the request was successful, and an error otherwise.

try{
        await window.await ethereum.request({
        method: 'wallet_switchEthereumChain',
            params: [{ chainId: '0xf00' }],
        });
} catch (switchError) {
  // This error code indicates that the chain has not been added to Coin98.
  if (switchError.code === 4902) {
    try {
      await ethereum.request({
        method: 'wallet_addEthereumChain',
        params: [
          {
            chainId: '0xf00',
            chainName: '...',
            rpcUrls: ['https://...'] /* ... */,
          },
        ],
      });
    } catch (addError) {
      // handle "add" error
    }
  }
  // handle other "switch" errors
}

Watch Asset

window.ethereum.request({
method: 'wallet_watchAsset',
    params: {
      type: 'ERC20',
      options: {
        address: '0xb60e8dd61c5d32be8058bb8eb970870f07233155',
        symbol: 'FOO',
        decimals: 18,
        image: 'https://foo.io/token-image.svg',
      },
    },
  })
  .then((success) => {
    if (success) {
      console.log('FOO successfully added to wallet!');
    } else {
      throw new Error('Something went wrong.');
    }
  })
  .catch(console.error);

RPC Request

return Promise<Ethereum RPC> Currently only supports HTTP(s) methods.

window.ethereum.request({method: '<Your Method>', params: [args1,....]})

Experimental MultiChain Connection

You can connect and receive multiChain addresses at the same time by using the following methods

async function connect(){
        if(!window.coin98){
                throw new Error('Coin98 Extension is required');
        }
        const accounts = await window.coin98.connect([<chain 1>, <chain 2>, ...]);
        
        if(!accounts){
                throw new Error('Connect Error | User cancel your request');
        }
        
        // Do anything with accounts:[<address of chain 1>, <address of chain 2>]
}

When your connection is successful, the chain's properties will be available for your next request. For example:

// For example | connect ether & solana
async function connect(){
        const conn = await window.coin98.connect(['ether','solana']);
        // If user accept the request, those properties will available at window.coin98;
        //  window.solana || Checkout document of solana connection guide for more methods;
        //        window.ether || Checkout document of ether connection guide for more methods;
}

Chain's Name can be found at

const { CHAIN_NAME } = window.coin98

Subscription

Support subscribe using JSON-RPC notifications. This allows clients to wait for events instead of polling for them. All results will be released at a data event.

Methods

// For Subscribe
window.ethereum.request({
        method: 'eth_subscribe',
        params: ['<type>','<options>']
})
// Its result will be subscription ID which can be used for unsubscribe
// For Unsubscribe
window.ethereum.request({
        method: 'eth_unsubscribe',
        params: ['<Subscription ID>']
});

Example

// Subscribe for event
const subscriptionID = window.ethereum.request({
    method: 'eth_subscribe',
        params: ["logs", 
        {
                address: "0x8320fe7702b96808f7bbc0d4a888ed1468216cfd", 
                topics: ["0xd78a0cb8bb633d06981248b816e7bd33c2a35a6089241d099fa519e361cab902"]}]
})
// You can listen for incoming notifications by
window.ethereum.on("data", data => {
        // Do the rest of your work with data
})

To Handle events

List of events

Currently Coin98 only supports some action events from wallet extension.

window.ethereum.on('event_name', callback);
//Example
window.ethereum.on('close', () => window.location.reload());
window.ethereum.on('accountsChanged', () => window.location.reload());

Wrap

Amazing! You're now equipped with the latest info on integrating Coin98 Wallet SDK with Mantle Network!

🛑 Have doubts and need support? Join our Discord Server and ping the Dev Rel team for support or interact with other blockchain developers and fellow builders!

💪🏼 Not tired and want to keep building? Head over to https://www.mantle.xyz/blog/developers and check out an amazing list of tutorials to keep building cool dApps on Mantle Network!

Ciao! 👋🏼

Integrating Coin98 Wallet SDK