Painless end-to-end testing and monitoring for web3 apps

Build robust and secure web3 apps with our suite of products

Install GuardianTest
Try Monitoring For Free

Introducing GuardianTest

Our end-to-end testing framework, an extended version of Playwright, enables you to develop and test your web3 app with confidence. It's open source and completely free to use.

Supercharged e2e testing for the web3 stack

  • Perform tests on any EVM compatible chain
  • Interact with sites using a wallet with easily mocked token balances and allowances
  • Validate target contract addresses from app interactions
  • Perform any other actions or validation Playwright offers

test.describe("OlympusDAO", () => {
  test("Test against a forked block", async ({ page, gui }) => {
    const forkBlock = 17039476;
    await gui.initializeChain(1, forkBlock);

    await page.goto("https://app.olympusdao.finance/#/stake");

    await gui.setEthBalance("100000000000000000000000");

    // More mocking and site interactions

    await page.locator("text=Connect Wallet").first().click();
    await page.locator("text=Metamask").first().click();

    // Finish site interactions
    
    const stakingAddress = "0xb63cac384247597756545b500253ff8e607a8020";
    await gui.validateContractInteraction("text=Stake", stakingAddress);
  });
});

Get Started In Minutes

  • Easy installation
  • Minimal configuration and no dependency hell
  • All-in-one framework that's simple to use right out of the box

The power of Playwright, extended to web3

  • No flaky tests - the combination of auto-wait, web-first assertions, and tracing means your tests are resilient
  • No limits - Playwright supports testing scenarios with multiple tabs, origins, and users, and its input pipeline mimics real user behavior
  • Fast execution - Playwright ensures full test isolation with zero overhead by creating a browser context for each test

test.describe("Bond Protocol", () => {
  test("Test with token balance", async ({ page, gui }) => {
    const wethAddress = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";
    const fixedTermTeller = "0x007f7735baf391e207e3aa380bb53c4bd9a5fed6";

    await gui.setBalance(wethAddress, "1000000000000000000000000");
    await gui.setAllowance(wethAddress, fixedTermTeller, "1000000000000000000000000");

    await page.goto("https://app.bondprotocol.finance/#/markets");
  });
});
Install GuardianTest
Documentation

Frontend Security Monitoring

Real-time vulnerability detection for your dapp’s frontend

Try for Free
Monitoring service
Frontend Attacks Have Stolen Millions From Users - Fortify and Protect Your dApp and Users

BETA

Convert Natural Language Into Tests Using Storycheck

Enable anyone to create end-to-end tests using simple text descriptions. Increase test coverage at a fraction of the cost and effort.

  • Easier

    Write a user story in markdown and automatically convert it into test code.

  • Faster

    Create end-to-end tests 10x faster, easier, and cheaper.

  • Usable by Anyone

    Empower non-technical stakeholders to help with test creation.

  • Less Brittle Tests

    Stop relying on the HTML DOM tree, instead, use natural language to find elements in your UI.
Learn More
Watch Demo

What Developers Are Saying

Profile picture of Eddie Ye

Eddie Ye ― Integrations Engineer at Connext

We're big fans for how GuardianUI is addressing an underserved risk vector and problem area in our industry: frontend security.
Profile picture of Spaceturtleship

SpaceTurtleShip ― Lead Frontend Developer at Bond Protocol

Frontend testing in general is well-developed, but crypto-specific tools have been sorely lacking.GuardianUI are building a great platform, helping us to provide our users with a safer and more robust experience.
Profile photo of Appleseed

Appleseed ― Lead Frontend Developer at OlympusDAO

Testing and monitoring live applications is pretty common in web2, but there isn't a great solution in web3. GuardianUI is tackling this problem.
Pricing

Simple and Predictable Pricing

GuardianTest

Free

E2E testing framework for web3 apps

  • Full access to all framework features
  • Customise usage for your workfows
  • Comprehensive documentation
  • Regular updates
  • Community support
  • Apache 2.0 License
Install GuardianTest
Frontend Security Monitoring

$0.03 per check

