Publish on chain using CosmWasm

Pre-requisite

At this stage, we assume that you followed the steps at ReactJs.

We will be using Keplr (opens in a new tab) as a wallet to interact with the frontend interface. Make sure that you have it installed and funded via Archway-Testnet Faucet Channel (opens in a new tab).

Also, we use Wamskit (opens in a new tab) for compiling and deploying the cosmwasm contracts.

It is automatically installed when installing npm modules.

You can access the code of this walkthrough on Gitlab:

Contract deployment

Clone the client contract repo.

This Archway contract (opens in a new tab) serves as a client to our Reclaim contract. It takes Reclaim's contract address, handles proofs, and verifies them.

git clone https://gitlab.reclaimprotocol.org/starterpacks/reclaim-cosmwasm-wasmkit-client.git
cd reclaim-archway-client
wasmkit compile

Add your wallet information.

As stated in the README, add your wallet credentials to your wasmkit.config.js as specified in wasmkit.config.js.example.

const archway_testnet_accounts = [
  {
    name: 'account_0',
    address: '', // your archway address
    mnemonic: ''// your mnemonic key
  },
];
 
const archway_mainnet_accounts = [
  {
    name: 'account_0',
    address: '', // your archway address
    mnemonic: ''// your mnemonic key
  },
];

Deploy and verify a proof.

Take a look at wasmkit.config.js and all.ts, make sure that you have the correct RPCs and contract addresses.

If you want to deploy to mainnet, search for the Uncomment for mainnet comment.

By running wasmkit run scripts/all.ts, you can upload the contract, instantiate it, and verify a Reclaim proof on it. Run the script and take a note of your contract address, we will be using them later.

npm i
wasmkit run scripts/all.ts

Here is an example of how your output should look like:

storeCode instantiate&verify

React client development

Bootstrap project and install packages.

Add the following to project dependency(packages.json) and install modules.

"dependencies": {
    "@cosmjs/stargate": "^0.32.0",
    "@cosmjs/proto-signing": "^0.32.0",
    "@cosmjs/crypto": "^0.32.0",
    "@cosmjs/encoding": "^0.32.0",
    "@cosmjs/math": "^0.32.0",
    "@cosmjs/cosmwasm-stargate": "^0.32.0",
    "@reclaimprotocol/js-sdk": "^0.1.5",
    "react-qr-code": "^2.0.12",
    ...
}

npm i

Setup your React codebase.

We will continue building on the reclaim react client (opens in a new tab), new lines are highlighted below.

import "./App.css";
import { Reclaim } from "@reclaimprotocol/js-sdk";
import { useState } from "react";
import QRCode from "react-qr-code";
 
function App() {
  const [url, setUrl] = useState("");
  const [ready, setReady] = useState(false);
  const [proof, setProof] = useState({});
 
  const reclaimClient = new Reclaim.ProofRequest("YOUR_APPLICATION_ID_HERE"); //TODO: replace with your applicationId
 
  async function generateVerificationRequest() {
    const providerId = "PROVIDER_ID"; //TODO: replace with your provider ids you had selected while creating the application
 
    reclaimClient.addContext(
      `user's address`,
      "for acmecorp.com on 1st january"
    );
 
    await reclaimClient.buildProofRequest(providerId);
 
    reclaimClient.setSignature(
      await reclaimClient.generateSignature(
        APP_SECRET //TODO : replace with your APP_SECRET
      )
    );
 
    const { requestUrl, statusUrl } =
      await reclaimClient.createVerificationRequest();
 
    setUrl(requestUrl);
 
    await reclaimClient.startSession({
      onSuccessCallback: (proofs) => {
        console.log("Verification success", proofs);
        setReady(true);
        setProof(proofs[0]);
        // Your business logic here
      },
      onFailureCallback: (error) => {
        console.error("Verification failed", error);
        // Your business logic here to handle the error
      },
    });
  }
 
  return (
    <div className="App">
      <div
        style={{
          display: "flex",
          alignItems: "center",
          justifyContent: "center",
          height: "50vh",
        }}
      >
        {!url && (
          <button onClick={generateVerificationRequest}>
            Create Claim QrCode
          </button>
        )}
        {url && <QRCode value={url} />}
      </div>
    </div>
  );
}
 
export default App;

Create a new folder (utilities).

Structure the folder as per the following, these are configs to call Reclaim on Archway.

