synpress-api.md

description	coverY
List of all Cypress/Playwright APIs used in Synpress	0

🗝 Synpress API

Initialize Playwright

{% tabs %} {% tab title="Cypress" %}

cy.initPlaywright()

Connect Playwright with Cypress instance.

function initPlaywright(): Chainable<boolean>;

Example

cy.initPlaywright();

{% endtab %}

{% tab title="Playwright" %}

init

Initialize Playwright instance.

function init(playwrightInstance: BrowserType<{}>): Promise<boolean>;

Example

import * as playwright from "@synthetixio/synpress/commands/playwright";

const connected = await playwright.init();

{% endtab %} {% endtabs %}

assignWindows

Assign currently open tabs with Playwright.

{% tabs %} {% tab title="Cypress" %}

Definition

function assignWindows(): Chainable<boolean>;

Example

cy.assignWindows().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

Definition

function assignWindows(): Promise<boolean>;

Example

import * as playwright from "@synthetixio/synpress/commands/playwright";

const connected = await playwright.init();
const assigned = await playwright.assignWindows();

{% endtab %} {% endtabs %}

assignActiveTabName

Assigns currently active tab.

{% tabs %} {% tab title="Cypress" %}

Definition

function assignActiveTabName(tabName: string): Chainable<boolean>;

Example

cy.assignActiveTabName("my_tab");

{% endtab %}

{% tab title="Playwright" %}

Definition

function assignActiveTabName(tabName: string): Promise<boolean>;

Example

import * as playwright from "@synthetixio/synpress/commands/playwright";

await playwright.assignActiveTabName("my_tab");

{% endtab %} {% endtabs %}

isMetamaskWindowActive

Checks if the currently active window is Metamask.

{% tabs %} {% tab title="First Tab" %}

Definition

function isMetamaskWindowActive(): Chainable<boolean>;

Example

cy.isMetamaskWindowActive().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

Definition

function isMetamaskWindowActive(): Promise<boolean>;

Example

import * as playwright from "@synthetixio/synpress/commands/playwright";

const isActive = await playwright.isMetamaskWindowActive();

{% endtab %} {% endtabs %}

isCypressWindowActive

Checks if the currently active window is Cypress.

{% tabs %} {% tab title="First Tab" %}

Definition

function isCypressWindowActive(): Chainable<boolean>;

Example

cy.isCypressWindowActive();

{% endtab %}

{% tab title="Playwright" %}

Definition

function isCypressWindowActive(): Promise<boolean>;

Example

import * as playwright from "@synthetixio/synpress/commands/playwright";

const isActive = await playwright.isCypressWindowActive();

{% endtab %} {% endtabs %}

switchToCypressWindow

Will focus on the Cypress window (tab) (the dApp)

{% tabs %} {% tab title="Cypress" %}

Definition

function switchToCypressWindow(): Chainable<boolean>;

Example

cy.switchToCypressWindow().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

Definition

function switchToCypressWindow(): Promise<boolean>;

Example

import * as playwright from "@synthetixio/synpress/commands/playwright";

const switched = await playwright.switchToCypressWindow();

{% endtab %} {% endtabs %}

switchToMetamaskWindow

Will focus on the Metamask window (tab)

{% tabs %} {% tab title="Cypress" %}

Definition

function switchToMetamaskWindow(): Chainable<boolean>;

Example

cy.switchToMetamaskWindow().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

Definition

function switchToMetamaskWindow(): Promise<boolean>;

Example

import * as playwright from "@synthetixio/synpress/commands/playwright";

const switched = await playwright.switchToMetamaskWindow();

{% endtab %} {% endtabs %}

switchToMetamaskNotification

Will focus on the Metamask popup and will bring it to the top.

{% tabs %} {% tab title="Cypress" %}

Definition

function switchToMetamaskNotification(): Chainable<boolean>;

Example

cy.switchToMetamaskNotification().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

Definition

function switchToMetamaskNotification(): Promise<boolean>;

Example

import * as playwright from "@synthetixio/synpress/commands/playwright";

const switched = await playwright.switchToMetamaskNotification();

{% endtab %} {% endtabs %}

getCurrentNetwork

Get current network info from Metamask

{% tabs %} {% tab title="Cypress" %}

Definition

function getCurrentNetwork(): {
  networkName: string;
  networkDisplayName: string;
  networkId: number;
  isTestnet: boolean;
};

Example