Real-time vulnerability detection

  • Unlimited browser checks
  • Unlimited alerts
  • Unlimited users
  • Log storage (7 days)
  • Basic support
  • Usage-based billing
Try for Free
Custom

Let's chat

For organizations with custom needs

  • Our experts can write and manage your tests
  • Custom onboarding
  • Premium support
  • Web infrastructure audits
  • And more!
Contact Us
FAQs

Commonly asked questions about the ecosystem of GuardianUI products

General

GuardianUI is an end-to-end testing and monitoring platform for web3 apps. We offer a suite of products designed to improve frontend security and UX in the crypto space including our open source testing framework - GuardianTest.

Our products support dApps of all types building on EVM compatible chains (e.g. Ethereum, Arbitrum, Optimism, Polygon).

Absolutely. We have solutions that cater to projects no matter the size of their team, budget, traffic, volume, etc. Our open source end-to-end testing framework, GuardianTest, is completely free to use. Organizations that want to monitor their live frontends to make sure their apps are performing correctly can utilize our frontend security monitoring product. Projects can also work with us directly to create more custom programs (e.g. we write your tests, volume discounts for monitoring, etc.).

GuardianUI’s products can help you improve the reliability, robustness, and safety of your web3 applications in multiple ways.
  • GuardianTest is an open source end-to-end testing framework that extends the popular Playwright framework so developers can easily perform tests on any EVM compatible chain, pin tests to any block, interact with a site with a wallet, mock ERC20 balances and allowances, validate target contract addresses from app interactions, and perform any other action or validation Playwright enables.
  • Our continuous frontend security solution lets you continuously run your tests written with the GuardianTest framework against your live app.
  • Storycheck enables you to write end-to-end tests using natural language and verify your app is creating the expected smart contract interactions.

We accept all major credit cards. We can also accept crypto.

GuardianTest

GuardianTest is an open source end-to-end testing framework. It extends Playwright to suit the unique demands of crypto organizations and developers.

Yes. GuardianTest is completely free to use (Apache 2.0 license).

Frontend Security Monitoring

GuardianUI continuously monitors for anything that might cause your live frontend to create the wrong smart contract interactions and rug your users. This includes middleware and supply chain attacks that could compromise your frontend and alter its contract interactions, such as DNS attacks, Cloudflare attacks, javascript injections, malicious package injections, package name squatting, malicious minifiers, compromised linters, and more. It also includes making sure bad code doesn’t get pushed to production.

There are countless examples of FE attacks resulting in users getting rugged that our continuous monitoring solution would detect. Here are a few:
  • BadgerDAO (Cloudflare) - $120M stolen from users
  • Sushiswap’s Miso (Supply Chain) - $3M stolen from users
  • Curve Finance (DNS) - $600k stolen from users
  • Ribbon Finance (DNS) - $500k stolen from users
  • Kyber Network (Google Tag Manager) - $265k stolen from users
  • Celer Protocol (DNS) - $250k stolen from users
  • Black Wallet (DNS) - $400k stolen from users
  • PancakeSwap (DNS) - prompted users to enter seed phrase
  • Cream Finance (DNS) - prompted users to enter seed phrase

While we offer a free trial to all new users, our continuous monitoring solution is a paid product.

By signing up for the Frontend Security Monitoring plan, you get unlimited access to all features. You’ll pay $0.03 per browser check and be billed monthly for browser checks performed in the previous month. You can cancel at any time.

Browser checks are implemented as Node.js scripts utilizing the GuardianTest framework. Each check involves the execution of real interactions in a Chrome browser, including clicks, form submissions, and result validation. This approach, often referred to as "synthetic monitoring," enables us to track and bill based on the number of executed scripts.

You can run your checks as frequently as every 5 minutes.

Absolutely! Please contact us using this form so we can discuss your specific needs.

Storycheck

Storycheck creates end-to-end tests by converting user stories into test code using natural language.

No, you don't need to use a programming language to write meaningful tests. You can use natural language to describe web3 UI flows. Here is an example. Developers can write advanced test cases using GuardianTest.