src/
 |- utilities/ArchwayContext.js
 |- utilities/ArchwayFunctions.js
 |- App.js

Copy this to ArchwayContext.js.

By default, the values below are for ArchwayContext's testnet, uncomment for mainnet.

import { createContext, useState } from "react";
import { SigningCosmWasmClient } from "@cosmjs/cosmwasm-stargate";
const ArchwayContext = createContext(null);
 
const ARCHWAY_CHAIN_ID = 'constantine-3';
const ARCHWAY_LCD = 'https://rpc.constantine.archway.tech';
 
// Uncomment for Mainnet
// const ARCHWAY_CHAIN_ID = 'archway-1';
// const ARCHWAY_LCD = 'https://rpc.mainnet.archway.io';
 
const ArchwayContextProvider = ({ children }) => {
  const [archwayClient, setArchwayClient] = useState(null);
  const [archwayAddress, setArchwayAddress] = useState("");
 
  async function setupKeplr() {
    const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
    while (
      !window.keplr ||
      !window.getEnigmaUtils ||
      !window.getOfflineSignerOnlyAmino
    ) {
      await sleep(50);
    }
 
    await window.keplr.enable(ARCHWAY_CHAIN_ID);
    window.keplr.defaultOptions = {
      sign: {
        preferNoSetFee: false,
        disableBalanceCheck: true,
      },
    };
 
    const keplrOfflineSigner =
      window.getOfflineSignerOnlyAmino(ARCHWAY_CHAIN_ID);
    const accounts = await keplrOfflineSigner.getAccounts();
 
    console.log(accounts[0].address);
    const archwayAddress = accounts[0].address;
 
    const archwayClient = await SigningCosmWasmClient.connectWithSigner(ARCHWAY_LCD, keplrOfflineSigner);
 
    setArchwayAddress(archwayAddress);
    setArchwayClient(archwayClient);
  }
 
  async function connectWallet() {
    console.log(1);
    try {
      if (!window.keplr) {
        console.log("intall keplr!");
      } else {
        await setupKeplr();
        localStorage.setItem("keplrAutoConnect", "true");
      }
    } catch (error) {
      alert(
        "An error occurred while connecting to the wallet. Please try again."
      );
    }
  }
 
  function disconnectWallet() {
    // reset archwayClient and archwayAddress
    setArchwayAddress("");
    setArchwayClient(null);
 
    // disable auto connect
    localStorage.setItem("keplrAutoConnect", "false");
 
    // console.log for success
    console.log("Wallet disconnected!");
  }
 
  async function addArchwayToKeplr () {
        try {
          if (!window.keplr) {
            alert("Intall keplr!");
          } else {
 
            const chainConfig = {
              "bech32Config": {
                "bech32PrefixAccAddr": "archway",
                "bech32PrefixAccPub": "archwaypub",
                "bech32PrefixConsAddr": "archwayvalcons",
                "bech32PrefixConsPub": "archwayvalconspub",
                "bech32PrefixValAddr": "archwayvaloper",
                "bech32PrefixValPub": "archwayvaloperpub"
              },
              "bip44": {
                "coinType": 118
              },
              "chainId": "constantine-3",
              "chainName": "Archway (Testnet)",
              "chainSymbolImageUrl": "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/constantine/chain.png",
              "currencies": [
                {
                  "coinDecimals": 18,
                  "coinDenom": "CONST",
                  "coinMinimalDenom": "aconst"
                }
              ],
              "features": ["cosmwasm"],
              "feeCurrencies": [
                {
                  "coinDecimals": 18,
                  "coinDenom": "CONST",
                  "coinMinimalDenom": "aconst",
                  "gasPriceStep": {
                    "low": 140000000000,
                    "average": 196000000000,
                    "high": 225400000000
                  }
                }
              ],
              "rest": "https://api.constantine.archway.tech",
              "rpc": "https://rpc.constantine.archway.tech",
              "stakeCurrency": {
                "coinDecimals": 18,
                "coinDenom": "CONST",
                "coinMinimalDenom": "aconst"
              },
              "nodeProvider": {
                "name": "Phi Labs",
                "email": "support@philabs.xyz",
                "website":"https://philabs.xyz"
              }
            }
            //Uncomment for Mainnet
            
            // const chainConfig = {
            //   "bech32Config": {
            //     "bech32PrefixAccAddr": "archway",
            //     "bech32PrefixAccPub": "archwaypub",
            //     "bech32PrefixConsAddr": "archwayvalcons",
            //     "bech32PrefixConsPub": "archwayvalconspub",
            //     "bech32PrefixValAddr": "archwayvaloper",
            //     "bech32PrefixValPub": "archwayvaloperpub"
            //   },
            //   "bip44": {
            //     "coinType": 118
            //   },
            //   "chainId": "archway-1",
            //   "chainName": "Archway",
            //   "chainSymbolImageUrl": "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/archway/chain.png",
            //   "currencies": [
            //     {
            //       "coinDecimals": 18,
            //       "coinDenom": "ARCH",
            //       "coinGeckoId": "archway",
            //       "coinMinimalDenom": "aarch",
            //       "coinImageUrl": "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/archway/aarch.png"
            //     }
            //   ],
            //   "features": ["cosmwasm"],
            //   "feeCurrencies": [
            //     {
            //       "coinDecimals": 18,
            //       "coinDenom": "ARCH",
            //       "coinGeckoId": "archway",
            //       "coinMinimalDenom": "aarch",
            //       "gasPriceStep": {
            //         "low": 140000000000,
            //         "average": 196000000000,
            //         "high": 225400000000
            //       },
            //       "coinImageUrl": "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/archway/aarch.png"
            //     }
            //   ],
            //   "rest": "https://api.mainnet.archway.io",
            //   "rpc": "https://rpc.mainnet.archway.io",
            //   "stakeCurrency": {
            //     "coinDecimals": 18,
            //     "coinDenom": "ARCH",
            //     "coinGeckoId": "archway",
            //     "coinMinimalDenom": "aarch",
            //     "coinImageUrl": "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/main/images/archway/aarch.png"
            //   },
            //   "nodeProvider": {
            //     "name": "Phi Labs",
            //     "email": "support@philabs.xyz",
            //     "website":"https://philabs.xyz"
            //   }
            // }
          await window.keplr.experimentalSuggestChain(chainConfig);
      }
    } catch (error) {
      alert(
        "An error occurred while connecting to the wallet. Please try again."
      );
    }
  }
 
  return (
    <ArchwayContext.Provider
      value={{
        archwayClient,
        setArchwayClient,
        archwayAddress,
        setArchwayAddress,
        connectWallet,
        disconnectWallet,
        addArchwayToKeplr
      }}
    >
      {children}
    </ArchwayContext.Provider>
  );
};
 