cy.getCurrentNetwork().then((network) => {
  expect(network.networkName).to.be.equal("sepolia");
  expect(network.networkId).to.be.equal(11155111);
  expect(network.isTestnet).to.be.true;
});

{% endtab %}

{% tab title="Playwright" %}

Definition

function getCurrentNetwork(): {
  networkName: string;
  networkDisplayName: string;
  networkId: number;
  isTestnet: boolean;
};

Example

import { getCurrentNetwork } from "@synthetixio/synpress/helpers";

const network = getCurrentNetwork();
expect(network.networkName).to.be.equal("sepolia");
expect(network.networkId).to.be.equal(11155111);
expect(network.isTestnet).to.be.true;

{% endtab %} {% endtabs %}

Add Metamask Network

Add network in MetaMask (and switch to the newly added network).

{% tabs %} {% tab title="Cypress" %}

addMetamaskNetwork

function addMetamaskNetwork(network: {
  networkName: string;
  rpcUrl: string;
  chainId: string;
  symbol?: string;
  blockExplorer?: string;
  isTestnet: boolean;
}): Chainable<boolean>;

Example

cy.addMetamaskNetwork({
  networkName: "Optimism Network",
  rpcUrl: "https://mainnet.optimism.io",
  chainId: "10",
  symbol: "OETH",
  blockExplorer: "https://optimistic.etherscan.io",
  isTestnet: false,
});

{% endtab %}

{% tab title="Playwright" %}

addNetwork

function addNetwork(network: {
  networkName: string;
  rpcUrl: string;
  chainId: string;
  symbol?: string;
  blockExplorer?: string;
  isTestnet: boolean;
}): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.addNetwork({
  networkName: "Optimism Network",
  rpcUrl: "https://mainnet.optimism.io",
  chainId: "10",
  symbol: "OETH",
  blockExplorer: "https://optimistic.etherscan.io",
  isTestnet: false,
});

{% endtab %} {% endtabs %}

Preview

Add network screen in MetaMask

Change Metamask Network

Change network in MetaMask.

Predefined networks: mainnet, goerli, sepolia , localhost

If no network is provided, it will default to using the NETWORK_NAME environment variable. If not, it will default to goerli the network.

{% tabs %} {% tab title="Cypress" %}

changeMetamaskNetwork

function changeMetamaskNetwork(networkName?: string): Chainable<boolean>;

Example

// Pass one of the predefined networks (mainnet, goerli, sepolia , localhost)
cy.changeMetamaskNetwork("mainnet");
// Pass the network name (from the Metamask networks dropdown menu)
cy.changeMetamaskNetwork("optimism network");
cy.changeMetamaskNetwork("sepolia");

{% endtab %}

{% tab title="Playwright" %}

changeNetwork

function changeNetwork(networkName?: string): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.changeNetwork("mainnet");
// Switch to the network defined in `process.env.NETWORK_NAME` or default to `goerli`
await metamask.changeNetwork();

{% endtab %} {% endtabs %}

Preview

Switch network from Metamask

Import Metamask Account

Import a new account in Metamask using a private key.

{% tabs %} {% tab title="Cypress" %}

importMetamaskAccount

function importMetamaskAccount(pk: string): Chainable<boolean>;

Example

cy.importMetamaskAccount(
  "0x2a871d0798f97d79848a013d4936a73bf4cc922c825d33c1cf7073dff6d409c6"
);
cy.importMetamaskAccount(Cypress.env("E2E_PRIVATE_KEY"));

{% endtab %}

{% tab title="Playwright" %}

importAccount

function importAccount(pk: string): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.importAccount(
  "0x2a871d0798f97d79848a013d4936a73bf4cc922c825d33c1cf7073dff6d409c6"
);
await metamask.importAccount(process.env.E2E_PRIVATE_KEY);

{% endtab %} {% endtabs %}

Preview

Import account using private key in Metamask

Create Metamask Account

{% tabs %} {% tab title="Cypress" %}

createMetamaskAccount

function createMetamaskAccount(accountName?: string): Chainable<boolean>;

Example

// Create a new account with the default name
cy.createMetamaskAccount();
cy.createMetamaskAccount("custom-wallet");

{% endtab %}

{% tab title="Playwright" %}

createAccount

function createAccount(accountName?: string): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.createAccount("my_account");
await metamask.createAccount();

{% endtab %} {% endtabs %}

Preview

Create new account in Metamask

Switch Metamask Account

{% tabs %} {% tab title="Cypress" %}

switchMetamaskAccount

