Skip to main content

​
Introduction

This guide will walk you through the process of creating, testing, and submitting an assertion using pcl. By the end of this tutorial, you’ll understand how to:
  1. Set up your project structure
  2. Test your assertion
  3. Deploy your contract
  4. Authenticate with pcl
  5. Create a project
  6. Store your assertion
  7. Submit your assertion to the Credible Layer
  8. Deploy your assertion
  9. Verify that the assertion is working

​
Prerequisites

Before you begin, make sure you have:

​
1. Project Setup

We’ve created an example project with containing some complete assertion examples that work out of the box and that you can use as a starting point for your own projects. The project can be found here. For a detailed understanding of what an assertion is and how it works, see the Assertion Guide. For testing assertions, see the Testing Assertions guide.
The credible-layer-starter repo has several examples that you can deploy and try out once you’re done with this guide. Specific instructions can be found in the README.
You can clone the example project by running the following command: 
git clone --recurse-submodules https://github.com/phylaxsystems/credible-layer-starter.git
cd credible-layer-starter
Once cloned you have a repository with all required dependencies.

​
2. Running Tests

Use the pcl CLI to run your tests: 
pcl test
This command will compile your assertion and run the tests. You should see output looking like this indicating that the tests have passed: 
Ran 2 tests for assertions/test/OwnableAssertion.t.sol:TestOwnableAssertion
[PASS] test_assertionOwnershipChanged() (gas: 806650)
[PASS] test_assertionOwnershipNotChanged() (gas: 804708)
Suite result: ok. 2 passed; 0 failed; 0 skipped; finished in 648.17ms (1.11s CPU time)

​
3. Deploy Your Contract

You can deploy the Ownable contract using the following command: 
forge script script/DeployOwnable.s.sol --rpc-url <RPC_URL> --sender <DEPLOYER_ADDRESS> --private-key <PRIVATE_KEY> --broadcast
Explanation of the arguments:
  • <RPC_URL>: The RPC URL of the network you’re deploying to
  • <PRIVATE_KEY>: The private key of the account you used to sign in to the dApp
  • <DEPLOYER_ADDRESS>: The address of the account you used to sign in to the dApp
Make sure to note down the address of the deployed contract as you’ll need it to create a project in the next step. It will be the Deployed to: address in the output of the command.

​
4. Authenticating with Credible Layer

Here’s a full video that you can consult to follow along with the process entire process from authentication to activating the assertion:
Before submitting your assertion, you need to authenticate: 
pcl auth login
Make sure to use the same address as you set as the initial owner of the contract in the previous step.
This will provide you with with a URL and an authentication code that you can use to authenticate with the Credible Layer. If authentication fails, ensure:
  • Your wallet has the correct network selected
  • The pcl CLI uses the correct url
  • You have an internet connection
  • The pcl CLI is properly installed

​
5. Create a Project

Once you have deployed your contract, you’ll need to create a project in the dApp if you don’t have one already. Navigate to the browser window opened by the pcl auth login command and create a new project. When asked to link your contract, use the address of the contract you deployed in the previous step. For a more detailed overview of how to use the dApp and manage projects, see the dApp Guide.

​
6. Storing Your Assertion

Next, store your assertion in the Assertion Data Availability layer (Assertion DA): 
pcl store OwnableAssertion
Here OwnableAssertion is the name of the assertion. This command submits your assertion’s bytecode and source code to be stored by the Assertion DA, making it available for verification by the network.

​
7. Submitting Your Assertion

Finally, submit your assertion to the Credible Layer dApp: 
pcl submit
This will prompt you to select the project and assertion(s) you want to submit. Follow the interactive prompts to complete the submission. Alternatively, you can specify the project and assertion directly as per the output of the pcl store command: 
pcl submit -a 'OwnableAssertion' -p <project_name>
Note, that <project_name> is the name of the project you created in the dApp, capitalized in the same way as you did when creating the project.

​
8. Deploying Your Assertion

Last step is to go to the dApp and deploy the assertion. Go back to the url that you opened with the pcl auth login command and navigate to the project that the assertion was added to. You’ll notice that there’s one assertion ready for deployment. Go ahead and proceed to review and deploy it. During the review process, you’ll choose whether to deploy to Staging (for testing) or Production (for active protection).
After deployment, your assertion enters a timelock period. During this period, it is marked for enforcement (production) or marked for staging (staging environment). After the timelock expires, the assertion becomes enforced (production) or staged (staging), actively protecting your contract. See the Glossary for details about timelocks.
For a more detailed overview of how to use the dApp, see the dApp Guide.

​
9. Verify That The Assertion Is Working

Now that your assertion is deployed and enforced (after the timelock period), let’s verify that it’s working as expected. We’ll do this by attempting to change the ownership of the contract, which should trigger our assertion and prevent the change. First, let’s check the current owner of the Ownable contract. Replace ADDRESS_OF_OWNABLE_CONTRACT with the address of your deployed Ownable contract and RPC_URL with your network’s RPC URL: 
cast call <ADDRESS_OF_OWNABLE_CONTRACT> "owner()" --rpc-url <RPC_URL>
This command should return the initial owner address that was set when we deployed the contract. Next, let’s attempt to transfer ownership to a new address. Make sure you replace NEW_OWNER_ADDRESS with an address that is not the initial owner and PRIVATE_KEY_OF_THE_OWNER with the private key of the owner of the contract. This transaction should cause the assertion to revert, which will result in the transaction being dropped: 
cast send <ADDRESS_OF_OWNABLE_CONTRACT> "transferOwnership(address)" <NEW_OWNER_ADDRESS> --rpc-url <RPC_URL> --private-key <PRIVATE_KEY_OF_THE_OWNER>
The transaction should timeout, which means that the assertion reverted and the transaction was dropped: 
Error: transaction was not confirmed within the timeout
To confirm that the ownership hasn’t changed, let’s check the owner again: 
cast call <ADDRESS_OF_OWNABLE_CONTRACT> "owner()" --rpc-url <RPC_URL>
The owner should still be the original address, confirming that our assertion successfully prevented the ownership change.

​
Conclusion

Congratulations! You’ve successfully created, tested, deployed, and verified your first assertion using pcl. You can now go ahead and start implementing assertions in your own projects.

​
Next Steps

  1. Read the Assertions Book: Check out the Assertions Book for more detailed explanations and a collection of assertions for various use cases
  2. Try more complex assertions: We’ve created some more assertions in the credible-layer-starter repo that are ready to be deployed and used with a couple of commands
  3. Integrate with your own projects: Apply assertions to your existing smart contracts
  4. Join the community: Share your assertions and learn from others in the Phylax Telegram
For more detailed information about pcl and its commands, see Using pcl and pcl Reference. For a comprehensive list of terms and concepts used in the Credible Layer, see the Glossary.