How to create an ERC-7738 Registry entry

A guide on how you can make your existing token “smart”

The 7738 registry contract sits at the same address on many chains, including L2’s, sidechains and testnets.

The fixed address on all implemented chains for the 7738 registry contract is 0x0077380bCDb2717C9640e892B9d5Ee02Bb5e0682

Implement via the viewer

1. Identify the contract address and chainId of your existing token. For this example we will use this test NFT:

Chain: Holesky/17000 Address: 0x15198624624587177c57a53e97322a5962b91ebd

Note that this NFT features the following public mint function:

function mint() public {
  _safeMint(msg.sender, _tokenId);
  _tokenId++;
}

2. Create your TokenScript ready for deployment. In this case we will use this simple TokenScript, which features a single mint onboarding funtion call.

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<ts:token xmlns:ts="http://tokenscript.org/2024/01/tokenscript"
      xmlns:xml="http://www.w3.org/XML/1998/namespace"
      xsi:schemaLocation="http://tokenscript.org/2024/01/tokenscript https://www.tokenscript.org/schemas/2024-01/tokenscript.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:ethereum="urn:ethereum:constantinople"
      name="ERC7738">
    <ts:label>
        <ts:plurals xml:lang="en">
            <ts:string quantity="one">
                Singapore Catapult 7738 Token
            </ts:string>
            <ts:string quantity="other">
                Singapore Catapult 7738 Tokens
            </ts:string>
        </ts:plurals>
    </ts:label>
    <ts:contract interface="erc721" name="ThisToken">
        <ts:address network="17000">0x15198624624587177c57a53e97322a5962b91ebd</ts:address>
    </ts:contract>
    <ts:origins>
        <ts:ethereum contract="ThisToken"/>
    </ts:origins>
    <ts:cards>
        <ts:card type="onboarding" name="purchase" buttonClass="primary">
            <ts:label>
                <ts:string xml:lang="en">
                    Mint
                </ts:string>
            </ts:label>
            <ts:transaction>
                <ethereum:transaction function="mint" contract="ThisToken">
                    <ts:data/>
                </ethereum:transaction>
            </ts:transaction>
            <ts:view xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
                <p>This is an onboarding card for Singapore Catapult token</p>
                <br/>
                <p>Use this to mint your own tokens.</p>
            </ts:view>
        </ts:card>
    </ts:cards>
</ts:token>

3. Upload to IPFS. In the case of the above script it uploads with the hash: ipfs://QmPZc6mGSysNukJpkEb8wkvp1SX3CuXRyzNpQTMd4Jciou

4. Now open the 7738 registry tokenscript, which is located on all supported chains at this address: 0x0077380bCDb2717C9640e892B9d5Ee02Bb5e0682 For Holesky: Registry 7738 Script

Create the registry entry by clicking on the set ScriptURI button.

Fill in the contract address and scriptURI appropriately for your token:

And push the transaction using your wallet. The tokenscript calls this function in the registry:

function setScriptURI(
        address contractAddress,
        string[] memory newScriptURIs
    ) external

If the wallet you use to push this setScriptURI function is the same as the owner() of the target contract (in this case the NFT) then the entry is treated as provisionally approved. If the script is stored on IPFS OR the script is signed by the owner() then the script will be shown as authenticated.

For each scriptURI link that is created, an NFT will be minted to the creation wallet. Relevant Metadata can be set by the owner of that NFT (using the Registry TokenScript, ethers.js or etherscan call etc). Once passed to another address, the NFT still retains its authentication, which creates a delegate authenticator.

List of all 7738 cards:

• Mainnet
• Base Mainnet
• Kaia
• Polygon
• Mint
• Arbitrum
• OP Mainnet

Testnets

• Holesky
• Sepolia
• Kairos
• Base Sepolia
• Polygon Amoy
• Mantle Sepolia
• Mint Sepolia

Implement via ethers.js

In your HardHat environment, you can deploy your contract and set the script registry in one step. In this sample we assume that you pre-calculated the deployment address and have already uploaded your TokenScript. In an all-in-one deployment you would include an IPFS API key, set the contract address in the script after contract deployment, upload then set the scriptURI entry.

import dotenv from "dotenv";
const { ethers, upgrades, hre } = require("hardhat");
const { getContractAddress } = require('@ethersproject/address')
dotenv.config();

const registryAddress = '0x0077380bCDb2717C9640e892B9d5Ee02Bb5e0682';
const deployedNFTAddress = '0x15198624624587177c57a53e97322a5962b91ebd';   //Your NFT/ERC20 address
const scriptURI = 'ipfs://QmPZc6mGSysNukJpkEb8wkvp1SX3CuXRyzNpQTMd4Jciou'; //Yor script URI

// Helper script to re-assign ownership of ENS domain to the registry contract
async function main() {
    const privateKey: any = process.env.PRIVATE_KEY;
    if (!privateKey) {
        throw new Error("PRIVATE_KEY not found in .env file");
    }

    const deployKey = new ethers.Wallet(privateKey, ethers.provider);

    // Interface of the ERC-7738 Registry contract
    const registryAbi = [
        "function setScriptURI(address contractAddress, string[] memory newScriptURIs)",
        "function setName(uint256 tokenId, string memory name)",
        "function setIcon(uint256 tokenId, string memory iconURI)",
        "function scriptURI(address contractAddress) view returns (string[])"
    ];

    const registry = new ethers.Contract(registryAddress, registryAbi, deployKey);

    //register the scripURI
    await registry.setScriptURI(deployedNFTAddress, [scriptURI]);

    const nftAbi = [
      "balanceOf(address owner)",
      "tokenOfOwnerByIndex(address owner, uint256 index)"
    ];

    const nft = new ethers.Contract(deployedNFTAddress, nftAbi, deployKey);

    //find the last tokenId created
    const balance = await nft.balanceOf(deployKey.address);
    if (balance === 0) {
      throw new Error("No NFTs found in this wallet");
    }
    const lastNFTIndex = balance - 1;
    const lastNFTId = await nft.tokenOfOwnerByIndex(lastNFTIndex);

    //write the new name
    await registry.setName(lastNFTId, "MyToken Script");

    //Pull and dump the token metadata
    let metaData = await registry.tokenURI(lastNFTId);

    let metaDataJSON = JSON.parse(metaData);

    console.log(`New name: ${metaDataJSON.name}`);
    console.log(`ScriptURI: ${JSON.stringify(await registry.scriptURI(deployedNFTAddress))}`);
}

main()
    .then(() => process.exit(0))
    .catch((error) => {
        console.error(error);
        process.exit(1);
    });

implement via Etherscan:

Use the Etherscan contract interface:

Etherscan mainnet contract interact

Use the setScriptURI eg:

Note that the newScriptURIs input field is an array, so you need to use the array format ["<YOUR URL>"].