export { ArchwayContext, ArchwayContextProvider };

Copy this to ArchwayFunctions.js.

Replace with your contract address. You can leave values as are if you did not do the deployment step, make sure to uncomment values for mainnet.

import { useContext } from "react";
import { ArchwayContext } from "./ArchwayContext";
import { calculateFee, GasPrice } from "@cosmjs/stargate";
 
let contractAddress = "archway1sqmc9q79fz50tvxul4c8r8k7dg9jagv5cxawqagkp84wq6hh32rqckhu92";
 
// Uncomment for mainnet
// let contractAddress = "archway19z8n74lcxz5gp0j4s20dfnmq30954k8cagjj53jrutqe2etlph3q87svth";
 
const ArchwayFunctions = () => {
  const { archwayClient, archwayAddress } = useContext(ArchwayContext);
 
  let verify_proof = async (proof) => {
    const defaultGasPrice = GasPrice.fromString("140000000000aarch");
    const defaultExecuteFee = calculateFee(300_000, defaultGasPrice);
 
    console.log(proof);
    const result = await archwayClient.execute(
      archwayAddress, 
      contractAddress,
      {
        verify_proof: {
          proof: proof
        }
      },
      defaultExecuteFee
    );
    console.log(result);
  }
 
  return {
    verify_proof
  };
};
 
export { ArchwayFunctions };

Wrap the App with the specified Archway context (index.js).

import { ArchwayContextProvider } from "./utilities/ArchwayContext";
 
const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(
  <ArchwayContextProvider>
    <App />
  </ArchwayContextProvider>
);

Create a VerifyProof component.

src/
 |- utilities/ArchwayContext.js
 |- utilities/ArchwayFunctions.js
 |- VerifyProof.jsx
 |- App.js

Include the VerifyProof() function.

import { useState, useEffect } from "react";
import { Reclaim } from "@reclaimprotocol/js-sdk";
import { ArchwayFunctions } from "./utilities/ArchwayFunctions";
 