function switchMetamaskAccount(
  accountNameOrAccountNumber: string | number
): Chainable<boolean>;

Example

// Switch using the account number
cy.switchMetamaskAccount(2);
// Switch using the account name
cy.switchMetamaskAccount("account 1");

{% endtab %}

{% tab title="Playwright" %}

switchAccount

function switchAccount(
  accountNameOrAccountNumber: string | number
): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.switchAccount("my_account");
await metamask.switchAccount(2);

{% endtab %} {% endtabs %}

Preview

Switch account from Metamask

Get Metamask Wallet Address

Get the current wallet address of Metamask wallet.

{% tabs %} {% tab title="Cypress" %}

getMetamaskWalletAddress

function getMetamaskWalletAddress(): Chainable<string>;

Example

cy.getMetamaskWalletAddress().then((address) => {
  expect(address).to.be.equal("0x70997970C51812dc3A010C7d01b50e0d17dc79C8");
});

{% endtab %}

{% tab title="Playwright" %}

getWalletAddress

function getWalletAddress(): Promise<string>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

const walletAddress = await metamask.getWalletAddress();
expect(walletAddress).to.be.equal("0x70997970C51812dc3A010C7d01b50e0d17dc79C8");

{% endtab %} {% endtabs %}

Disconnect Metamask Wallet From dApp

Disconnects Metamask wallet from last connected dApp.

{% tabs %} {% tab title="Cypress" %}

disconnectMetamaskWalletFromDapp

function disconnectMetamaskWalletFromDapp(): Chainable<boolean>;

Example

cy.disconnectMetamaskWalletFromDapp().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

disconnectWalletFromDapp

function disconnectWalletFromDapp(): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.disconnectWalletFromDapp();

{% endtab %} {% endtabs %}

Preview

Disconnect dApp from Metamask

Disconnect Metamask Wallet From All dApps

Disconnects Metamask wallet from all connected dApps.

{% tabs %} {% tab title="Cypress" %}

disconnectMetamaskWalletFromAllDapps

function disconnectMetamaskWalletFromAllDapps(): Chainable<boolean>;

Example

cy.disconnectMetamaskWalletFromAllDapps().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

disconnectWalletFromAllDapps

function disconnectWalletFromAllDapps(): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.disconnectWalletFromAllDapps();tab

{% endtab %} {% endtabs %}

Preview

Disconnect dApps from Metamask

Confirm Metamask Signature Request

Confirm Metamask's permission to sign a "regular" message.

{% tabs %} {% tab title="Cypress" %}

confirmMetamaskSignatureRequest

function confirmMetamaskSignatureRequest(): Chainable<boolean>;

Example

cy.confirmMetamaskSignatureRequest().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

confirmSignatureRequest

function confirmSignatureRequest(): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.confirmSignatureRequest();

{% endtab %} {% endtabs %}

Preview

Confirm signature request in Metamask

Confirm Metamask Data Signature Request

Confirm Metamask's permission to sign a Data "type 4" message.

{% tabs %} {% tab title="Cypress" %}

confirmMetamaskDataSignatureRequest

function confirmMetamaskDataSignatureRequest(): Chainable<boolean>;

Example

cy.confirmMetamaskDataSignatureRequest().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

confirmDataSignatureRequest

function confirmDataSignatureRequest(): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.confirmDataSignatureRequest();

{% endtab %} {% endtabs %}

Preview

Confirm data (type 4) signing request in Metamask

Reject Metamask Signature Request

Reject Metamask permission to sign a "regular" message.

{% tabs %} {% tab title="Cypress" %}

rejectMetamaskSignatureRequest

function rejectMetamaskSignatureRequest(): Chainable<boolean>;

Example

cy.rejectMetamaskSignatureRequest().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

rejectSignatureRequest

function rejectSignatureRequest(): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.rejectSignatureRequest();

{% endtab %} {% endtabs %}

Preview

Reject signature request from Metamask

Reject Metamask Data Signature Request

Reject Metamask's permission to sign a Data "Type 4" message.

{% tabs %} {% tab title="Cypress" %}

rejectMetamaskDataSignatureRequest

function rejectMetamaskDataSignatureRequest(): Chainable<boolean>;

Example

cy.rejectMetamaskDataSignatureRequest().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

rejectDataSignatureRequest

function rejectDataSignatureRequest(): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.rejectDataSignatureRequest();

{% endtab %} {% endtabs %}

Preview

Reject data (type 4) signing request in Metamask

Confirm Metamask Encryption Public Key Request

Confirm Metamask's request for the public encryption key.

