SDI for dapp developers
This page describes how to interact with the x/compliance module in order to get relevant information about the verified users and issuers.
If you need help on how to get your contract verified as an issuer and start verifying users, you can read check this section: https://swisstronik.gitbook.io/swisstronik-docs/development/swisstronik-cli/for-sdi-issuers
Examples of how to interact with Swisstronik smart contracts using different frontend libraries is available here: https://github.com/SigmaGmbH/swisstronik-dapp-template
Interacting with the x/compliance module using the SwisstronikJS SDK
You'll need to install @swisstronik/sdk npm package
import { SwisstronikStargateClient } from "@swisstronik/sdk";
const client = await SwisstronikStargateClient.connect(
"https://rpc.testnet.swisstronik.com"
);Getting address details
It returns details for a verified address in the x/compliance module. You can use this method for both verified issuers and verified users.
const address = "swtr...";
const addressDetails = await client.queryAddressDetails(address);The result contains information about whether the address is verified as an issuer or not, array of issuers verifications or if the verification has been revoked. Please, note that if the user address is verified by an issuer, the isVerified attribute will be false since it's true just for verified issuers. If the user is verified by an issuer, the verification array will contain elements such as the verification Id, verification type and issuer address.
Getting Issuer details
It returns issuer details by its address (name, description, url, logo and legal entity).
const issuerAddress = "swtr...";
const issuerDetails = await client.queryIssuerDetails(issuerAddress);Getting verification details
It returns verification details by its Id (verification type, expiration timestamp, issuance timestamp, issuer address, etc.).
const verificationID = "AKsIPk2b...";
const verificationDetails = await client.queryVerificationDetails(verificationID);Getting verified address list
It returns the list of verified addresses details for both users and issuers.
const addressList = await client.queryAddressList();Getting Issuer list
It returns the list of Issuer details.
const issuerList = await client.queryIssuerList();Getting verification details list
It returns the list of Verification details.
const verificationList = await client.queryVerificationList();Working demo on https://sigmagmbh.github.io/swisstronik-issuer-registry-frontend/
Interacting with the x/compliance module using Solidity
In order to get relevant x/compliance information, there's a contract deployed and ready to be used called SWTRProxy. Its code and latest address is deployed available on https://github.com/SigmaGmbH/swisstronik-sdi-contracts.
For interacting with the SWTRProxy contract in your solidity contract, you can install the @swisstronik/sdi-contracts npm package and use the ISWTRProxy interface in your contract.
How to import and initialize the SWTRProxy
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.24;
import {ISWTRProxy} from "@swisstronik/sdi-contracts/contracts/interfaces/ISWTRProxy.sol";
contract Sample {
ISWTRProxy public swtrProxy;
constructor(ISWTRProxy _swtrProxy) { swtrProxy = _swtrProxy; }
}
From there you can call any function available in the ISWTRProxy interface
Getting list of verified Issuers
uint256 totalIssuers = swtrProxy.issuerRecordCount();
ISWTRProxy.Issuer[] memory issuers;
if(totalIssuers > 0) {
issuers = swtrProxy.listIssuersRecord(0, totalIssuers); //pagination
}It'll return issuers name, address, and version.
Get issuer by address
ISWTRProxy.Issuer memory issuer = swtrProxy.getIssuerRecordByAddress(0x123..);Get Issuer Addresses by name and versions
There may be multiple versions/addresses for the same issuer name
uint32[] memory versions; //add your versions
address[] memory issuerAddresses = swtrProxy.getIssuerAddressesByNameAndVersions("Quadrata", versions);The addresses are sorted in the same order the versions are passed.
Checking if an user is verified with a specific verification type by any issuer
bool isVerified = swtrProxy.isUserVerified(
0x123.., //user address
ISWTRProxy.VerificationType.VT_KYC
);Checking if an user is verified with a specific verification type by specific issuers
address[] memory allowedIssuers; //add your issuers address
bool isVerifiedByIssuers = swtrProxy.isUserVerifiedBy(
0x123.., //user address
ISWTRProxy.VerificationType.VT_KYC,
allowedIssuers
);Getting verification details
bytes memory verificationId; // add your verification id
ISWTRProxy.VerificationData memory verificationDetails = swtrProxy.getVerificationDataById(
0x123, // user address
0x456, // issuer address
verificationId
);Getting verification details list
ISWTRProxy.VerificationData[] memory verificationList = swtrProxy.listVerificationData(
0x123, // user address
0x456, // issuer address
);
Checking if user has a specific verification type
bool passed = swtrProxy.passedVerificationType(
0x123, // user address
0x456, // issuer address
ISWTRProxy.VerificationType.VT_HUMANITY // verification type
);You can find the list of available functions here: https://github.com/SigmaGmbH/swisstronik-sdi-contracts
Solidity Examples
Getting an image url ONLY IF the user is has a specific verification type issued by a specific issuer
In this example only users with the VT_HUMANITY verification type issued by the specified issuer are able to view the image set by the owner. Note due to the Intel SGX, there's no other way to view the image.
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.24;
import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ISWTRProxy} from "@swisstronik/sdi-contracts/contracts/interfaces/ISWTRProxy.sol";
enum AdapterType {
Quadrata,
WorldCoin
}
contract Sample is Ownable, EIP712 {
string internal imageUrl; // Thanks to Intel SGX encryption, there's no way to know the value of this variable by checking the storage slot
ISWTRProxy public swtrProxy;
constructor(
ISWTRProxy _swtrProxy
) EIP712("Sample Dapp", "1") Ownable(msg.sender) {
swtrProxy = _swtrProxy;
}
function setImageUrl(string memory _imageUrl) public onlyOwner {
imageUrl = _imageUrl;
}
function getImageUrl(
bytes calldata signature
) public view returns (string memory) {
require(bytes(imageUrl).length > 0, "Image URL not set");
address userAddress = recoverSigner(signature);
uint32[] memory versions = new uint32[](1);
versions[0] = 1;
address[] memory allowedIssuers = swtrProxy.getIssuerAddressesByNameAndVersions(
"Worldcoin",
versions
);
bool isVerified = swtrProxy.isUserVerifiedBy(
userAddress,
ISWTRProxy.VerificationType.VT_HUMANITY,
allowedIssuers
);
require(isVerified, "User not verified");
return imageUrl;
}
function recoverSigner(
bytes calldata signature
) public view returns (address) {
bytes32 structHash = keccak256(
abi.encode(
keccak256("Obj(string contents)"),
keccak256("Sample Verification")
)
);
bytes32 digest = _hashTypedDataV4(structHash);
return ECDSA.recover(digest, signature);
}
}Getting decoded original data of the verification by user address
In thes example, we get the decoded original data of the user verification
function decodeQuadrataPassportV1OriginalData(
address userAddress
)
public
view
returns (
uint8 aml,
string memory country,
string memory did,
bool isBusiness,
bool investorStatus
)
{
uint32[] memory versions = new uint32[](1);
versions[0] = 1;
address issuerAddress = swtrProxy.getIssuerAddressesByNameAndVersions(
"Quadrata",
versions
)[0];
ISWTRProxy.VerificationData[] memory verificationList = swtrProxy
.listVerificationData(userAddress, issuerAddress);
require(verificationList.length > 0, "No verification data found");
(aml, country, did, isBusiness, investorStatus) = swtrProxy
.decodeQuadrataPassportV1OriginalData(
verificationList[0].originalData
);
}
function decodeWorldcoinV1OriginalData(
address userAddress
)
public
view
returns (
string memory merkle_root,
string memory nullifier_hash,
string memory proof,
string memory verification_level
)
{
uint32[] memory versions = new uint32[](1);
versions[0] = 1;
address issuerAddress = swtrProxy.getIssuerAddressesByNameAndVersions(
"Worldcoin",
versions
)[0];
ISWTRProxy.VerificationData[] memory verificationList = swtrProxy
.listVerificationData(userAddress, issuerAddress);
require(verificationList.length > 0, "No verification data found");
(
merkle_root,
nullifier_hash,
proof,
verification_level
) = swtrProxy.decodeWorldcoinV1OriginalData(
verificationList[0].originalData
);
}Typescript examples
Using web3.js and Swisstronik plugin order to check if an user has a specific verification type issued by a specific issuer
You'll need to install the plugin with npm i @swisstronik/web3-plugin-swisstronik
import { SwisstronikPlugin } from "@swisstronik/web3-plugin-swisstronik";
import { verificationTypes } from "@swisstronik/sdk/compliance/verificationDetails";
import { Web3 } from "web3";
const web3 = new Web3(walletProvider);
web3.registerPlugin(new SwisstronikPlugin("https://json-rpc.testnet.swisstronik.com"));
const contract = new web3.eth.Contract(ABI, CONTRACT_ADDRESS); // SWTRProxy ABI and Contract address
const verificationType = "VT_HUMANITY";
const issuerAddress = (
await contract
.methods
.getIssuerAddressesByNameAndVersions("Quadrata", [1])
.call()
) as string[][0];
const isVerified: boolean = contract.methods.isUserVerifiedBy(
"0x123", //user address,
verificationTypes.indexOf(verificationType), //enum
issuerAddress
).call();
console.log(isVerified);Getting decoded original data of the verification by user address
const decodeQuadrataPassportV1OriginalData = async (userAddress: string) => {
const addressDetails = await client?.queryAddressDetails(userAddress);
const verificationsList = addressDetails?.verifications;
const issuerAddress = (await contract.methods
.getIssuerAddressesByNameAndVersions("Quadrata", [1])
.call()) as string[][0];
const verificationId = verificationsList?.find(
(v) => v.issuerAddress === issuerAddress
)?.verificationId;
const verificationDetails = await client?.queryVerificationDetails(
verificationId!
);
// eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain
const originalData = "0x"+Buffer.from(verificationDetails?.originalData!,
"base64"
).toString("hex");
const { aml, country, did, isBusiness, investorStatus } =
web3.eth.abi.decodeParameters(
[
{
name: "aml",
type: "uint8",
},
{
name: "country",
type: "string",
},
{
name: "did",
type: "string",
},
{
name: "isBusiness",
type: "bool",
},
{
name: "investorStatus",
type: "bool",
},
],
originalData
);
};
const decodeWorldcoinV1OriginalData = async (userAddress: string) => {
const addressDetails = await client?.queryAddressDetails(userAddress);
const verificationsList = addressDetails?.verifications;
const issuerAddress = (await contract.methods
.getIssuerAddressesByNameAndVersions("Worldcoin", [1])
.call()) as string[][0];
const verificationId = verificationsList?.find(
(v) => v.issuerAddress === issuerAddress
)?.verificationId;
const verificationDetails = await client?.queryVerificationDetails(
verificationId!
);
// eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain
const originalData = "0x"+Buffer.from(verificationDetails?.originalData!,
"base64"
).toString("hex");
const { merkle_root, nullifier_hash, proof, verification_level } =
web3.eth.abi.decodeParameters(
[
{
name: "merkle_root",
type: "string",
},
{
name: "nullifier_hash",
type: "string",
},
{
name: "proof",
type: "string",
},
{
name: "verification_level",
type: "string",
},
],
originalData
);
};Note that via the SDK the addresses are specified in Bech32 (cosmos) format, and in solidity in ETH format. In some situations you may want/need to convert from Bech32 to ETH format. Or the other way around. You can do it with the @swisstronik/utils package:
import { ethAddressToBech32, bech32toEthAddress } from "@swisstronik/utils";Last updated