export default function VerifyProof(props) {
  const [proof, setProof] = useState({});
  const [verified, setVerified] = useState(false);
  const { verify_proof } = ArchwayFunctions();
 
  useEffect(() => {
    const newProof = Reclaim.transformForOnchain(props.proof);
    setProof(newProof);
  }, []);
 
  return (
    <div>
      <button
        className="button"
        onClick={async () => {
          try {
            console.log(proof);
            await verify_proof(proof);
            setVerified(true);
          } catch (e) {
            console.error(e);
          }
        }}
      >
        Verify Proof
      </button>
      {verified && <p> Proof verified </p>}
      <style jsx="true">{`
        .container {
          display: flex;
          flex-direction: column;
          align-items: center;
          justify-content: center;
        }
        .button {
          border: solid 1px #ccc;
          margin: 0 0 20px;
          border-radius: 3px;
        }
      `}</style>
    </div>
  );
}

Create a ConnectButton component.

|- utilities/ArchwayContext.js
|- utilities/ArchwayFunctions.js
|- VerifyProof.jsx
|- ConnectButton.jsx
|- App.js

Add a button and placeholder for connecting.

import { useContext } from "react";
import { ArchwayContext } from "./utilities/ArchwayContext";
 
export default function ConnectButton () {
    const { archwayAddress, connectWallet, addArchwayToKeplr } = useContext(ArchwayContext);
  
    return (
        <div>Archway
        <div>
          <button className="button" onClick={addArchwayToKeplr}>
            Add Archway to Keplr
          </button>
          <hr/>
          <button className="button" onClick={connectWallet}>
            Connect Keplr
          </button>
        </div>
        <h2>
          {archwayAddress
            ? archwayAddress.slice(0, 10) + "...." + archwayAddress.slice(41, 45)
            : "Please connect wallet"}
        </h2>
      </div>
    )
}

Bringing it all together (App.js).

We will submit the proof on chain once we get the success callback. New lines are highlighted.

import "./App.css";
import { Reclaim } from "@reclaimprotocol/js-sdk";
 import { useState } from "react";
import QRCode from "react-qr-code";
import VerifyProof from "./VerifyProof";
import ConnectButton from "./ConnectButton";
 
function App() {
  const [url, setUrl] = useState("");
  const [ready, setReady] = useState(false);
  const [proof, setProof] = useState({});
 
 
  const reclaimClient = new Reclaim.ProofRequest("YOUR_APPLICATION_ID_HERE"); //TODO: replace with your applicationId
 
  async function generateVerificationRequest() {
    const providerId = "PROVIDER_ID"; //TODO: replace with your provider ids you had selected while creating the application
 
    reclaimClient.addContext(
      `user's address`,
      "for acmecorp.com on 1st january"
    );
 
    await reclaimClient.buildProofRequest(providerId);
 
    reclaimClient.setSignature(
      await reclaimClient.generateSignature(
        APP_SECRET //TODO : replace with your APP_SECRET
      )
    );
 
    const { requestUrl, statusUrl } =
      await reclaimClient.createVerificationRequest();
 
    setUrl(requestUrl);
 
    await reclaimClient.startSession({
      onSuccessCallback: (proofs) => {
        console.log("Verification success", proofs);
        setReady(true);
        setProof(proofs[0]);
        // Your business logic here
      },
      onFailureCallback: (error) => {
        console.error("Verification failed", error);
        // Your business logic here to handle the error
      },
    });
  }
 
  return (
    <div className="App">
      <ConnectButton />
      <div
        style={{
          display: "flex",
          alignItems: "center",
          justifyContent: "center",
          height: "50vh",
        }}
      >
        {!url && (
          <button onClick={generateVerificationRequest}>
            Create Claim QrCode
          </button>
        )}
        {url && <QRCode value={url} />}
      </div>
      {ready && <VerifyProof proof={proof}></VerifyProof>}
    </div>
  );
}
 
export default App;

Submitting the proof

npm run build
 
npm run start

After requesting a proof from Reclaim and performing the verification on your end, a verify proof button will appear on the screen. Make sure your Keplr is connected, click the button, a wallet pop-up will show prompting you to submit.

screen1

keplr1

Now your proof will get approved on-chain, here is the sample transaction (opens in a new tab) from the screenshot above.

Neutron Neutron-Terra(IBC)