{% tabs %} {% tab title="Cypress" %}

confirmMetamaskEncryptionPublicKeyRequest

function confirmMetamaskEncryptionPublicKeyRequest(): Chainable<boolean>;

Example

cy.confirmMetamaskEncryptionPublicKeyRequest().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

confirmEncryptionPublicKeyRequest

function confirmEncryptionPublicKeyRequest(): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.confirmEncryptionPublicKeyRequest();s

{% endtab %} {% endtabs %}

Preview

Request encryption public key in Metamask

Reject Metamask Encryption Public Key Request

Reject Metamask's request for the public encryption key.

{% tabs %} {% tab title="Cypress" %}

rejectMetamaskEncryptionPublicKeyRequest

function rejectMetamaskEncryptionPublicKeyRequest(): Chainable<boolean>;

Example

cy.rejectMetamaskEncryptionPublicKeyRequest().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

rejectEncryptionPublicKeyRequest

function rejectEncryptionPublicKeyRequest(): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.rejectEncryptionPublicKeyRequest();

{% endtab %} {% endtabs %}

Preview

Confirm Metamask Decryption Request

Confirm Metamask's request to decrypt a message with the private key.

{% tabs %} {% tab title="Cypress" %}

confirmMetamaskDecryptionRequest

function confirmMetamaskDecryptionRequest(): Chainable<boolean>;

Example

cy.confirmMetamaskDecryptionRequest().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

confirmDecryptionRequest

function confirmDecryptionRequest(): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.confirmDecryptionRequest();ta

{% endtab %} {% endtabs %}

Preview

Accept decryption request in Metamask

Reject Metamask Decryption Request

Reject Metamask's request to decrypt the message with the private key.

{% tabs %} {% tab title="Cypress" %}

rejectMetamaskDecryptionRequest

function rejectMetamaskDecryptionRequest(): Chainable<boolean>;

Example

cy.rejectMetamaskDecryptionRequest().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

rejectDecryptionRequest

function rejectDecryptionRequest(): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.rejectDecryptionRequest();abs

{% endtab %} {% endtabs %}

Preview

Reject decryption request in Metamask

Import Metamask Token

Add custom token to Metamask.

{% tabs %} {% tab title="Cypress" %}

importMetamaskToken

function importMetamaskToken(
  tokenConfig: { address: string; symbol: string } | string
): Chainable<{
  tokenContractAddress: string;
  tokensymbol: string;
  tokenDecimals: string;
  imported: boolean;
}>;

Example

it(`importMetamaskToken should import token to metamask`, () => {
  const USDCContractAddressOnSepolia =
    "0xda9d4f9b69ac6C22e444eD9aF0CfC043b7a7f53f";
  cy.importMetamaskToken(USDCContractAddressOnSepolia).then((tokenData) => {
    expect(tokenData.tokenContractAddress).to.be.equal(
      USDCContractAddressOnSepolia
    );
    expect(tokenData.tokenSymbol).to.be.equal("USDC");
    expect(tokenData.tokenDecimals).to.be.equal("6");
    expect(tokenData.imported).to.be.true;
  });
});

{% endtab %}

{% tab title="Playwright" %}

importToken

function importToken(
  tokenConfig: { address: string; symbol: string } | string
): Promise<{
  tokenContractAddress: string;
  tokensymbol: string;
  tokenDecimals: string;
  imported: boolean;
}>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

test("import token", async ({ page }) => {
  await page.click("#import-token");
  const USDCContractAddressOnSepolia =
    "0xda9d4f9b69ac6C22e444eD9aF0CfC043b7a7f53f";
  const tokenData = await metamask.importToken(USDCContractAddressOnSepolia);
  await expect(tokenData.tokenContractAddress).to.be.equal(
    USDCContractAddressOnSepolia
  );
  await expect(tokenData.tokenSymbol).to.be.equal("USDC");
  await expect(tokenData.tokenDecimals).to.be.equal("6");
  await expect(tokenData.imported).to.be.true;
});

{% endtab %} {% endtabs %}

Preview

Import token in Metamask

Confirm Metamask To Add Token

Confirm Metamask's request to add a token.

{% tabs %} {% tab title="Cypress" %}

confirmMetamaskAddToken

function confirmMetamaskAddToken(): Chainable<boolean>;

Example

cy.confirmMetamaskAddToken().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

confirmAddToken

function confirmAddToken(): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.confirmAddToken();

{% endtab %} {% endtabs %}

Preview

