17 |
18 | # Welcome to Ink Kit
19 |
20 | Ink Kit is an onchain-focused SDK that delivers a delightful developer experience with ready-to-use app layout templates, themes, and magical animated components.
21 |
22 | ## Install
23 |
24 | ```bash
25 | npm install @inkonchain/ink-kit
26 | # or
27 | pnpm install @inkonchain/ink-kit
28 | ```
29 |
30 | ## Usage
31 |
32 | ```tsx
33 | // Import styles first at the root of your project (required)
34 | import "@inkonchain/ink-kit/style.css";
35 | ```
36 |
37 | ```tsx
38 | // Import components as needed
39 | import { Button } from "@inkonchain/ink-kit";
40 |
41 | function App() {
42 | return (
43 |
44 |
47 |
48 | );
49 | }
50 | ```
51 |
52 | Note: Ink Kit classes are prefixed with `ink:` and can be customized using CSS variables instead of Tailwind classes. They should be imported first so that your own custom classes are taking precedence.
53 |
54 | ## Key Features
55 |
56 | - 🎨 **Customizable app layout templates**
57 | - ✨ **Magical animated components**
58 | - 🎭 **Vibrant themes**
59 | - ⛓️ **Onchain-focused development**
60 | - 🚀 **Efficient developer experience**
61 | - 📱 **Polished, engaging interfaces**
62 |
63 | ## Theming
64 |
65 | By default, Ink Kit provides a couple of themes already in the stylesheet:
66 |
67 | - Light (`light-theme`)
68 | - Dark (`dark-theme`)
69 | - Contrast (`contrast-theme`)
70 | - Neo (`neo-theme`)
71 | - Morpheus (`morpheus-theme`)
72 |
73 | To specify which theme to use, add the `ink:THEME_ID` to your document root:
74 |
75 | ```tsx
76 |
77 | ...
78 | ```
79 |
80 | If you want to programmatically set this value, you can use the `useInkThemeClass`:
81 |
82 | ```tsx
83 | const theme = getMyCurrentTheme();
84 | useInkThemeClass(theme === "light" ? "ink:neo-theme" : "ink:dark-theme");
85 | ```
86 |
87 | ### Custom Theme
88 |
89 | To create a custom theme, you can override CSS variables:
90 |
91 | ```css
92 | :root {
93 | --ink-button-primary: rgb(10, 55, 10);
94 | ...
95 | }
96 | ```
97 |
98 | To see examples on specific colors that you can override, check the following [theme](https://github.com/inkonchain/ink-kit/tree/main/src/styles/theme) section of the Ink Kit repository.
99 |
100 | ## Resources
101 |
102 | - **Documentation**: Visit our [Storybook](https://ink-kit.inkonchain.com/)
103 | - **Contributing**: Visit our [GitHub repository](https://github.com/inkonchain/ink-kit)
104 |
105 | ## WIP Notice
106 |
107 | This is a work in progress: we are constantly adding new components, improving the developer experience, and fixing bugs.
108 |
--------------------------------------------------------------------------------
/src/pages/build/onchain-clients.mdx:
--------------------------------------------------------------------------------
1 | # Onchain Clients
2 |
3 | ## Ethers.js - Instructions for Connecting to Ink
4 |
5 | Ethers.js documentation: [https://docs.ethers.org/v6/](https://docs.ethers.org/v6/)
6 |
7 | To connect to Ink by instantiating a new `ethers.js` `JsonRpcProvider` object with an RPC URL of Ink's testnet, follow the steps below:
8 |
9 | 1. **Install ethers.js**: Ensure you have `ethers.js` v6 installed in your project. If not, you can install it using npm or yarn.
10 |
11 | ```bash
12 | npm install ethers@6
13 | ```
14 |
15 | or
16 |
17 | ```bash
18 | yarn add ethers@6
19 | ```
20 |
21 | 2. **Instantiate a JsonRpcProvider**: Use the following code snippet to create a new `JsonRpcProvider` object with the RPC URL of Ink's testnet.
22 |
23 | ```javascript
24 | import { ethers } from 'ethers';
25 |
26 | const rpcUrl = 'https://rpc-gel-sepolia.inkonchain.com';
27 | const provider = new ethers.JsonRpcProvider(rpcUrl, 763373);
28 | ```
29 |
30 | 3. **Using the Provider**: You can now use the `provider` to interact with Ink's testnet. For example, you can fetch the current block number or interact with smart contracts deployed on the testnet.
31 |
32 | ```javascript
33 | // previous code
34 | const blockNumber = await provider.getBlockNumber();
35 | console.log(blockNumber);
36 | ```
37 |
38 | ### Example: Fetching the Current Block Number
39 |
40 | The following code snippet demonstrates how to fetch and print the current block number from Ink's testnet:
41 |
42 | ## Viem - Instructions for Connecting to Ink
43 |
44 | Viem documentation: [https://viem.sh/docs/introduction](https://viem.sh/docs/introduction)
45 |
46 | 1. **Install Viem**: Ensure you have `viem` installed in your project. If not, you can install it using npm or yarn.
47 |
48 | ```bash
49 | npm install viem
50 | ```
51 |
52 | or
53 |
54 | ```bash
55 | yarn add viem
56 | ```
57 |
58 | 2. **Instantiate a Public Client**: Use the following code snippet to create a new `Public Client` object with the Ink Sepolia testnet.
59 | ```javascript
60 | import { createPublicClient, http } from 'viem'
61 | import { inkSepolia } from 'viem/chains'
62 |
63 | const client = createPublicClient({
64 | chain: inkSepolia,
65 | transport: http(),
66 | })
67 | ```
68 |
69 | 3. **Consuming Actions**: You can now interact with Ink's chain! Here we are getting the current block number.
70 |
71 | ```javascript
72 | // previous code
73 | const blockNumber = await client.getBlockNumber();
74 | console.log(blockNumber);
75 | ```
76 |
--------------------------------------------------------------------------------
/src/pages/build/transaction-fees.mdx:
--------------------------------------------------------------------------------
1 | import { Callout } from 'nextra/components'
2 |
3 | # Fees on Ink
4 |
5 | As a Superchain L2, the fee you pay for each transaction on Ink has two components:
6 | 1. An execution fee for the chain you're on (i.e. Ink L2)
7 | 2. A security fee that helps secure the L2 by publishing L2 transactions to Ethereum (the L1)
8 |
9 | The security fee is generally higher than the execution fee because L1 transactions tend to be more expensive. The L1 can be subject to congestion and other situations that lead to high gas fees and longer confirmation times.
10 |
11 | This is an example of fees from an Ink transaction via our [Block Explorer](https://explorer-sepolia.inkonchain.com/tx/0xaea0e302ed3f89eef77475c1821df67b3713b80798298469ecc3dbd4d8e14e5f):
12 | 
13 |
14 |
15 |
16 |
--------------------------------------------------------------------------------
/src/pages/build/tutorials.mdx:
--------------------------------------------------------------------------------
1 | # Tutorials
2 |
3 | Welcome to the tutorials section! Here you'll find step-by-step guides to help you build on Ink.
4 |
5 | ## Available Tutorials
6 |
7 | * [Deploying a Smart Contract with Foundry](/build/tutorials/deploying-a-smart-contract/foundry)
8 | * [Deploying a Smart Contract with Hardhat](/build/tutorials/deploying-a-smart-contract/hardhat)
9 | * [Deploying a Smart Contract with Remix](/build/tutorials/deploying-a-smart-contract/remix)
10 | * [Verifying a Smart Contract](/build/tutorials/verify-smart-contract)
11 | * [Shipping a Superchain App](/build/tutorials/shipping-on-the-superchain)
12 | * [Deploying a SuperchainERC20](/build/tutorials/deploying-a-superchainerc20)
13 |
--------------------------------------------------------------------------------
/src/pages/build/tutorials/_meta.json:
--------------------------------------------------------------------------------
1 | {
2 | "deploying-a-smart-contract": "Deploying a Smart Contract",
3 | "verify-smart-contract": "Verifying a Smart Contract",
4 | "shipping-on-the-superchain": "Shipping on the Superchain",
5 | "deploying-a-superchainerc20": "Deploying a SuperchainERC20"
6 | }
7 |
--------------------------------------------------------------------------------
/src/pages/build/tutorials/deploying-a-smart-contract/_meta.json:
--------------------------------------------------------------------------------
1 | {
2 | "foundry": "Foundry",
3 | "hardhat": "Hardhat",
4 | "remix": "Remix"
5 | }
6 |
--------------------------------------------------------------------------------
/src/pages/build/tutorials/deploying-a-smart-contract/foundry.mdx:
--------------------------------------------------------------------------------
1 | import CopyableCode from "@/components/CopyableCode";
2 | import { TestnetDisclaimer } from "@/components/TestnetDisclaimer";
3 |
4 | # Deploying a Smart Contract with Foundry
5 |
6 | This guide will walk you through setting up a new project using Foundry, a blazing fast toolkit for Ethereum application development written in Rust.
7 |
8 | ## Installing Foundry
9 |
10 | First, you'll need to install Foundry. Run this command in your terminal:
11 |
12 | ```bash
13 | curl -L https://foundry.paradigm.xyz | bash
14 | ```
15 |
16 | Then run:
17 |
18 | ```bash
19 | foundryup
20 | ```
21 |
22 | This will install `forge`, `cast`, and `anvil` - the core tools of Foundry. You can also use `foundryup` to update the tools to the latest version.
23 |
24 | ## Creating a New Project
25 |
26 | To create a new project, navigate to the directory where you want to create your project and use the `forge init` command:
27 |
28 | ```bash
29 | forge init my_project
30 | cd my_project
31 | ```
32 |
33 | This will create a new directory with the following structure:
34 |
35 | ```
36 | my_project/
37 | ├── lib/
38 | ├── src/
39 | │ └── Counter.sol
40 | ├── test/
41 | │ └── Counter.t.sol
42 | ├── script/
43 | ├── .gitignore
44 | └── foundry.toml
45 | ```
46 |
47 | ## Writing Your First Contract
48 |
49 | Remove the default Counter example contract:
50 |
51 | ```bash
52 | rm -rf src/Counter.sol script/Counter.s.sol test/Counter.t.sol
53 | ```
54 |
55 | Create a new contract and put it in the file :
56 |
57 | ```solidity
58 | // SPDX-License-Identifier: MIT
59 | pragma solidity ^0.8.19;
60 | contract InkContract {
61 | string public greeting = "Hello, Ink!";
62 |
63 | function setGreeting(string memory _greeting) public {
64 | greeting = _greeting;
65 | }
66 | }
67 | ```
68 |
69 | Create the tests for this contract in the file :
70 |
71 | ```solidity
72 | // SPDX-License-Identifier: MIT
73 | pragma solidity ^0.8.19;
74 |
75 | import {Test} from "forge-std/Test.sol";
76 | import {InkContract} from "../src/InkContract.sol";
77 |
78 | contract InkContractTest is Test {
79 | InkContract public ink;
80 |
81 | function setUp() public {
82 | ink = new InkContract();
83 | }
84 |
85 | function test_DefaultGreeting() public view {
86 | assertEq(ink.greeting(), "Hello, Ink!");
87 | }
88 |
89 | function test_SetGreeting() public {
90 | string memory newGreeting = "New greeting!";
91 | ink.setGreeting(newGreeting);
92 | assertEq(ink.greeting(), newGreeting);
93 | }
94 |
95 | function testFuzz_SetGreeting(string memory randomGreeting) public {
96 | ink.setGreeting(randomGreeting);
97 | assertEq(ink.greeting(), randomGreeting);
98 | }
99 | }
100 | ```
101 |
102 | ## Building and Testing
103 |
104 | Build your project:
105 |
106 | ```bash
107 | forge build
108 | ```
109 |
110 | Run tests:
111 |
112 | ```bash
113 | forge test
114 | ```
115 |
116 | ## Deployment
117 |
118 | 1. First, create a file in your project root:
119 |
120 | ```env
121 | PRIVATE_KEY=your_private_key_here
122 | RPC_URL=https://rpc-gel-sepolia.inkonchain.com/
123 | BLOCKSCOUT_API_KEY=your_blockscout_api_key_here
124 | ```
125 |
126 | 2. Create a deployment script in :
127 |
128 | ```solidity
129 | // SPDX-License-Identifier: MIT
130 | pragma solidity ^0.8.19;
131 | import "forge-std/Script.sol";
132 | import "../src/InkContract.sol";
133 |
134 | contract DeployScript is Script {
135 | function run() external {
136 | uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");
137 |
138 | vm.startBroadcast(deployerPrivateKey);
139 |
140 | new InkContract();
141 |
142 | vm.stopBroadcast();
143 | }
144 | }
145 | ```
146 |
147 | 3. Deploy your contract:
148 |
149 | ```bash
150 | # Load environment variables
151 | source .env
152 |
153 | # Deploy to InkSepolia Testnet
154 | forge script script/Deploy.s.sol:DeployScript --rpc-url $RPC_URL --broadcast --verify
155 | ```
156 |
157 | ## Verifying Your Contract
158 |
159 | If you want to verify your contract on Etherscan:
160 |
161 | ```bash
162 | forge verify-contract src/InkContract.sol:InkContract \
163 | --chain-id 763373 \
164 | --etherscan-api-key $BLOCKSCOUT_API_KEY
165 | ```
166 |
167 | ## Additional Configuration
168 |
169 | You can customize your Foundry setup in `foundry.toml`:
170 |
171 | ```toml
172 | [profile.default]
173 | src = "src"
174 | out = "out"
175 | libs = ["lib"]
176 | solc = "0.8.19"
177 | optimizer = true
178 | optimizer_runs = 200
179 |
180 | [rpc_endpoints]
181 | inksepolia = "${INKSEPOLIA_RPC_URL}"
182 | ```
183 |
184 | ## Next Steps
185 |
186 | - Check out [Get Foundry Book](https://book.getfoundry.sh/) for more information on Foundry.
187 |
188 |
189 |
--------------------------------------------------------------------------------
/src/pages/build/tutorials/deploying-a-smart-contract/hardhat.mdx:
--------------------------------------------------------------------------------
1 | import { TestnetDisclaimer } from "@/components/TestnetDisclaimer";
2 |
3 | # Deploying a Smart Contract with Hardhat
4 |
5 | This guide will walk you through setting up a new project using Hardhat, a popular development environment for Ethereum software.
6 |
7 | ## Prerequisites
8 |
9 | First, make sure you have Node.js installed (version 20 or later). You can check your Node version with:
10 |
11 | ```bash
12 | node --version
13 | ```
14 |
15 | ## Setting Up a New Hardhat Project
16 |
17 | 1. Create a new directory for your project and initialize it:
18 |
19 | ```bash
20 | mkdir my-hardhat-project
21 | cd my-hardhat-project
22 | npm init -y
23 | ```
24 |
25 | 2. Install Hardhat and necessary dependencies:
26 |
27 | ```bash
28 | npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox
29 | ```
30 |
31 | 3. Create a new Hardhat project:
32 |
33 | ```bash
34 | npx hardhat init
35 | ```
36 |
37 | Choose "Create a JavaScript project" when prompted. This will create a project with this structure:
38 |
39 | ```
40 | my-hardhat-project/
41 | ├── contracts/
42 | ├── scripts/
43 | ├── test/
44 | ├── hardhat.config.js
45 | └── package.json
46 | ```
47 |
48 | ## Writing Your First Contract
49 |
50 | Create a new file in the `contracts` directory:
51 |
52 | ```solidity
53 | // SPDX-License-Identifier: MIT
54 | pragma solidity ^0.8.19;
55 |
56 | contract InkContract {
57 | string public greeting = "Hello, Ink!";
58 |
59 | function setGreeting(string memory _greeting) public {
60 | greeting = _greeting;
61 | }
62 | }
63 | ```
64 |
65 | ## Configuring Hardhat
66 |
67 | Create a `.env` file in your project root:
68 |
69 | ```env
70 | PRIVATE_KEY=your_private_key_here
71 | INK_SEPOLIA_URL=https://rpc-gel-sepolia.inkonchain.com/
72 | BLOCKSCOUT_API_KEY=your_blockscout_api_key_here
73 | ```
74 |
75 | Update your `hardhat.config.js`:
76 |
77 | ```javascript
78 | require("@nomicfoundation/hardhat-toolbox");
79 | require("dotenv").config();
80 |
81 | /** @type import('hardhat/config').HardhatUserConfig */
82 | module.exports = {
83 | solidity: "0.8.19",
84 | networks: {
85 | inksepolia: {
86 | url: process.env.INK_SEPOLIA_URL || "",
87 | accounts: process.env.PRIVATE_KEY ? [process.env.PRIVATE_KEY] : [],
88 | },
89 | },
90 | etherscan: {
91 | apiKey: {
92 | inksepolia: process.env.BLOCKSCOUT_API_KEY,
93 | },
94 | customChains: [
95 | {
96 | network: "inksepolia",
97 | chainId: 763373,
98 | urls: {
99 | apiURL: "https://explorer-sepolia.inkonchain.com/api",
100 | browserURL: "https://explorer-sepolia.inkonchain.com/",
101 | },
102 | },
103 | ],
104 | },
105 | };
106 | ```
107 |
108 | ## Building and Testing
109 |
110 | 1. Compile your contracts:
111 |
112 | ```bash
113 | npx hardhat compile
114 | ```
115 |
116 | 2. Create a test file in `test/InkContract.js`:
117 |
118 | ```javascript
119 | const { expect } = require("chai");
120 |
121 | describe("InkContract", function () {
122 | it("Should return the correct greeting", async function () {
123 | const InkContract = await ethers.getContractFactory("InkContract");
124 | const contract = await InkContract.deploy();
125 | await contract.deployed();
126 |
127 | expect(await contract.greeting()).to.equal("Hello, Ink!");
128 | });
129 | });
130 | ```
131 |
132 | 3. Run the tests:
133 |
134 | ```bash
135 | npx hardhat test
136 | ```
137 |
138 | ## Deployment
139 |
140 | Create a deployment script in `scripts/deploy.js`:
141 |
142 | ```javascript
143 | async function main() {
144 | const InkContract = await ethers.getContractFactory("InkContract");
145 | const contract = await InkContract.deploy();
146 |
147 | await contract.deployed();
148 |
149 | console.log("InkContract deployed to:", contract.address);
150 | }
151 |
152 | main()
153 | .then(() => process.exit(0))
154 | .catch((error) => {
155 | console.error(error);
156 | process.exit(1);
157 | });
158 | ```
159 |
160 | Deploy to Ink Sepolia testnet:
161 |
162 | ```bash
163 | npx hardhat run scripts/deploy.js --network inksepolia
164 | ```
165 |
166 | ## Verifying Your Contract
167 |
168 | After deployment, verify your contract:
169 |
170 | ```bash
171 | npx hardhat verify --network inksepolia
172 | ```
173 |
174 | ## Interacting with Your Contract
175 |
176 | You can use Hardhat Console to interact with your deployed contract:
177 |
178 | ```bash
179 | npx hardhat console --network inksepolia
180 | ```
181 |
182 | ```javascript
183 | const Contract = await ethers.getContractFactory("InkContract");
184 | const contract = await Contract.attach("YOUR_CONTRACT_ADDRESS");
185 | await contract.greeting();
186 | await contract.setGreeting("New greeting!");
187 | ```
188 |
189 | ## Additional Tools
190 |
191 | Hardhat comes with several built-in tools:
192 |
193 | - Hardhat Network: Local Ethereum network for development
194 | - Console: Interactive JavaScript environment
195 | - Gas Reporter: Gas usage reporting
196 | - Coverage: Code coverage for Solidity tests
197 |
198 | To use the network for local development:
199 |
200 | ```bash
201 | npx hardhat node
202 | ```
203 |
204 | ## Next Steps
205 |
206 | - Explore [Hardhat Documentation](https://hardhat.org/docs) for more features
207 |
208 |
209 |
--------------------------------------------------------------------------------
/src/pages/build/tutorials/deploying-a-smart-contract/remix.mdx:
--------------------------------------------------------------------------------
1 | import { Callout } from "nextra/components";
2 | import { TestnetDisclaimer } from "@/components/TestnetDisclaimer";
3 |
4 | # Deploying a Smart Contract with Remix
5 |
6 | This guide will walk you through deploying a smart contract on Ink using Remix IDE, a popular browser-based development environment for Ethereum smart contracts.
7 |
8 | ## What is Remix?
9 |
10 | Remix IDE is a powerful, open-source tool that helps you write, compile, deploy, and debug Solidity smart contracts. It's particularly useful for beginners as it requires no setup and runs directly in your browser.
11 |
12 | ## Accessing Remix
13 |
14 | 1. Open your web browser and navigate to [Remix IDE](https://remix.ethereum.org)
15 | 2. You'll see the default workspace with some example contracts
16 |
17 | ## Creating Your First Contract
18 |
19 | 1. In the File Explorer (left sidebar), create a new file by clicking the "+" icon
20 | 2. Name it `InkContract.sol` and add the following code:
21 |
22 | ```solidity
23 | // SPDX-License-Identifier: MIT
24 | pragma solidity ^0.8.19;
25 |
26 | contract InkContract {
27 | string public greeting = "Hello, Ink!";
28 |
29 | function setGreeting(string memory _greeting) public {
30 | greeting = _greeting;
31 | }
32 | }
33 | ```
34 |
35 | 
36 |
37 | ## Compiling Your Contract
38 |
39 | 1. Click on the `Solidity Compiler` tab in the left sidebar (icon looks like an "S")
40 | 2. Make sure the compiler version matches your pragma statement (0.8.19)
41 | 3. Click `Compile InkContract.sol`
42 | 4. Look for a green checkmark indicating successful compilation
43 |
44 | 
45 |
46 | ## Connecting to Ink Network
47 |
48 | 1. On the left sidebar, click the `Deploy & run transactions` tab (represented by a deployment arrow icon ▶️)
49 | 2. In the `ENVIRONMENT` dropdown:
50 | - If you see `Injected Provider`, select it
51 | - If not visible, click `Customize this list...` in dropdown
52 | - In the opened "Environment Explorer" window, under "Deploy using a Browser Extension" section, select `Injected Provider - [WALLET_NAME]`, where [WALLET_NAME] is your connected Web3 wallet (e.g., MetaMask, Rabby)
53 | 3. Configure your preferred Web3 wallet with Ink Sepolia network details:
54 | - Network Name: Ink Sepolia
55 | - RPC URL: https://rpc-gel-sepolia.inkonchain.com/
56 | - Chain ID: 763373
57 | - Currency Symbol: Ink
58 | - Block Explorer URL: https://explorer-sepolia.inkonchain.com/
59 |
60 | Most modern Web3 wallets will allow you to add custom networks through their settings. Look for options like `Add Network`, `Custom RPC`, or `Networks` in your wallet's interface.
61 |
62 | 
63 |
64 | ## Deploying Your Contract
65 |
66 | 1. Before deploying, ensure:
67 |
68 | - Your Web3 wallet is connected to Ink Sepolia network
69 | - You have sufficient ETH for deployment
70 | - Your wallet is connected to Remix IDE (accept the connection prompt if shown)
71 |
72 | 2. In the "Deploy & Run Transactions" tab:
73 |
74 | - Select `InkContract` from the `CONTRACT` dropdown
75 | - Click `Deploy`
76 | - A popup from your wallet will appear - review and confirm the transaction
77 |
78 | 3. Once deployed, you'll see your contract appear under `Deployed Contracts` in the left lower corner of the window.
79 |
80 | 
81 |
82 | ## Interacting with Your Contract
83 |
84 | 1. Under `Deployed Contracts`, expand your contract to see its functions
85 | 2. You can:
86 | - Read the current greeting by clicking `greeting`
87 | - Set a new greeting by:
88 | - Typing a new message in the `setGreeting` input field
89 | - Clicking `transact`
90 | - Confirming the transaction in your wallet
91 |
92 | 
93 |
94 | ## Verifying Your Contract
95 |
96 | See also the respective [tutorial](/build/tutorials/verify-smart-contract).
97 |
98 | 1. Go to [Ink Blockscout](https://explorer-sepolia.inkonchain.com)
99 | 2. Find your contract by its address
100 | 3. Click `Verify & Publish`
101 | 4. Fill in the verification details:
102 | - Choose `Solidity (Single file)`
103 | - Select the same compiler version used in Remix
104 | - Set optimization to 200 runs
105 | - Paste your contract code
106 | - Click `Verify & Publish`
107 |
108 |
109 | Make sure to verify whether optimization is on or off in Remix Compiler's
110 | Advanced Configuration as this can affect verification success.
111 |
112 |
113 | ## Tips and Best Practices
114 |
115 | - Always test your contracts in Remix's JavaScript VM before deploying to testnet
116 | - Use the Remix debugger to troubleshoot failed transactions
117 | - Save your contract's address after deployment
118 | - Keep your wallet secure and never share your private keys
119 |
120 | ## Useful Features in Remix
121 |
122 | - **Debugger**: Helps you understand why transactions fail
123 | - **Static Analysis**: Checks your code for common issues
124 | - **Gas Estimation**: Shows approximate deployment costs
125 | - **Console**: Displays transaction logs and debugging information
126 |
127 | ## Next Steps
128 |
129 | - Explore [Remix Documentation](https://remix-ide.readthedocs.io/) for advanced features
130 | - Learn about [Solidity](https://docs.soliditylang.org/) programming
131 |
132 |
133 |
--------------------------------------------------------------------------------
/src/pages/build/tutorials/deploying-a-superchainerc20.mdx:
--------------------------------------------------------------------------------
1 | import { Callout } from "nextra/components";
2 |
3 | # Deploying a SuperchainERC20
4 |
5 |
6 | The SuperchainERC20 standard is ready for production deployments. Please note
7 | that the OP Stack interoperability upgrade, required for crosschain messaging,
8 | is currently in active development.
9 |
10 |
11 | Welcome to the SuperchainERC20 quickstart guide! In this guide, we'll cover how the token works and the deployment process using the SuperchainERC20 starter kit. Whether you're a seasoned developer or just starting out, this guide has got you covered.
12 |
13 | ## What is SuperchainERC20?
14 |
15 | SuperchainERC20 provides a standardized token implementation enabling seamless token transfers across the Superchain.
16 |
17 | SuperchainERC20 extends the standard ERC-20 token with cross-chain mint and burn capabilities, enabling seamless interoperability across the [Superchain interop cluster](https://docs.optimism.io/stack/interop/explainer#superchain-interop-cluster). This token standard implements the [ERC-7802](https://eips.ethereum.org/EIPS/eip-7802) interface to enable 1-block latency cross-chain mint/burn functionality.
18 |
19 | ## How does SuperchainERC20 work?
20 |
21 | [SuperchainERC20](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/L2/SuperchainERC20.sol) and [SuperchainTokenBridge](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts-bedrock/src/L2/SuperchainTokenBridge.sol) work together to allow ERC-20 tokens to be transferred from one chain to the other.
22 |
23 | SuperchainERC20 cross-chain transfers require two transactions:
24 |
25 | 1. **Initiate Transaction**: On the source chain, tokens are burned and a cross-chain message is emitted
26 | 2. **Execute Transaction**: The message is relayed to the destination chain, triggering token minting
27 |
28 | This flow ensures tokens maintain consistent total supply across the entire Superchain ecosystem and eliminates the need for liquidity pools or wrapped tokens.
29 |
30 | ## Why SuperchainERC20 matters for users, token issuers, and apps on Ink
31 |
32 | Superchain interop provides Ink with essential cross-chain capabilities that enhance the network's interoperability. When token issuers use SuperchainERC20 over a typical ERС-20 deployment it gives token issuers access to the broader Superchain network effects, ensuring your tokens can seamlessly be used by apps and users across the Superchain.
33 |
34 | SuperchainERC20 deployment creates opportunities for:
35 |
36 | - **Enhanced Liquidity**: Unified token representation across chains improves capital efficiency
37 | - **Simplified Developer Experience**: Consistent API for projects building on Ink
38 | - **Reduced Fragmentation**: Improved capital efficiency for DeFi applications across the Superchain ecosystem - one chain to rule them all
39 |
40 | ## 🚀 Deploying SuperchainERC20 - Quickstart
41 |
42 | ### Prerequisites
43 |
44 | First, you'll need to install Foundry, as the project requires `anvil`. Follow the [Foundry installation guide](https://book.getfoundry.sh/getting-started/installation).
45 |
46 | ### Setup Steps
47 |
48 | 1. **Clone the repository**
49 |
50 | ```sh
51 | git clone git@github.com:ethereum-optimism/superchainerc20-starter.git
52 | cd superchainerc20-starter
53 | ```
54 |
55 | 2. **Install dependencies**
56 |
57 | ```sh
58 | pnpm i
59 | ```
60 |
61 | 3. **Set up environment files**
62 |
63 | ```sh
64 | pnpm init:env
65 | ```
66 |
67 | 4. **Start the development environment**
68 |
69 | ```sh
70 | pnpm dev
71 | ```
72 |
73 | 5. **Update RPC URLs**
74 |
75 | ```sh
76 | pnpm contracts:update:rpcs
77 | ```
78 |
79 | 6. **Configure deployment settings**
80 | Create or update your deployment configuration file:
81 |
82 | ```toml
83 | [deploy_config]
84 | salt = "ethers phoenix"
85 | chains = ["sepolia/ink"]
86 |
87 | [token]
88 | owner_address = "" # Your wallet address
89 | name = "" # The name of your token
90 | symbol = "" # Your token's symbol (e.g., "OPT")
91 | decimals = 18 # Number of decimal places (18 is standard)
92 | ```
93 |
94 | Save this to `packages/contracts/configs/deploy-config.toml`
95 |
96 | 7. **Set up your deployer private key**
97 |
98 | ```sh
99 | echo 'DEPLOYER_PRIVATE_KEY=' > packages/contracts/.env
100 | ```
101 |
102 | ⚠️ Never share or commit your private key. Make sure your wallet has enough funds for deployment.
103 |
104 | 8. **Deploy your token**
105 | ```sh
106 | pnpm contracts:deploy:token
107 | ```
108 |
109 | ## Security considerations
110 |
111 |
112 | To ensure security, you must either design the deployer to allow only a specific trusted ERC-20 contract, such as SuperchainERC20, to be deployed through it, or call CREATE2 to deploy the contract directly from an EOA you control.
113 |
114 | This precaution is critical because if an unauthorized ERC-20 contract is deployed at the same address on any Superchain network, it could allow malicious actors to mint unlimited tokens and bridge them to the network where the original ERC-20 contract resides.
115 |
116 |
117 |
118 | For production deployments, ensure that:
119 |
120 | 1. Grant permissions to the `SuperchainTokenBridge`(address `0x4200000000000000000000000000000000000028`) to call `crosschainMint` and `crosschainBurn`.
121 | 2. Deploy the `SuperchainERC20` at the same address on every chain in the Superchain where you want your token to be available. If you do not deploy the contract to a specific destination chain, users will be unable to successfully move their tokens to that chain.
122 |
123 | ## What's Next?
124 |
125 | SuperchainERC20 enables token issuers to seamlessly access Superchain network effects. By leveraging SuperchainERC20 and Superchain interop, developers can focus on building features rather than solving complex cross-chain challenges.
126 |
127 | - Use Supersim, a local development tool, to [deploy a SuperchainERC20 or build an interop-enabled app](https://docs.optimism.io/app-developers/get-started)
128 | - Learn more about the [technical architecture of Superchain interop](https://docs.optimism.io/stack/interop/explainer)
129 | - Learn about how [other token standards can benefit from Superchain interop](https://docs.optimism.io/stack/interop/compatible-tokens)
130 |
--------------------------------------------------------------------------------
/src/pages/build/tutorials/shipping-on-the-superchain.mdx:
--------------------------------------------------------------------------------
1 | # Shipping on the Superchain
2 |
3 | You can use [Supersim](https://github.com/ethereum-optimism/supersim) to simulate the Superchain and develop apps that can be used across any chain!
4 |
5 | Supersim enables builders to:
6 |
7 | * Experiment with apps that can be accessed from any chain
8 | * Create tokens with **SuperchainERC20**, a fungible token standard for tokens that can be used across the Superchain
9 | * Simulate crosschain messaging
10 |
--------------------------------------------------------------------------------
/src/pages/build/tutorials/verify-smart-contract.mdx:
--------------------------------------------------------------------------------
1 | import { Callout } from 'nextra/components'
2 |
3 | ## Verifying your Smart Contract
4 |
5 | In order for your deployed smart contract(s) to be human-readable on block explorers like Blockscout they must be verified. Verification is highly recommended to increase trust in your code and dapp.
6 |
7 | Smart contracts can be verified through the Blockscout UI or a [host of other methods](https://docs.blockscout.com/devs/verification).
8 |
9 | ## Verifying a Smart Contract using the Blockscout UI
10 |
11 | Verification is available for both Solidity and Vyper contracts. **Currently, there are 7 different types of inputs you can use for verification using the Blockscout UI**.
12 |
13 |
14 | 👷🏻♂️ If preferred you can verify directly from your Hardhat or Foundry dev environment.
15 |
16 | [Hardhat Verification Plugin](https://docs.blockscout.com/devs/verification/hardhat-verification-plugin)
17 |
18 | [Foundry Verification](https://docs.blockscout.com/devs/verification/foundry-verification)
19 |
20 |
21 | ### Smart Contract Verification with Blockscout
22 | 1) Go to the [Verify contract](https://explorer-sepolia.inkonchain.com/contract-verification) page (Other -> Verify contract)
23 |
24 | 
25 |
26 | 2) Enter the contract address you received during deployment. The dropdown will show you several available verification options. Select the one you would like to use and continue.
27 |
28 | 
29 |
30 | ### Input Types
31 | Choose the format that applies to your files:
32 |
33 | - Solidity ([Flattened source code](/build/tutorials/verify-smart-contract#solidity-flattened-source-code))
34 |
35 | - Solidity ([Standard JSON input](/build/tutorials/verify-smart-contract#solidity-standard-json-input))
36 |
37 | - Solidity ([Sourcify](/build/tutorials/verify-smart-contract#via-sourcify-sources-and-metadata-json-file))
38 |
39 | - Solidity ([Multi-part files](/build/tutorials/verify-smart-contract#solidity-multi-part-files))
40 |
41 | - Vyper ([Contract](/build/tutorials/verify-smart-contract#vyper-contract))
42 |
43 | - Vyper ([Multi-part files](/build/tutorials/verify-smart-contract#vyper-multi-part-files-and-standard-json-input))
44 |
45 | - Vyper ([Standard JSON input](/build/tutorials/verify-smart-contract#vyper-multi-part-files-and-standard-json-input))
46 |
47 | #### Solidity (Flattened source code)
48 | This verification method is recommended only for single-file smart contracts without any imports. For verification of contracts containing more than 1 file, it's recommended to use different verification method.
49 |
50 | 
51 |
52 | 1. **Contract Address**: The `0x` address supplied on contract creation (added above)
53 |
54 | 2. **Is Yul contract**: Select if the contract is coded in Yul for efficiency.
55 |
56 | 3. **Include Nightly Builds**: Select if you want to show nightly builds.
57 |
58 | 4. **Compiler**: derived from the first line in the contract `pragma solidity X.X.X`. Use the corresponding compiler version rather than the nightly build.
59 |
60 | 5. **EVM Version**: Select the correct EVM version if known, otherwise use default.
61 |
62 | 6. **Optimization Enabled**: If you enabled optimization during compilation, select and enter the run value. 200 is the Solidity Compiler default value. Only change if you changed this value while compiling.
63 |
64 | 7. **Enter the Solidity Contract Code**: Copy-paste the source code of your smart contract as is.
65 |
66 | 8. **Add Contract Libraries**: Enter the name and 0x address for any required libraries called in the .sol file. You can add multiple contracts with the "+" button.
67 |
68 | 9. Click the `Verify and Publish` button.
69 |
70 | 10. If all goes well, you will see a checkmark ✅ next to Code in the code tab, and an additional tab called `Read Contract`. The contract name will now appear in BlockScout with any transactions related to your contract.
71 |
72 | #### Solidity (Standard JSON input)
73 |
74 | More information on JSON input is available [here](https://docs.soliditylang.org/en/latest/using-the-compiler.html#input-description).
75 |
76 |
77 | 1. **Include nightly builds**. You can choose `Yes` or `No` depending on your compiler.
78 |
79 | 2. **Compiler**. Choose the compiler version used to compile your smart contract. If you selected yes for nightly builds, use the compiler version rather than the build.
80 |
81 | 3. **Standard Input JSON**. Upload your Standard Input JSON file. File should follow the Solidity [format](https://docs.soliditylang.org/en/latest/using-the-compiler.html#input-description) and all the sources must be in Literal Content format, not a URL.
82 |
83 | Click the `Verify & publish` button and wait for the response.
84 |
85 | #### Via Sourcify: Sources and metadata JSON file
86 | See [Contract Verification via Sourcify](https://docs.blockscout.com/devs/verification/contracts-verification-via-sourcify) for details.
87 |
88 | #### Solidity (Multi-part files)
89 | See the above settings. You will upload all of the .sol or .yul files you used for your contract. This method requires at least 2 files - if you have a single file use the flattened source code method.
90 |
91 | #### Vyper Contract
92 | Contract Name: Name assigned to the contract.
93 |
94 | 1. **Compiler**: Select the compiler version used in the source code.
95 |
96 | 2. **EVM Version**: Select the correct EVM version if known, otherwise use default.
97 |
98 | 3. **Contract Code**: Copy and paste the contract code
99 |
100 | 4. Click the `Verify and Publish` button.
101 |
102 | If all goes well, you will see a checkmark ✅ next to Code in the code tab, and an additional tab called `Read Contract`. The contract name will now appear in BlockScout with any transactions related to your contract.
103 |
104 | #### Vyper Multi-part files and standard json input
105 | See the information above.
106 |
107 | ### Troubleshooting
108 | If you receive the dreaded `There was an error compiling your contract` message this means the bytecode doesn't match the supplied source code. Unfortunately, there are many reasons this may be the case. Here are a few things to try:
109 |
110 | 1) Double check the compiler version is correct.
111 |
112 |
113 | Check all version digits - for example 0.5.1 is different from 0.5.10
114 |
115 |
116 | 2) Check that an extra space has not been added to the end of the contract. When pasting in, an extra space may be added. Delete this and attempt to recompile.
117 |
118 | 3) Copy, paste, and verify your source code in Remix. You may find some exceptions here.
119 |
120 | Verification in a dev environment
121 | The [Hardhat verification plugin](https://docs.blockscout.com/devs/verification/hardhat-verification-plugin) supports BlockScout. You can also choose to use the [Sourcify plugin](https://docs.blockscout.com/devs/verification/hardhat-verification-plugin/sourcify-plugin-for-hardhat) to verify with Sourcify from your hardhat environment. [Foundry supports blockscout verification with Forge](https://book.getfoundry.sh/reference/forge/forge-verify-contract).
122 |
123 | ###### Source
124 | [Blockscout](https://docs.blockscout.com/devs/verification/blockscout-ui)
125 |
--------------------------------------------------------------------------------
/src/pages/build/verify.mdx:
--------------------------------------------------------------------------------
1 | ---
2 | title: Kraken Verify
3 | description: Solidity contracts for Kraken Verify - EAS attestation utilities enabling access control for verified Kraken users through onchain attestations.
4 | ---
5 |
6 | # Kraken Verify
7 |
8 | Kraken Verify is a service that allows users to create an onchain attestation linking their wallet address to their verified Kraken account. This creates a trusted connection between a user's Kraken identity and their blockchain activity, enabling access to exclusive features across the Ink ecosystem.
9 |
10 | Kraken Verify uses the [Ethereum Attestation Service (EAS)](https://attest.org/) on Ink to issue onchain attestations. These attestations only store the wallet address and verification confirmation - no personal information is published onchain. Gas fees are covered by Kraken, making verification free for users.
11 |
12 | Users can verify one address at a time, with the ability to revoke and re-verify with a new address as needed. To prevent abuse, users can perform up to 20 verifications per year. These verifications are non-transferable and provide a secure way to access verified-only features.
13 |
14 | ## Installation
15 |
16 | ```bash
17 | # Using npm
18 | npm install @krakenfx/verify
19 |
20 | # Using yarn
21 | yarn add @krakenfx/verify
22 |
23 | # Using pnpm
24 | pnpm add @krakenfx/verify
25 | ```
26 |
27 | ## Setup
28 |
29 | ### Remappings
30 |
31 | Generate remappings for Foundry:
32 |
33 | ```bash
34 | forge remappings > remappings.txt
35 | ```
36 |
37 | You might need to add this extra one manually if you're using pnpm:
38 |
39 | ```txt
40 | @ethereum-attestation-service/=node_modules/.pnpm/@ethereum-attestation-service+eas-contracts@1.8.0/node_modules/@ethereum-attestation-service
41 | ```
42 |
43 | ### IDE Configuration
44 |
45 | Update your IDE to support remappings. For VS Code:
46 |
47 | ```json
48 | // .vscode/settings.json
49 | {
50 | "solidity.remappings": ["...=node_modules/..."]
51 | }
52 | ```
53 |
54 | ## Usage
55 |
56 | ### Solidity
57 |
58 | ```solidity
59 | // SPDX-License-Identifier: MIT
60 | pragma solidity 0.8.24;
61 |
62 | import { KrakenVerifyAccessControl } from "@krakenfx/verify/src/abstracts/KrakenVerifyAccessControl.sol";
63 |
64 | contract MyContract is KrakenVerifyAccessControl {
65 | // Only users with valid Kraken Verify attestations can call this function
66 | function verifiedUserFunction() external onlyVerified {
67 | // Your implementation
68 | }
69 | }
70 | ```
71 |
72 | ### JavaScript / TypeScript Client
73 |
74 | The package also provides a client for checking address verification status directly from JavaScript or TypeScript applications. This can be useful for frontend applications that need to verify user addresses before displaying certain features or content.
75 |
76 | #### ESM / TypeScript
77 |
78 | ```typescript
79 | // ES Modules / TypeScript
80 | import { VerifyClient } from "@krakenfx/verify";
81 |
82 | const verifyClient = new VerifyClient();
83 | const yourAddress = "0x2193981f2d65149644C039c9071f2bE8b5938F0B";
84 |
85 | // Check if an address is verified
86 | const isVerified = await verifyClient.isAddressVerified(yourAddress);
87 |
88 | console.log(`Result: ${isVerified ? "✅ Verified" : "❌ Not verified"}`);
89 | ```
90 |
91 | #### CommonJS
92 |
93 | ```javascript
94 | // CommonJS
95 | const { VerifyClient } = require("@krakenfx/verify");
96 |
97 | const verifyClient = new VerifyClient();
98 | const yourAddress = "0x2193981f2d65149644C039c9071f2bE8b5938F0B";
99 |
100 | // Check if an address is verified
101 | async function checkVerification() {
102 | const isVerified = await verifyClient.isAddressVerified(yourAddress);
103 | console.log(`Result: ${isVerified ? "✅ Verified" : "❌ Not verified"}`);
104 | }
105 |
106 | checkVerification();
107 | ```
108 |
109 | #### Configuration Options
110 |
111 | You can customize the client by passing options to the constructor:
112 |
113 | ```typescript
114 | const verifyClient = new VerifyClient({
115 | rpcUrl: "https://your-rpc-endpoint.com", // Custom RPC URL
116 | verbose: true, // Enable verbose logging
117 | });
118 | ```
119 |
120 | ## What's Included
121 |
122 | This package provides access control for verified Kraken users through EAS attestations:
123 |
124 | - `KrakenVerifyAccessControl.sol`: Abstract contract with the `onlyVerified` modifier
125 | - Supporting libraries and interfaces for attestation verification
126 | - JavaScript/TypeScript client for checking address verification status
127 |
128 | ## Requirements
129 |
130 | - Solidity 0.8.24
131 | - Node.js 16+ (for client usage)
132 |
133 | ## License
134 |
135 | MIT
136 |
--------------------------------------------------------------------------------
/src/pages/faq.mdx:
--------------------------------------------------------------------------------
1 | import { URLS } from "@/utils/urls";
2 |
3 | # Frequently Asked Questions
4 |
5 | ## Ink
6 |
7 | ### What makes Ink different?
8 |
9 | Ink is an OP Stack Layer 2 launched with 1-second blocktimes. What sets us apart is our dedication to building a comprehensive DeFi ecosystem while staying true to our origins. Our mission is to simplify DeFi while bringing Kraken’s core principles—security, user experience, and privacy—onchain.
10 |
11 | We embrace our cypherpunk roots by shipping rapidly and iteratively. Feedback from users, developers, and the broader onchain community is vital to us as we strive to create the ultimate platform for achieving individual financial sovereignty.
12 |
13 | ### What’s the difference between Ethereum and OP Stack chains?
14 |
15 | OP Stack chains are designed to be EVM equivalent and introduces as few changes as possible to the Ethereum protocol.
16 |
17 | For a full rundown on all differences please refer to [Optimism’s documentation](https://docs.optimism.io/stack/differences).
18 |
19 | For convenience, a few notable points worth mentioning are:
20 |
21 | - [Opcodes](https://docs.optimism.io/stack/differences#opcodes)
22 | - [Bridging](https://docs.optimism.io/stack/differences#bridging)
23 | - [Chain Finality](https://docs.optimism.io/stack/differences#chain-finality)
24 |
25 | ### How do I get started with developing on Ink?
26 |
27 | Get started developing on Ink [here](/build/getting-started). We also have a full stack suite of [infra providers and tools](/tools/rpc) to help you ship.
28 |
29 | ### How to deploy a smart contract on Ink?
30 |
31 | You can follow a tutorial from the Ink Docs here: https://docs.inkonchain.com/build/tutorials
32 |
33 | ### Where can I get funds to test Ink?
34 |
35 | Check out our [faucets](/tools/faucets).
36 |
37 | ### Where can I find important contracts deployed on Ink?
38 |
39 | For token contracts on Ink please refer to our [Ink Token Contracts](/useful-information/ink-token-contracts) page.
40 |
41 | For L1, L2 and predeploy addresses, please see our [Contracts](/useful-information/contracts) page.
42 |
43 | ### Are there any native bridging options?
44 |
45 | At the moment, Ink does not host its own bridging portal. Please review our recognized partner’s bridges here: https://inkonchain.com/dashboard
46 |
47 | ### Why are fees/bridging high?
48 |
49 | Ink cannot control gas fees or platform fees which vary subject to chain congestion and platform discretion. Please feel free to DYOR and explore multiple options available at https://inkonchain.com/dashboard
50 |
51 | Kraken also supports the Ink network with zero withdrawal fees. If you want to buy ETH and then send it to your wallet, this is another option.
52 |
53 | ### Is developing on and using Ink expensive?
54 |
55 | Not at all! As an L2 built on the Optimism stack Ink benefits from extremely low fees. L2 users do pay an extra fee to settle L2 data on L1 (Ethereum mainnet). Please see [Fees](/build/transaction-fees) for more information.
56 |
57 | ### What can I deploy on Ink?
58 |
59 | You can deploy anything! While we may be a DeFi chain, we encourage developers of all types to deploy. Check out our [tutorials](/build/tutorials) to get started.
60 |
61 | ### Why don’t you support XYZ dApp?
62 |
63 | The Ink ecosystem is growing rapidly post launch! Every week new partner bridges, DEXes, Infra providers, and other dApps are onboarding with Ink. Keep an eye on our social accounts for announcements. We value your feedback and appreciate your loyalty to the community.
64 |
65 | ### Where can I learn more about OP Stack?
66 |
67 | To learn more about OP Stack chains, please visit [Optimism’s documentation](https://docs.optimism.io/).
68 |
69 | ## Community
70 |
71 | ### Wen TGE?
72 |
73 | There is no information to share at this moment regarding any token from Ink.
74 |
75 | ### Wen Airdrop
76 |
77 | There is no information to share at this moment regarding any airdrop. There may have been social media posts from third party, crypto related accounts in X but please DYOR (Do Your Own Research) and consult with us in official channels to avoid misinformation and to maintain expectations of what to come.
78 |
79 | Finally, if still unsuccessful, please open a ticket so we can investigate. Feel free to share their username so we can help better.
80 |
81 | ### How do I get access granted to Guild task?
82 |
83 | Please complete the tasks as detailed. Expand the description section to see the full task list and instructions. Once done, click the re-check access button at the top so Guild.xyz can check again and update your status.
84 |
85 | Also make sure to connect the right address to Guild and that you grant access to all connected networks in your wallet.
86 |
--------------------------------------------------------------------------------
/src/pages/general/_meta.json:
--------------------------------------------------------------------------------
1 | {
2 | "about": "About Ink",
3 | "network-information": "Network Information",
4 | "connect-wallet": "Connect Wallet",
5 | "bridge": { "title": "Bridge", "href": "/tools/bridges" },
6 | "faucet": { "title": "Faucet", "href": "/tools/faucets" },
7 | "support": "Support"
8 | }
9 |
--------------------------------------------------------------------------------
/src/pages/general/about.mdx:
--------------------------------------------------------------------------------
1 | # About Ink
2 |
3 | ## What is Ink?
4 |
5 | Ink is an Ethereum OP Stack layer 2 blockchain designed to be the house of DeFi for the Superchain; a powerful baselayer for deploying innovative DeFi protocols.
6 |
7 | - **Sub-second block times**: 1s block times Day 1, sub-second blocks coming soon.
8 | - **Smol Gas**: Ape more, pay less.
9 | - **Security**: Sequencer-level security to protect users from malicious intents and exploits.
10 | - **Interoperability**: A commitment to the seamless flow of capital across the Superchain and beyond.
11 | - **Unleashed by Kraken**: Ink will leverage Kraken's security and crypto expertise to support builders and users alike as they move towards independent financial sovereignty.
12 | - **Scaling Ethereum**: Ink is dedicated to scaling Ethereum with a powerful L2 that enhances performance and accessibility.
13 |
14 | ## Why use Ink?
15 |
16 | Built on the Superchain and unleashed by Kraken, Ink will serve as a central point in your journey towards onchain financial sovereignty.
17 |
18 | ### Ink features:
19 |
20 | - **Abstraction**: Ink integrates Kraken's infrastructure and enables users to enjoy a unified experience from converting fiat to the cutting edge of DeFi.
21 | - **DeFi-first**: Ink aims to scale up DeFi's user base and evolve the quality and range of DeFi products.
22 | - **UX**: Ink pursues a user experience that makes your onchain journey a breeze by leveraging aggregation, automation and abstraction. Check out our Ink Kit here for more.
23 | - **Speed**: 1s block times on day one with subsecond block times coming soon.
24 | - **Security**: Kraken's decade-long record of security and reliability will be reflected and pushed forward on Ink.
25 | - **Support**: Builders can expect rich documentation, expert guidance, workshops, tailored onboarding, dedicated community channels and financial support to bring their ideas to life.
26 | - **Low Fees**: Harnessing the scalability of Optimism and the security of Ethereum, gas fees on Ink are a fraction of mainnet.
27 | - **Open Source, Scaling Ethereum**: At Ink, we build in the open, benefiting all.
28 | - **EVM compatible**: Seamlessly deploy any Solidity contract written for Ethereum Mainnet or other L2s directly on Ink without modifications.
29 |
30 | ## What is Ink built on?
31 |
32 | - Ink is a Layer 2 built on the [OP Stack](https://docs.optimism.io/stack/getting-started) and part of the Superchain. Aligning with the Optimism Superchain promotes interoperability and the seamless flow of funds from one chain to the next, allowing Ink to push the limits of DeFi.
33 |
--------------------------------------------------------------------------------
/src/pages/general/connect-wallet.mdx:
--------------------------------------------------------------------------------
1 | import { Callout } from "nextra/components";
2 | import CopyableCode from "@/components/CopyableCode";
3 | import { AddNetworkButton } from "../../components/AddNetworkButton";
4 |
5 | ## Connect Wallet
6 |
7 |
8 |
9 |
10 |
11 | ## Kraken Wallet
12 |
13 | Ink Mainnet is supported natively on Kraken Wallet. Don’t have it yet? Download it for [iOS](https://apps.apple.com/us/app/kraken-wallet-crypto-defi/id1626327149) or [Android](https://play.google.com/store/apps/details?id=com.kraken.superwallet&hl=en).
14 |
15 | ---
16 |
17 | ## Rainbow
18 |
19 | Ink Mainnet is supported natively on Rainbow wallet. Don’t have it yet? Download it [here](https://rainbow.me/en/download)
20 |
21 | ---
22 |
23 | ## MetaMask
24 |
25 | To manually add **Ink Mainnet** as a custom network, follow these steps:
26 |
27 | 1. Open your MetaMask browser extension.
28 | 2. Click the network selection dropdown at the top left of the extension.
29 | 3. Select the **"+ Add a custom network"** button at the bottom.
30 | 4. In the new window, click **"Add a network manually"** at the bottom of the list.
31 | 5. Enter the details provided in the dialog that appears.
32 |
33 | | Field | Information |
34 | | ------------------------------ | ------------------------------------------------------- |
35 | | Network Name | Ink |
36 | | RPC Endpoint (HTTPS) (primary) | |
37 | | Chain ID | 57073 |
38 | | Currency Symbol | ETH |
39 | | Block Explorer | |
40 |
41 | 6. Click **"Save"**.
42 | 7. Ink Mainnet will now be available in the network selection dropdown.
43 |
44 | ---
45 |
46 | _For a more detailed walkthrough, please refer to the [official MetaMask tutorial](https://support.metamask.io/networks-and-sidechains/managing-networks/how-to-add-a-custom-network-rpc/)._
47 |
--------------------------------------------------------------------------------
/src/pages/general/faucet.mdx:
--------------------------------------------------------------------------------
1 | # Faucets
2 |
3 | ## TODO
4 |
--------------------------------------------------------------------------------
/src/pages/general/network-information.mdx:
--------------------------------------------------------------------------------
1 | import CopyableCode from "@/components/CopyableCode";
2 |
3 | # Network Information
4 |
5 | ## Mainnet
6 |
7 | | Field | Information |
8 | | -------------------------------- | -------------------------------------------------------- |
9 | | Network Name | Ink |
10 | | Description | Ink's public mainnet |
11 | | RPC Endpoint (HTTPS) (primary) | |
12 | | RPC Endpoint (WSS) (primary) | |
13 | | RPC Endpoint (HTTPS) (secondary) | |
14 | | RPC Endpoint (WSS) (secondary) | |
15 | | Chain ID | 57073 |
16 | | Currency Symbol | ETH |
17 | | Block Explorer | |
18 |
19 | ---
20 |
21 | ## Testnet
22 |
23 | | Field | Information |
24 | | -------------------------------- | --------------------------------------------------------------- |
25 | | Network Name | Ink Sepolia |
26 | | Description | Ink's public testnet |
27 | | RPC Endpoint (HTTPS) (primary) | |
28 | | RPC Endpoint (WSS) (primary) | |
29 | | RPC Endpoint (HTTPS) (secondary) | |
30 | | RPC Endpoint (WSS) (secondary) | |
31 | | Chain ID | 763373 |
32 | | Currency Symbol | ETH |
33 | | Block Explorer | |
34 |
35 | Click [here](/tools/rpc) for a list of vendors offering private RPC endpoints.
36 |
--------------------------------------------------------------------------------
/src/pages/general/support.mdx:
--------------------------------------------------------------------------------
1 | import { URLS } from "@/utils/urls";
2 |
3 | # Support
4 |
5 | At Ink, we're here to help everyone, builders and users alike.
6 |
7 | Please don't hesitate to reach out to us via any of our channels listed below.
8 |
9 | - [Telegram](https://t.me/inkonchain)
10 | - [Twitter](https://x.com/inkonchain)
11 |
--------------------------------------------------------------------------------
/src/pages/general/support/_meta.json:
--------------------------------------------------------------------------------
1 | {
2 | "troubleshooting": "Troubleshooting"
3 | }
4 |
--------------------------------------------------------------------------------
/src/pages/general/support/troubleshooting.mdx:
--------------------------------------------------------------------------------
1 | import { Callout } from "nextra/components";
2 | import CopyableCode from "@/components/CopyableCode";
3 |
4 | # Troubleshooting Guide
5 |
6 | This guide covers common issues developers and users might encounter when working with Ink, along with their solutions.
7 |
8 | ## Transaction Issues
9 |
10 | ### Nonce Out of Sync
11 |
12 | If you encounter JSON-RPC internal errors or transactions getting stuck, your wallet's nonce may be out of sync with the network. Here's how to fix it:
13 |
14 | #### For MetaMask Users:
15 |
16 | 1. Enable custom nonce in MetaMask:
17 |
18 | - Go to Settings > Advanced
19 | - Enable "Customize transaction nonce"
20 |
21 | 2. Find your next valid nonce using either method A or B:
22 |
23 | **Method A: Using Block Explorer**
24 |
25 | - Go to (replace YOUR_ADDRESS with your address)
26 | - Find your most recent transaction where you were the sender (FROM address)
27 | - Click the transaction and then "View details"
28 | - Find the nonce value and add 1 to it - this is your next valid nonce
29 |
30 | **Method B: Using Command Line**
31 |
32 | ```bash
33 | curl -s -X POST -H "Content-Type: application/json" --data '{
34 | "jsonrpc":"2.0",
35 | "method":"eth_getTransactionCount",
36 | "params":["YOUR_ADDRESS", "latest"],
37 | "id":1
38 | }' https://rpc-gel.inkonchain.com | python3 -c "import sys, json; print(int(json.load(sys.stdin)['result'], 16))"
39 | ```
40 |
41 | Replace `YOUR_ADDRESS` with your wallet address. The number returned is your next valid nonce.
42 |
43 | 3. Send a recovery transaction:
44 |
45 | - Send a 0 ETH transaction to yourself
46 | - When prompted for the nonce, use the exact number you got from either method above
47 | - Increase the gas price slightly (tap + once in the Network Fee section)
48 | - The transaction should go through
49 |
50 | 4. Future transactions should now use the correct nonce
51 |
52 |
53 | The recovery transaction typically costs around $0.05 in gas fees.
54 |
55 |
56 | ## Getting Help
57 |
58 | If you're still experiencing issues:
59 |
60 | 1. Check the [Network Status Page](https://status.inkonchain.com/) for any ongoing incidents
61 | 2. Submit a detailed bug report on our [GitHub](https://github.com/inkonchain/docs/issues)
62 |
--------------------------------------------------------------------------------
/src/pages/index.mdx:
--------------------------------------------------------------------------------
1 | import { Callout } from "nextra/components";
2 | import { URLS } from "@/utils/urls";
3 |
4 | # Welcome to the Ink Docs
5 |
6 |
9 |
10 | Welcome to the documentation for Ink, Kraken's dedicated DeFi chain.
11 |
12 |
13 | New to Ink? [Learn more about Ink](/general/about)
14 |
15 |
16 | ###### Get started with developing on Ink!
17 |
18 | - [Get connected to Ink](/general/connect-wallet)
19 | - [Get testnet funds](/tools/faucets) to send transactions and deploy contracts on Ink
20 | - Check out the [tutorials](/build/tutorials) (WIP) to start building on Ink
21 |
22 | Try out [InkGPT](https://chatgpt.com/g/g-ef8AAM6s4-inkkit-assistant)! Blaze
23 | through the docs and get deployed in no time with our new AI assistant.
24 |
25 |
--------------------------------------------------------------------------------
/src/pages/status.mdx:
--------------------------------------------------------------------------------
1 | import { useEffect } from 'react'
2 | import { useRouter } from 'next/router'
3 |
4 | export default function StatusPage() {
5 | useEffect(() => {
6 | // Open in new tab and redirect current page back to previous page
7 | window.open('https://status.inkonchain.com/', '_blank')
8 | window.history.back()
9 | }, [])
10 |
11 | return (
12 |
13 | Opening Status Page in new tab...
14 |
15 | )
16 | }
17 |
--------------------------------------------------------------------------------
/src/pages/tools/_meta.json:
--------------------------------------------------------------------------------
1 | {
2 | "account-abstraction": "Account Abstraction",
3 | "block-explorers": "Block Explorers",
4 | "bridges": "Bridges",
5 | "crosschain": "Crosschain",
6 | "faucets": "Faucets",
7 | "indexers": "Indexers",
8 | "multisig": "Multisig",
9 | "oracles": "Oracles",
10 | "rpc": "RPC",
11 | "security": "Security",
12 | "vrf": "VRF"
13 | }
14 |
--------------------------------------------------------------------------------
/src/pages/tools/account-abstraction.mdx:
--------------------------------------------------------------------------------
1 | # Account Abstraction
2 |
3 | ## Alchemy
4 |
5 | Leverage Alchemy's best in class account abstraction stack, [Account Kit](https://www.alchemy.com/account-kit) which lets you build embedded wallets powered by smart accounts.
6 |
7 | **Supported Networks**:
8 |
9 | * Ink Mainnet
10 | * Ink Sepolia
11 |
12 | ## Safe
13 |
14 | Access Safe’s full suite of tooling including modular smart account infrastructure and account abstraction SDK.
15 |
16 | **Supported Networks**:
17 |
18 | * [Ink Mainnet](https://app.safe.global/new-safe/create?chain=ink)
19 | * [Ink Sepolia](https://safe.optimism.io/welcome/accounts?chain=ink-sepolia)
20 |
21 | ## ZeroDev
22 |
23 | ZeroDev is a chain abstracted smart account for building user-friendly Web3 experiences. Leveraging ERC-4337, it offers you the ability to enable flexible authentication, sponsor gas and bundle transactions for users. Check out ZeroDevs [docs](https://docs.zerodev.app/) to learn more.
24 |
25 | **Supported Networks**:
26 |
27 | * Ink Mainnet
28 | * Ink Sepolia
29 |
--------------------------------------------------------------------------------
/src/pages/tools/block-explorers.mdx:
--------------------------------------------------------------------------------
1 | # Block Explorer
2 |
3 | ## Blockscout
4 |
5 | Blockscout is a universal block explorer providing detailed chain information and tools for debugging smart contracts and transactions. Visit the [Blockscout Docs](https://docs.blockscout.com/) for details.
6 |
7 | **Supported Networks**
8 |
9 | * [Ink Mainnet](https://explorer.inkonchain.com/)
10 | * [Ink Sepolia](https://explorer-sepolia.inkonchain.com/)
11 |
12 | ## OKX Explorer
13 |
14 | OKX Explorer offers streamlined onchain data access, advanced tools, and unified bridge insights across integrated chains for developers.
15 |
16 | **Supported Networks**
17 |
18 | * [Ink Mainnet](https://web3.okx.com/explorer/inkchain)
19 |
20 | ## Routescan
21 |
22 | The world’s first multichain explorer provides seamless access to +100 chains, offering a 48h Explorer setup with Full History APIs, Enhanced Charts, and powerful developer tools.
23 |
24 | **Supported Networks**
25 |
26 | * [Ink Mainnet](https://57073.routescan.io/)
27 | * [Ink Sepolia](https://sepolia.inkonscan.xyz/)
28 |
29 | ## Tenderly
30 |
31 | Tenderly's [Developer Explorer](https://docs.tenderly.co/developer-explorer?mtm_campaign=ext-docs&mtm_kwd=ink) is a multi-chain explorer offering view of your smart contract transactions, events, and logs.
32 | Rely on Explorer's integrated [Debugger](https://docs.tenderly.co/debugger?mtm_campaign=ext-docs&mtm_kwd=ink) and [Simulator UI](https://docs.tenderly.co/simulator-ui/using-simulation-ui?mtm_campaign=ext-docs&mtm_kwd=ink) to spot and solve issues in transactions and contracts. Set up critical [alerts](https://docs.tenderly.co/alerts/intro-to-alertsmtm_campaign=ext-docs&mtm_kwd=ink) on contracts to proactively respond to issues and improve security practices.
33 |
--------------------------------------------------------------------------------
/src/pages/tools/bridges.mdx:
--------------------------------------------------------------------------------
1 | import { Callout } from "nextra/components";
2 |
3 | # Bridges
4 |
5 |
6 | Use the below bridges at your own risk. Always DYOR!
7 |
8 |
9 |
10 |
11 | Transaction times vary based on network congestion and gas fees. Please ensure
12 | you have enough ETH in your wallet to cover transaction fees.
13 |
14 |
15 | ## Across
16 |
17 | Using a network of solvers, Across allows users to seamlessly bridge from L1 to L2 and back without the 7 day waiting period.
18 |
19 | **Supported Networks**
20 |
21 | - [Ink Mainnet](https://app.across.to/bridge?)
22 |
23 | ## Brid.gg
24 |
25 | Brid.gg enables you to bridge assets from L1 to L2 across the Superchain.
26 |
27 | **Supported Networks**
28 |
29 | - [Ink Mainnet](https://brid.gg/ink)
30 | - [Ink Sepolia](https://testnet.brid.gg/ink-sepolia)
31 |
32 | ## Bungee
33 |
34 | Bungee aggregates multiple bridges and DEXs to find the most cost-effective routes for swapping across chains.
35 |
36 | **Supported Networks**
37 |
38 | - [Ink Mainnet](https://bungee.exchange)
39 |
40 | ## Gelato
41 |
42 | Gelato's user friendly bridge UI allows users to bridge to Ink quickly and easily.
43 |
44 | **Supported Networks**
45 |
46 | - [Ink Mainnet](https://bridge.gelato.network/bridge/ink)
47 | - [Ink Sepolia](https://testnet-bridge.gelato.network/bridge/ink-sepolia)
48 |
49 | ## Rhino.fi
50 |
51 | Rhino.fi is a lightning fast secure bridge for seamless cross chain transactions.
52 |
53 | **Supported Networks**
54 |
55 | - [Ink Mainnet](https://app.rhino.fi/bridge?chain=ETHEREUM&token=ETH&chainOut=INK)
56 |
57 | ## Reservoir
58 |
59 | Reservoir facilitates gas minimized fast bridging through their cross chain relayer network. Check out their [Instant Bridging](https://docs.reservoir.tools/docs/instant-bridging) solution to integrate into your application.
60 |
61 |
62 | ## Superbridge
63 |
64 | Superbridge provides a seamless bridging allowing users to choose the route which best suits their bridging needs.
65 |
66 | **Supported Networks**
67 |
68 | - [Ink Mainnet](https://superbridge.app/)
69 | - [Ink Sepolia](https://testnets.superbridge.app/)
70 |
71 |
72 | ## Ink's Sepolia Bridge
73 |
74 | **Supported Networks**
75 |
76 | - [Ink Sepolia](https://inkonchain.com/bridge)
77 |
--------------------------------------------------------------------------------
/src/pages/tools/crosschain.mdx:
--------------------------------------------------------------------------------
1 | # Crosschain Infrastructure
2 |
3 | ## [LayerZero](https://docs.layerzero.network/v2/home/getting-started/what-is-layerzero)
4 |
5 | **Supported Networks**
6 |
7 | * Ink Mainnet
8 | * Ink Sepolia
9 |
10 | ## [Wormhole](https://wormhole.com/docs/)
11 |
12 | **Supported Networks**
13 |
14 | * Ink Mainnet (coming soon)
15 | * Ink Sepolia
16 |
--------------------------------------------------------------------------------
/src/pages/tools/faucets.mdx:
--------------------------------------------------------------------------------
1 | import { FaucetsContentWrapper } from '@/components/FaucetsContentWrapper'
2 |
3 |
4 |
--------------------------------------------------------------------------------
/src/pages/tools/indexers.mdx:
--------------------------------------------------------------------------------
1 | # Indexers
2 |
3 | ## [Goldsky](https://docs.goldsky.com/chains/ink)
4 |
5 | Goldsky is a high-performance data indexing provider for Ink that makes it easy to extract, transform, and load on-chain data to power both application and analytics use cases. Goldsky offers two primary approaches to indexing and accessing blockchain data: Subgraphs (high-performance subgraphs) and Mirror (real-time data replication pipelines).
6 |
7 | **Supported Networks**
8 |
9 | * Ink Mainnet
10 | * Ink Sepolia
11 |
12 | ## [Alchemy](https://www.alchemy.com/subgraphs)
13 |
14 | Alchemy provides high performance data indexing and subgraphs for Ink alongside a full stack suite of tools to help you build.
15 |
16 | **Supported Networks**
17 |
18 | * Ink Mainnet
19 |
--------------------------------------------------------------------------------
/src/pages/tools/multisig.mdx:
--------------------------------------------------------------------------------
1 | import { MultisigContentWrapper } from '@/components/MultisigContentWrapper'
2 |
3 |
--------------------------------------------------------------------------------
/src/pages/tools/oracles.mdx:
--------------------------------------------------------------------------------
1 | import CopyableCode from "@/components/CopyableCode";
2 |
3 | # Oracles
4 |
5 | ## API3
6 |
7 | API3 offers 190+ price feeds for Ink on the [API3 Market](https://market.api3.org/ink). All API3's price feeds are integrated with OEV Network to recapture protocol MEV due to oracle updates. See this [guide](https://docs.api3.org/dapps/) to learn how to integrate API3's data feeds.
8 |
9 | | Network | Contract Address |
10 | | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
11 | | Ink Mainnet | |
12 |
13 | | Network | Contract Address |
14 | | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
15 | | Ink Sepolia | |
16 |
17 |
18 | ## Chainlink
19 |
20 | **Coming Soon**
21 |
22 | ## eOracle
23 |
24 | eOracle provides decentralized price feeds through a cryptoeconomically secure oracle network, backed by staked ETH and a globally distributed network of validators.
25 |
26 | | Network | Feed | Contract Address | Decimals |
27 | | ----------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- |
28 | | Ink Mainnet | BTC/USD | | 8 |
29 | | Ink Mainnet | ETH/USD | | 8 |
30 | | Ink Mainnet | USDC/USD | | 8 |
31 | | Ink Mainnet | USDT/USD | | 8 |
32 |
33 | | Network | Feed | Contract Address | Decimals |
34 | | ----------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- |
35 | | Ink Sepolia | BTC/USD | | 8 |
36 | | Ink Sepolia | ETH/USD | | 8 |
37 | | Ink Sepolia | USDC/USD | | 8 |
38 | | Ink Sepolia | USDT/USD | | 8 |
39 |
40 |
41 |
42 | ## Pyth
43 |
44 | Pyth offers 250+ price feeds for Ink.
45 | See their [guide](https://docs.pyth.network/price-feeds/getting-started) to learn how to use Pyth feeds.
46 |
47 | | Network | Contract Address |
48 | | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
49 | | Ink Mainnet | |
50 |
51 | | Network | Contract Address |
52 | | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
53 | | Ink Sepolia | |
54 |
55 | ## Redstone
56 |
57 | Redstone provides both pull and push price feeds for Ink. See [this](https://docs.redstone.finance/docs/get-started/supported-chains/) guide to learn how to use Redstone feeds.
58 |
59 | | Network | Feed | Contract Address |
60 | | ----------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
61 | | Ink Mainnet | BTC/USD | |
62 | | Ink Mainnet | ETH/USD | |
63 | | Ink Mainnet | USDT/USD | |
64 | | Ink Mainnet | USDC/USD | |
65 | | Ink Mainnet | SOL/USD | |
66 |
67 | | Network | Feed | Contract Address |
68 | | ----------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
69 | | Ink Sepolia | BTC/USD | |
70 | | Ink Sepolia | ETH/USD | |
71 | | Ink Sepolia | USDT/USD | |
72 | | Ink Sepolia | USDC/USD | |
73 | | Ink Sepolia | SOL/USD | |
74 |
75 | ### SEDA
76 |
77 | SEDA provides custom feeds for Ink. See their [guide](https://docs.seda.xyz/home/for-developers/building-an-oracle-program) to build data feeds with SEDA. Mainnet support coming soon.
78 |
79 | | Network | Contract Name | Contract Address |
80 | | ----------- | ------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
81 | | Ink Sepolia | SEDA prover | |
82 |
--------------------------------------------------------------------------------
/src/pages/tools/rpc.mdx:
--------------------------------------------------------------------------------
1 | import { Callout } from "nextra/components";
2 | import CopyableCode from "@/components/CopyableCode";
3 |
4 | # RPC
5 |
6 | ## [Alchemy](https://www.alchemy.com/)
7 |
8 | Alchemy provides fast and reliable private RPC endpoints alongside a full suite of tools to help support your development needs.
9 |
10 | **Supported Networks**
11 | - Ink Mainnet
12 | - Ink Sepolia
13 |
14 | ## [Gelato](https://gelato.network)
15 |
16 | Gelato provides public and private RPC endpoints for Ink, along with websocket support.
17 |
18 | **Supported Networks**
19 |
20 | - Ink Mainnet
21 | - Ink Sepolia
22 |
23 | ## [QuickNode](https://www.quicknode.com)
24 |
25 | QuickNode provides public and private RPC endpoints for Ink, along with websocket support and a suite of tools to help you ship.
26 |
27 | **Supported Networks**
28 |
29 | - Ink Mainnet
30 | - Ink Sepolia
31 |
32 |
33 | Need a managed node solution?
34 | [QuickNode](https://www.quicknode.com/chains/ink) offers Ink nodes with APIs,
35 | tools, and an easy-to-use control panel.
36 |
37 |
38 | ## [Tenderly](https://tenderly.co)
39 |
40 | Tenderly provides robust RPC infrastructure with advanced debugging capabilities and comprehensive monitoring tools.
41 |
42 | **Supported Networks**
43 |
44 | - Ink Mainnet
45 | - Ink Sepolia
46 |
47 |
48 | Looking for advanced debugging tools?
49 | [Tenderly](https://tenderly.co/transaction-previews?mtm_campaign=ext-docs&mtm_kwd=ink) provides detailed transaction
50 | insights and monitoring capabilities for Ink.
51 |
52 |
53 | ## [dRPC](https://drpc.org)
54 |
55 | dRPC provides enterprise-level RPC infrastructure with globally distributed nodes, decentralized architecture and focus on privacy.
56 |
57 | **Supported Networks**
58 |
59 | - Ink Mainnet
60 | - Ink Sepolia
61 |
62 |
63 | Searching for reliable RPC infrastructure?
64 | [dRPC](https://drpc.org/chainlist/ink) works seamlessly with Ink and all Superchain networks.
65 |
66 |
67 |
68 |
69 |
70 |
71 |
72 | # Public Endpoints
73 |
74 | To connect to Ink Sepolia or Ink Mainnet, you can select from multiple RPC providers, each offering reliable infrastructure with unique features and capabilities.
75 |
76 |
77 | Interested in running your own node? Check out [our
78 | tutorial](https://github.com/inkonchain/node).
79 |
80 |
81 | ### 1. Gelato
82 |
83 | Gelato provides high-performance, globally distributed RPC endpoints with automatic failover.
84 |
85 | #### Ink Mainnet
86 |
87 | - HTTPS:
88 | - Websocket:
89 |
90 | #### Ink Sepolia
91 |
92 | - HTTPS:
93 | - Websocket:
94 |
95 | ---
96 |
97 | ### 2. Tenderly
98 |
99 | Tenderly provides robust RPC endpoints with detailed transaction debugging capabilities.
100 |
101 | #### Ink Mainnet
102 |
103 | - HTTPS:
104 | - Websocket:
105 |
106 | #### Ink Sepolia
107 |
108 | - HTTPS:
109 | - Websocket:
110 |
111 | ### 3. QuickNode
112 |
113 | QuickNode provides public and private RPC endpoints for Ink, along with websocket support and a suite of tools to help you ship.
114 |
115 | #### Ink Mainnet
116 |
117 | - HTTPS:
118 | - Websocket:
119 |
120 | #### Ink Sepolia
121 |
122 | - HTTPS:
123 | - Websocket:
124 |
125 | ### 4. dRPC
126 |
127 | dRPC provides globally distributed nodes for public and premium Ink RPC endpoints, including websocket support.
128 |
129 | #### Ink Mainnet
130 |
131 | - HTTPS:
132 | - Websocket:
133 |
134 | #### Ink Sepolia
135 |
136 | - HTTPS:
137 | - Websocket:
138 |
139 |
--------------------------------------------------------------------------------
/src/pages/tools/security.mdx:
--------------------------------------------------------------------------------
1 | # Security
2 |
3 | ## Hypernative
4 |
5 | [Hypernative](https://www.hypernative.io/) enhances security for developers building on Ink by providing real-time threat prevention, ecosystem-wide monitoring, and risk management tools. With advanced machine learning and detection models, Hypernative helps identify and mitigate risks across smart contracts, bridges, wallets, and more—giving developers the confidence to build securely. **All projects building on Ink** gain access to [Hypernative's platform](https://www.hypernative.io/solutions/protocols) for security flows, incident response, and risk analysis, ensuring resilience and reducing vulnerabilities.
6 |
7 | **Supported Networks**
8 |
9 | * Ink Mainnet
10 | * Ink Sepolia
11 |
12 | ## Tenderly
13 |
14 | [Tenderly](https://www.tenderly.co/) offers security tools to help developers build and maintain secure dapps and smart contracts.
15 |
16 | * Configure [Tenderly Alerts](https://docs.tenderly.co/alerts/intro-to-alerts?mtm_campaign=ext-docs&mtm_kwd=ink) for notifications on transactions and contract events. Use [Alerts API](https://docs.tenderly.co/alerts/api) to set up custom alerts with highly granular triggering criteria.
17 | * Use [Web3 Actions](https://docs.tenderly.co/web3-actions/intro-to-web3-actions?mtm_campaign=ext-docs&mtm_kwd=ink) to automate predefined responses, improving security and user experience.
18 | * Leverage [Simulation RPC](https://docs.tenderly.co/simulations/single-simulations#simulate-via-rpc?mtm_campaign=ext-docs&mtm_kwd=ink) to predict transaction outcomes such as asset changes, precise gas usage, and emitted events.
19 |
20 | **Supported Networks**
21 |
22 | * Ink Mainnet
23 | * Ink Sepolia
24 |
--------------------------------------------------------------------------------
/src/pages/tools/vrf.mdx:
--------------------------------------------------------------------------------
1 | # VRF
2 |
3 | ## Gelato
4 |
5 | [Gelato VRF](https://docs.gelato.network/web3-services/vrf/understanding-vrf) offers real randomness for blockchain applications by leveraging [Drand](https://drand.love/), a trusted decentralized source of random numbers. Get started [here](https://www.youtube.com/watch?v=2OzH8f3_Q9s)!
6 |
7 | **Supported Networks**
8 |
9 | * Ink Mainnet
10 | * Ink Sepolia
11 |
--------------------------------------------------------------------------------
/src/pages/useful-information/_meta.json:
--------------------------------------------------------------------------------
1 | {
2 | "contracts": "Contracts",
3 | "ink-contracts": "Ink Contracts",
4 | "ink-token-contracts": {
5 | "title": "Ink Token Contracts",
6 | "display": "hidden"
7 | },
8 | "the-superchain": "The Superchain"
9 | }
10 |
--------------------------------------------------------------------------------
/src/pages/useful-information/contracts.mdx:
--------------------------------------------------------------------------------
1 | import { Callout } from "nextra/components";
2 | import CopyableCode from "@/components/CopyableCode";
3 |
4 | # Ink Contract Addresses
5 |
6 | ### Ink L2 Contract Addresses
7 |
8 | #### Ink Mainnet
9 |
10 | | Contract Name | Contract Address |
11 | | ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
12 | | BaseFeeVault | |
13 | | EAS | |
14 | | ERC5564Announcer | |
15 | | ERC6538Registry | |
16 | | GasPriceOracle | |
17 | | L1FeeVault | |
18 | | L2CrossDomainMessenger | |
19 | | L2ERC721Bridge | |
20 | | L2StandardBridge | |
21 | | L2ToL1MessagePasser | |
22 | | OptimismMintableERC20Factory | |
23 | | OptimismMintableERC721Factory | |
24 | | ProxyAdmin | |
25 | | SchemaRegistry | |
26 | | SequencerFeeVault | |
27 | | SuperchainERC20Bridge | |
28 | | WETH9 | |
29 |
30 |
31 | These addresses are predeterministic and the same on Ink Sepolia- see
32 | [documentation](https://specs.optimism.io/protocol/predeploys.html).
33 |
34 |
35 | ### L1 Contract Addresses
36 |
37 | #### Ethereum Mainnet
38 |
39 | | Contract Name | Contract Address |
40 | | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
41 | | AddressManager | |
42 | | AnchorStateRegistry | |
43 | | DelayedWETHPermissionedGame | |
44 | | DisputeGameFactory | |
45 | | ERC5564Announcer | |
46 | | ERC6538Registry | |
47 | | L1CrossDomainMessenger | |
48 | | L1ERC721Bridge | |
49 | | L1StandardBridge | |
50 | | OptimismMintableERC20Factory | |
51 | | OptimismPortal | |
52 | | ProxyAdmin | |
53 | | SystemConfig | |
54 |
55 | #### Sepolia
56 |
57 | | Contract Name | Contract Address |
58 | | ---------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
59 | | AddressManager | |
60 | | AnchorStateRegistry | |
61 | | DelayedWETHPermissionedGame | |
62 | | DisputeGameFactory | |
63 | | ERC5564Announcer | |
64 | | ERC6538Registry | |
65 | | L1CrossDomainMessenger | |
66 | | L1ERC721Bridge | |
67 | | L1StandardBridge | |
68 | | OptimismMintableERC20Factory | |
69 | | OptimismPortal | |
70 | | ProxyAdmin | |
71 | | SystemConfig | |
72 |
73 | ### Pre Installs
74 |
75 | #### Ink Mainnet
76 |
77 | | Contract Name | Contract Address |
78 | | ----------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
79 | | Arachnid's Deterministic Deployment Proxy | |
80 | | Create2Deployer | |
81 | | CreateX | |
82 | | ERC-4337 v0.6.0 EntryPoint | |
83 | | ERC-4337 v0.6.0 SenderCreator | |
84 | | ERC-4337 v0.7.0 EntryPoint | |
85 | | ERC-4337 v0.7.0 SenderCreator | |
86 | | Multicall3 | |
87 | | MultiSend | |
88 | | MultiSendCallOnly | |
89 | | Permit2 | |
90 | | Safe | |
91 | | SafeL2 | |
92 | | SafeSingletonFactory | |
93 |
94 | For more information on these preinstalls, take a look at the [Optimism Specs](https://specs.optimism.io/protocol/preinstalls.html).
95 |
96 | #### Ink Sepolia
97 |
98 | | Contract Name | Contract Address |
99 | | ----------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
100 | | Arachnid's Deterministic Deployment Proxy | |
101 | | Create2Deployer | |
102 | | CreateX | |
103 | | ERC-4337 v0.6.0 EntryPoint | |
104 | | ERC-4337 v0.6.0 SenderCreator | |
105 | | ERC-4337 v0.7.0 EntryPoint | |
106 | | ERC-4337 v0.7.0 SenderCreator | |
107 | | Multicall3 | |
108 | | MultiSend | |
109 | | MultiSendCallOnly | |
110 | | Permit2 | |
111 | | Safe | |
112 | | SafeL2 | |
113 | | SafeSingletonFactory | |
114 |
115 | ## Contract Deployments - Instructions for Developers
116 |
117 | ###### Contract Verification
118 |
119 | Please see [how to verify contracts](/build/tutorials/verify-smart-contract).
120 |
--------------------------------------------------------------------------------
/src/pages/useful-information/ink-contracts.mdx:
--------------------------------------------------------------------------------
1 | import { Callout } from "nextra/components";
2 | import CopyableCode from "@/components/CopyableCode";
3 |
4 | # Ink Contracts
5 |
6 |
7 | This page is a work in progress. If there are missing tokens, please feel free
8 | to edit this page by submitting a PR to our
9 | [Github](https://github.com/inkonchain).
10 |
11 |
12 | | Name | Contract Address |
13 | | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
14 | | CRV | |
15 | | crvUSD | |
16 | | FPI | |
17 | | frxETH | |
18 | | frxUSD | |
19 | | FXS | |
20 | | sfrxETH | |
21 | | sfrxUSD | |
22 | | USDC.e | |
23 | | USDT0 | |
24 | | WETH9 | |
25 |
--------------------------------------------------------------------------------
/src/pages/useful-information/ink-token-contracts.mdx:
--------------------------------------------------------------------------------
1 | import { useEffect } from 'react'
2 | import { useRouter } from 'next/router'
3 |
4 | export default function Redirect() {
5 | const router = useRouter()
6 |
7 | useEffect(() => {
8 | router.replace('/useful-information/ink-contracts')
9 | }, [])
10 |
11 | return null
12 | }
--------------------------------------------------------------------------------
/src/pages/useful-information/the-superchain.mdx:
--------------------------------------------------------------------------------
1 | import { Callout } from "nextra/components";
2 |
3 | # The Superchain
4 |
5 | ## What is the Superchain?
6 |
7 | - The Optimism [Superchain](https://docs.optimism.io/stack/explainer#superchain-overview) is a network that enables shared bridging, decentralized governance, upgrades, a communication layer and more between standardized chains.
8 | - The Superchain is based on a vision of an internet that no longer requires trusted entities who have and will continue abusing that trust. However, this vision of a decentralized web requires a level of scalability that is not yet widely available.
9 | - The Superchain's mission is to achieve revolutionary scalability for blockchains.
10 |
11 | The Superchain puts forward a new architecture for multi-chain ecosystems.
12 | - New chains, when introduced, frequently have divergent security models and significant expenses associated with their rollout.
13 | - The solution is to use an L2 architecture that commoditizes new chains - enabling efficient crosschain applications without introducing systemic risk and significant setup costs. In the future, we should be able to treat many L2 chain instances as a single unit, realizing the vision of the Superchain.
14 |
15 |
16 | The end goal of the Superchain is for developers to be able to abstract away underlying chains when developing dapps.
17 |
18 |
19 | ### What defines the Superchain?
20 |
21 | The Superchain is a network of interoperable blockchains, including Ink and Optimism. The Superchain satisfies the following properties:
22 |
23 | | Property | Purpose |
24 | | :------------------------------------------- | :----------------------------------------------------------------------------------------- |
25 | | Shared L1 blockchain | Provides a total ordering of transactions across all OP Chains. |
26 | | Shared bridge for all OP Chains | Enables OP Chains to have standardized security properties. |
27 | | Cheap OP Chain deployment | Enables deploying and transacting on OP Chains without the high fees of transacting on L1. |
28 | | Configuration options for OP Chains | Enables OP Chains to configure their data availability provider, sequencer address, etc. |
29 | | Secure transactions and cross-chain messages | Enables users to safely migrate state between OP Chains. |
30 |
31 |
32 | Check out the Optimism docs on architecture: [the OP Stack](https://docs.optimism.io/stack/explainer).
33 |
34 |
35 | ## Ink and the Superchain
36 |
37 | Ink is an OP Chain (Ethereum Layer 2) which is part of the Superchain. Being part of the Superchain network means Ink can easily interface with other connected chains, promoting both interoperability and specialization while benefiting from shared security, crosschain upgrades and decentralized governance. Ink and Optimism strongly align on the ultimate mission of realizing greater freedom for all through blockchain technology.
38 |
39 | ## Developing on the Superchain
40 |
41 | You can use [Supersim](https://github.com/ethereum-optimism/supersim) to simulate the Superchain and develop apps that can be used across any chain!
42 |
43 | Supersim enables builders to:
44 |
45 | * Experiment with apps that can be accessed from any chain
46 | * Create tokens with **SuperchainERC20**, a fungible token standard for tokens that can be used across the Superchain
47 | * Simulate crosschain messaging
48 |
--------------------------------------------------------------------------------
/src/pages/work-with-ink/_meta.json:
--------------------------------------------------------------------------------
1 | {
2 | "community": {
3 | "title": "Community"
4 | },
5 | "contributing": {
6 | "title": "Contribution Guide"
7 | }
8 | }
--------------------------------------------------------------------------------
/src/pages/work-with-ink/brand-kit.mdx:
--------------------------------------------------------------------------------
1 | ---
2 | title: Brand Kit
3 | description: The core essence of the Ink branding, featuring logos, colors, typefaces, illustrations, and best practices
4 | ---
5 |
6 | import Image from "next/image";
7 | import { DownloadButton } from "@/components/DownloadButton";
8 | import { DownloadIcon } from "@/icons/Download";
9 |
10 | # Brand Kit
11 |
12 |
13 |
20 |
21 |
22 | This brand kit includes the core essence of the Ink branding, featuring logos, colors, typefaces, illustrations, and best practices. It should help any and all creative work.
23 |
24 |
25 |
31 |
32 |
33 | ## Logo
34 |
35 | The Ink logo consists of a symbol and a word mark.
36 | Wherever possible, the horizontal full logo should be used.
37 |
38 |
39 |
45 |
46 |
47 | ### Logo System
48 |
49 |
50 |
51 |
52 |
60 | Full Ink logo
61 |
62 |
63 |
71 | Ink chain mark
72 |
73 |
74 |
75 |
76 |
84 | Safe margin
85 |
86 |
87 |
95 | Safe margin
96 |
97 |
98 |
99 |
100 | ### Logo Extensions
101 |
102 |
103 |
104 |
105 |
113 | With Kraken
114 |
115 |
116 |
124 | With other marks
125 |
126 |
127 |
128 |
136 | Partnerships
137 |
138 |
139 |
140 | ## Color
141 |
142 | Ink purple should be used whenever possible.
143 | Backgrounds typically use gradients.
144 |
145 |
146 |
154 |
155 |
156 | ## Typography
157 |
158 | Ink uses the open source typeface Plus Jakarta Sans.
159 | Lurus Alternatives are used in most cases.
160 |
161 |