Add tokens request to Metamask

Reject Metamask Add Token Request

Reject Metamask's request to add a token.

{% tabs %} {% tab title="Cypress" %}

rejectMetamaskAddToken

function rejectMetamaskAddToken(): Chainable<boolean>;

Example

cy.rejectMetamaskAddToken().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

rejectAddToken

function rejectAddToken(): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.rejectAddToken();

{% endtab %} {% endtabs %}

Preview

Reject add token request in Metamask

Confirm Metamask Permission To Spend

Confirm Metamask's permission to spend assets.

{% tabs %} {% tab title="Cypress" %}

confirmMetamaskPermissionToSpend

function confirmMetamaskPermissionToSpend(
  spendLimit?: string
): Chainable<boolean>;

Example

cy.confirmMetamaskPermissionToSpend().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

confirmPermissionToSpend

function confirmPermissionToSpend(): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.confirmPermissionToSpend();

{% endtab %} {% endtabs %}

Preview

Approve permission to spend tokens

Reject Metamask Permission To Spend

Reject Metamask's permission to spend assets.

{% tabs %} {% tab title="Cypress" %}

rejectMetamaskPermissionToSpend

function rejectMetamaskPermissionToSpend(): Chainable<boolean>;

Example

cy.rejectMetamaskPermissionToSpend().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

rejectPermissionToSpend

function rejectPermissionToSpend(): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.rejectPermissionToSpend();

{% endtab %} {% endtabs %}

Preview

Reject permission to spend tokens in MetaMask

Accept Metamask Access

Accept Metamask access request.

{% tabs %} {% tab title="Cypress" %}

acceptMetamaskAccess

function acceptMetamaskAccess(options?: {
  allAccounts?: boolean; // Will select all the accounts.
  confirmSignatureRequest?: boolean; // Will accept "regular" signing request after connection. 
  confirmDataSignatureRequest?: boolean; // Will accept "data" signing request after connection. 
}): Chainable<boolean>;

Example

// Use default Metamask options (will click next with the default selected account)
cy.acceptMetamaskAccess();
// Will accept "regular" signing requests after connection.
cy.acceptMetamaskAccess({ confirmSignatureRequest: true });
// Will accept "data" signing request after connection.
cy.acceptMetamaskAccess({ confirmDataSignatureRequest: true });
// Accept MetaMask connection to all accounts
cy.acceptMetamaskAccess({ allAccounts: true });

{% endtab %}

{% tab title="Playwright" %}

acceptAccess

function acceptAccess(options?: {
  allAccounts?: boolean; // Will select all the accounts.
  confirmSignatureRequest?: boolean; // Will accept "regular" signing request after connection.
  confirmDataSignatureRequest?: boolean; // Will accept "data" signing request after connection.
}): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

// Will accept "regular" signing requests after connection.
await playwright.acceptAccess({ confirmSignatureRequest: true });
// Will accept "data" signing request after connection.
await playwright.acceptAccess({ confirmDataSignatureRequest: true });
// Accept Metamask connection to all accounts
await playwright.acceptAccess({ allAccounts: true });

{% endtab %} {% endtabs %}

Preview

Confirm Metamask Transaction

Confirm Metamask transaction (auto-detects eip-1559 and legacy transactions).

{% tabs %} {% tab title="Cypress" %}

confirmMetamaskTransaction

function confirmMetamaskTransaction(
  gasConfig?:
    | {
        gasLimit?: number;
        gasPrice?: number;
        baseFee?: number;
        priorityFee?: number;
      }
    | "low"
    | "market"
    | "aggressive"
    | "site"
): Chainable<{
  recipientPublicAddress: string;
  networkName: string;
  customNonce: string;
  confirmed: boolean;
}>;

Example

it(`confirmMetamaskTransaction should confirm legacy transaction using default settings`, () => {
  cy.get("#sendButton").click();
  cy.confirmMetamaskTransaction().then((txData) => {
    expect(txData.recipientPublicAddress).to.be.not.empty;
    expect(txData.networkName).to.be.not.empty;
    expect(txData.customNonce).to.be.not.empty;
    expect(txData.confirmed).to.be.true;
  });
});

cy.confirmMetamaskTransaction({
  gasLimit: 210000,
  gasPrice: 100,
}).then((txData) => {
  expect(txData.confirmed).to.be.true;
});
cy.confirmMetamaskTransaction("low");
cy.confirmMetamaskTransaction("market");
cy.confirmMetamaskTransaction("aggressive");
cy.confirmMetamaskTransaction("site");

{% endtab %}

{% tab title="Playwright" %}

confirmTransaction

function confirmTransaction(
  gasConfig?:
    | {
        gasLimit?: number;
        gasPrice?: number;
        baseFee?: number;
        priorityFee?: number;
      }
    | "low"
    | "market"
    | "aggressive"
    | "site"
): Promise<{
  recipientPublicAddress: string;
  networkName: string;
  customNonce: string;
  confirmed: boolean;
}>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

const txData = await metamask.confirmTransaction({
  gasLimit: 210000,
  gasPrice: 100,
});
await expect(txData.confirmed).to.be.true;
await metamask.confirmMetamaskTransaction("low");
await metamask.confirmMetamaskTransaction("market");
await metamask.confirmMetamaskTransaction("aggressive");
await metamask.confirmMetamaskTransaction("site");ta

{% endtab %} {% endtabs %}

Preview

Confirm Metamask transaction

Reject Metamask Transaction

{% tabs %} {% tab title="Cypress" %}

rejectMetamaskTransaction

function rejectMetamaskTransaction(): Chainable<boolean>;

Example

cy.rejectMetamaskTransaction().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

rejectTransaction

function rejectTransaction(): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.rejectTransaction();bs

{% endtab %} {% endtabs %}

Preview

Reject Metamask transaction

Allow Metamask To Add Network

Allow the dApp to add a new network in Metamask.

{% tabs %} {% tab title="Cypress" %}

allowMetamaskToAddNetwork

function allowMetamaskToAddNetwork(waitForEvent?: string): Chainable<boolean>;

Example

cy.allowMetamaskToAddNetwork("close").should("be.true");
cy.allowMetamaskToAddNetwork().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

allowToAddNetwork

function allowToAddNetwork(waitForEvent?: string): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.allowToAddNetwork();

{% endtab %} {% endtabs %}

Preview

Allow dApp to add a network in Metamask

Reject Metamask To Add Network

Reject dApp to add a new network in Metamask.

{% tabs %} {% tab title="Cypress" %}

rejectMetamaskToAddNetwork

function rejectMetamaskToAddNetwork(): Chainable<boolean>;

Example

cy.rejectMetamaskToAddNetwork().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

rejectToAddNetwork

function rejectToAddNetwork(): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.rejectToAddNetwork();

{% endtab %} {% endtabs %}

Preview

Reject dApp to add a network in Metamask

Allow Metamask to switch to another network

Allow the dApp to switch the network in Metamask.

{% tabs %} {% tab title="Cypress" %}

allowMetamaskToSwitchNetwork

function allowMetamaskToSwitchNetwork(): Chainable<boolean>;

Example

cy.allowMetamaskToSwitchNetwork().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

allowToSwitchNetwork

function allowToSwitchNetwork(): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.allowToSwitchNetwork();

{% endtab %} {% endtabs %}

Preview

Allow the dApp to switch the network in Metamask

Reject Metamask To Switch Network

Reject the dApp to switch the network in Metamask.

{% tabs %} {% tab title="Cypress" %}

rejectMetamaskToSwitchNetwork

function rejectMetamaskToSwitchNetwork(): Chainable<boolean>;

Example

cy.rejectMetamaskToSwitchNetwork().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

rejectToSwitchNetwork

function rejectToSwitchNetwork(): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.rejectToSwitchNetwork();bs

{% endtab %} {% endtabs %}

Preview

Allow Metamask To Add and Switch Network

Allow the dApp to add a new network in Metamask and switch to it.

{% tabs %} {% tab title="Cypress" %}

allowMetamaskToAddAndSwitchNetwork

function allowMetamaskToAddAndSwitchNetwork(): Chainable<boolean>;

Example

cy.allowMetamaskToAddAndSwitchNetwork().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

allowToAddAndSwitchNetwork

function allowToAddAndSwitchNetwork(): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.allowToAddAndSwitchNetwork();

{% endtab %} {% endtabs %}

Unlock Metamask

{% tabs %} {% tab title="Cypress" %}

unlockMetamask

function unlockMetamask(password: string): Chainable<boolean>;

Example

cy.unlockMetamask("my_password");

{% endtab %}

{% tab title="Playwright" %}

unlock

function unlock(password: string): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.unlock("my_password");

{% endtab %} {% endtabs %}

Preview

Unlock Metamask

Fetch Metamask Wallet Address

Fetches previous Metamask wallet address.

{% tabs %} {% tab title="Cypress" %}

fetchMetamaskWalletAddress

function fetchMetamaskWalletAddress(): Chainable<string>;

Example

cy.fetchMetamaskWalletAddress().then((address) => cy.log(address));

{% endtab %}

{% tab title="Playwright" %}

fetchWalletAddress

function fetchWalletAddress(): Promise<string>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

const walletAddr = await metamask.fetchWalletAddress();
await expect(walletAddr).to.be.eq("0x...");

{% endtab %} {% endtabs %}

Setup Metamask

Load the MetaMask extension and go through the setup process.

Note: you will need to have the SKIP_METAMASK_SETUP environment variable set to true to be able to use this API. Read this guide to know more.

TODO: adding/switching networks will be updated after merking this PR

{% embed url="Synthetixio/synpress#770" %}

{% tabs %} {% tab title="Cypress" %}

setupMetamask

setupMetamask(
  secretWordsOrPrivateKey?: string,
  network?: string | {
    networkName: string,
    rpcUrl: string,
    chainId: number,
    symbol?: string,
    blockExplorer?: string,
    isTestnet?: string,
  },
  password?: string,
  enableAdvancedSettings?: boolean,
  enableExperimentalSettings?: boolean,
): Chainable<boolean>;

Example

cy.setupMetamask();
cy.setupMetamask("secret, words, ...", "goerli", "metamask_password");
cy.setupMetamask(
  "secret, words, ...",
  {
    networkName: "name",
    rpcUrl: "https://eth.llamarpc.com",
    chainId: 1,
    symbol: "ETH",
    blockExplorer: "https://etherscan.io/",
    isTestnet: true,
  },
  "metamask_password"
);

{% endtab %}

{% tab title="Playwright" %}

initialSetup

function initialSetup(browser: BrowserType<{}> | null, {
  secretWordsOrPrivateKey?: string,
  network?: string | {
    networkName: string,
    rpcUrl: string,
    chainId: number,
    symbol?: string,
    blockExplorer?: string,
    isTestnet?: string,
  },
  password?: string,
  enableAdvancedSettings?: boolean,
  enableExperimentalSettings?: boolean,
}): Promise<boolean>;

Example

import {chromium} from "@playwright/test";
import { initialSetup } from "@synthetixio/synpress/commands/metamask";

// Setup Metamask
await initialSetup(chromium, {
  secretWordsOrPrivateKey:"test test test test test test test test test test test share",
  network: "sepolia",
  password: "Tester@1234",
  enableAdvancedSettings: true,
});

{% endtab %} {% endtabs %}

Etherscan API

Get Transaction Status

Get transaction status from Etherscan API.

etherscanGetTransactionStatus

type TxStatus = {
  status: string;
  message: string;
  result: {
    isError: string;
    errDescription: string;
  };
};

type TxReceipt = {
  blockHash: string;
  blockNumber: string;
  contractAddress: string | null;
  cumulativeGasUsed: string;
  effectiveGasPrice: string;
  from: string;
  to: string;
  gasUsed: string;
  logs: Array<any>;
  logsBloom: string;
  status: string;
  transactionHash: string;
  transactionIndex: string;
  type: string;
};

function etherscanGetTransactionStatus(txid: string): Chainable<{
  txStatus: TxStatus;
  txReceipt: TxReceipt;
}>;

Example

cy.etherscanGetTransactionStatus(
  "0x3af85fa2369b75f327619f5968fd4cc08806ef9481d57ac32774beaf34641be9"
);

etherscanWaitForTxSuccess

Wait until the transaction succeeds using Etherscan API.

function etherscanWaitForTxSuccess(txid: string): Chainable<boolean>;

Activate Advanced Gas Control In Metamask

Activate the ability (in Metamask settings) to specify custom gas prices and limits while doing transactions in Metamask.

{% tabs %} {% tab title="Cypress" %}

activateAdvancedGasControlInMetamask

function activateAdvancedGasControlInMetamask(
  skipSetup?: boolean
): Chainable<boolean>;

Example

cy.activateAdvancedGasControlInMetamask().should('be.true');

{% endtab %}

{% tab title="Playwright" %}

activateAdvancedGasControl

function activateAdvancedGasControl(skipSetup?: boolean): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.activateAdvancedGasControl();

{% endtab %} {% endtabs %}

Activate Show Hex Data In Metamask

Activate the ability (in Metamask settings) to show hex data while doing transactions in Metamask.

{% tabs %} {% tab title="Cypress" %}

activateShowHexDataInMetamask

function activateShowHexDataInMetamask(skipSetup?: boolean): Chainable<boolean>;

Example

cy.activateShowHexDataInMetamask().should("be.true");

{% endtab %}

{% tab title="Second Tab" %}

activateShowHexData

function activateShowHexData(skipSetup?: boolean): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.activateShowHexData();

{% endtab %} {% endtabs %}

Preview

Show hex data option in Metamask settings

Activate Testnet Conversion In Metamask

Activate the ability (in Metamask settings) to show fiat conversions on test networks in Metamask.

{% tabs %} {% tab title="Cypress" %}

activateTestnetConversionInMetamask

function activateTestnetConversionInMetamask(
  skipSetup?: boolean
): Chainable<boolean>;

Example

cy.activateTestnetConversionInMetamask().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

activateTestnetConversion

function activateTestnetConversion(): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.activateTestnetConversion();

{% endtab %} {% endtabs %}

Preview

Show conversion on test networks option in Metamask settings

Activate Show Testnet Networks In Metamask

Activate the ability (in Metamask settings) to show test networks in Metamask.

{% tabs %} {% tab title="Cypress" %}

activateShowTestnetNetworksInMetamask

function activateShowTestnetNetworksInMetamask(
  skipSetup?: boolean
): Chainable<boolean>;

Example

cy.activateShowTestnetNetworksInMetamask().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

activateShowTestnetNetworks

function activateShowTestnetNetworks(skipSetup?: boolean): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.activateShowTestnetNetworks();

{% endtab %} {% endtabs %}

Preview

Show test networks option in Metamask settings

Activate Custom Nonce In Metamask

Activate the ability (in Metamask settings) to specify custom nonce while doing transactions in Metamask.

{% tabs %} {% tab title="Cypress" %}

activateCustomNonceInMetamask

function activateCustomNonceInMetamask(skipSetup?: boolean): Chainable<boolean>;

Example

cy.activateCustomNonceInMetamask().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

activateCustomNonce

function activateCustomNonce(skipSetup?: boolean): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.activateCustomNonce();

{% endtab %} {% endtabs %}

Preview

Customize transaction nonce option in Metamask settings

Activate Dismiss Backup Reminder In Metamask

Activate the ability (in Metamask settings) to dismiss secret recovery phrase reminders in Metamask.

{% tabs %} {% tab title="Cypress" %}

activateDismissBackupReminderInMetamask

function activateDismissBackupReminderInMetamask(
  skipSetup?: boolean
): Chainable<boolean>;

Example

cy.activateDismissBackupReminderInMetamask().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

activateDismissBackupReminder

function activateDismissBackupReminder(): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.activateDismissBackupReminder();

{% endtab %} {% endtabs %}

Preview

Dismiss secret recovery phrase backup reminder option in Metamask settings

Activate eth_sign Requests In Metamask

Activate eth sign requests in Metamask settings.

{% tabs %} {% tab title="Cypress" %}

activateEthSignRequestsInMetamask

function activateEthSignRequestsInMetamask(skipSetup?: boolean): Chainable<boolean>;

Example

cy.activateEthSignRequestsInMetamask().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

activateEthSignRequests

function activateEthSignRequests(skipSetup?: boolean): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.activateEthSignRequests();

{% endtab %} {% endtabs %}

Preview

Toggle eth_sign requests option in Metamask settings

Activate Improved Token Allowance In Metamask

Activate improved token allowance in Metamask settings (experimental).

{% tabs %} {% tab title="Cypress" %}

activateImprovedTokenAllowanceInMetamask

function activateImprovedTokenAllowanceInMetamask(
  skipSetup?: boolean
): Chainable<boolean>;

Example

cy.activateImprovedTokenAllowanceInMetamask().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

activateImprovedTokenAllowance

function activateImprovedTokenAllowance(skipSetup?: boolean): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.activateImprovedTokenAllowance();

{% endtab %} {% endtabs %}

Reset Metamask Account

Reset the Metamask account state in settings.

{% tabs %} {% tab title="Cypress" %}

resetMetamaskAccount

function resetMetamaskAccount(): Chainable<boolean>;

Example

cy.resetMetamaskAccount().should("be.true");

{% endtab %}

{% tab title="Playwright" %}

resetAccount

function resetAccount(): Promise<boolean>;

Example

import * as metamask from "@synthetixio/synpress/commands/metamask";

await metamask.resetAccount();

{% endtab %} {% endtabs %}

Preview

Reset Metamask account