On-going Monitoring

For a subset of attributes (ex: AML), the issuer is responsible to perform on-going monitoring and update the attribute values directly in the passport.

Only specific issuers are required to perform on-going monitoring.

Example (change of AML score)

Nodejs

import { ethers } from 'ethers';
import { BytesLike } from '@ethersproject/bytes';

const newAMLScore = hexZeroPad("0x05", 32); // new AML score
const accountToUpdate = "0x......."; // Wallet of the Passport holder to update
const issuer = new Wallet(ISSUER_PRIVATE_KEY); // Loading issuer account from their private key
const attrTypes = [utils.id("AML")];  // List of attributes types
const attrKeys = computeAttrKeys(accountAddress, attrTypes); // List of attributes Identifiers
const attrValues = [newAMLScore]; // List of attributes values
const verifiedAt = Math.floor(new Date().getTime() / 1000) - 60; // we substract 60 seconds to avoid errors during minting passport with long block time
const issuedAt = Math.floor(new Date().getTime() / 1000) - 60; // we substract 60 seconds to avoid errors during minting passport with long block time
const passportAddress = "0x2e779749c40CC4Ba1cAB4c57eF84d90755CC017d";
const chainId = 1; // 1 for Ethereum Mainnet
const fee = utils.parseEther("0"); // No fee to paid as this is an update performed by the issuer themselves
const did = ethers.constants.HashZero; // Leave empty
const signature = await signAttributes(
  accountAddress,
  issuer,
  attrKeys,
  attrValues,
  verifiedAt,
  issuedAt, 
  fee,
  passportAddress,
  chainId
)

const QUAD_PASSPORT_ABI = ''; // Can be retrieve at https://etherscan.io/address/0xebf9b4db6050517e402c578237326b793bf348ff#code

const passportContract = new ethers.Contract(
    passportAddress,
    QUAD_PASSPORT_ABI,
);

const tx = await passportContract.setAttributesIssuer(
    accountAddress,
    [
      attrKeys,
      attrValues,
      attrTypes,
      ethers.constants.HashZero, // Leave bytes32(0)
      0, // Leave 0
      verifiedAt,
      issuedAt,
      fee,
    ],
    sigIssuer,
    {
      value: fee,
    }
  )
)

await tx.wait();

export const signAttributes = async (
  accountAddress: string,
  issuer: typeof Signer,
  attrKeys: BytesLike[],
  attrValues: BytesLike[],
  verifiedAt: number,
  issuedAt: number,
  fee: any,
  passportAddress: string,
  chainId: number,
  did: BytesLike = utils.constants.HashZero,
): Promise<typeof DataHexString> => {
  const attrKeys: string[] = [];
  const attrValues: string[] = [];

  const hash = utils.keccak256(
    utils.defaultAbiCoder.encode(
      [
        "address",
        "bytes32[]",
        "bytes32[]",
        "bytes32",
        "uint256",
        "uint256",
        "uint256",
        "uint256",
        "address",
      ],
      [
        accountAddress,
        attrKeys,
        attrValues,
        did,
        verifiedAt,
        issuedAt,
        fee,
        chainId,
        passportAddress,
      ]
    )
  );

  const sig = await issuer.signMessage(utils.arrayify(hash));

  return sig;
};
`

Python

W3_TIMEOUT = 60
ABI_PATH = "" # DIRECTORY CONTAINING ABI FILE
PASSPORT_ABI_FILE_NAME = "" # ABI FILE NAME
NETWORK_URI = "" # INFURA_RPC_NODE
PASSPORT_CONTRACT_ADDRESS = "" # PASSPORT ADDRESS
CHAIN_ID = 1 # CHAIN ID WHERE ATTESTATION WILL BE POSTED
GAS_LIMIT = 300000
ISSUER_PRIVATE_KEY = "" # ISSUER__PRIVATE_KEY
HEX_PADDING = 66

@dataclass(frozen=True)
class UpdateCreditScoreInputs:
    target_address: str
    token_id: int
    new_value: str
    verified_at: int
    quad_did: str
    issued_at: int = blockchain_timestamp_seconds()
    # Update fee should be 0 so issuer does not have to pay for update
    update_fee: int = 0

    def attr_keys(self) -> List[bytes]:
        # Need to modify CREDIT_SCORE to attribute type 
        return [Web3.solidityKeccak(['bytes32', 'bytes32'], [self.target_address, keccak('CREDIT_SCORE')])]

    def attr_values(self) -> List[bytes]:
        return [self.hexlified_value()]

    def attr_types(self) -> List[str]:
        return [keccak('CREDIT_SCORE')]

    def hexlified_value(self) -> bytes:
        return bytes.fromhex(f'{self.new_value:#0{HEX_PADDING}x}'[2:])

    def attribute_setter_config(self) -> tuple:
        return (
            [key.hex() for key in self.attr_keys()],
            [f'0x{val.hex()}' for val in self.attr_values()],
            self.attr_types(),
            self.quad_did,
            self.token_id,
            self.verified_at,
            self.issued_at,
            self.update_fee,
        )

    def update_message(self, chain_id) -> str:
        abiEncoded = eth_abi.encode_abi(
            [
                'bytes32',
                'bytes32[]',
                'bytes32[]',
                'bytes32',
                'uint256',
                'uint256',
                'uint256',
                'uint256',
                'bytes32',
            ],
            [
                self.target_address,
                self.attr_keys(),
                self.attr_values(),
                bytes.fromhex(self.quad_did[2:]),
                self.verified_at,
                self.issued_at,
                self.update_fee,
                chain_id,
                bytes.fromhex(Web3.toChecksumAddress(PASSPORT_CONTRACT_ADDRESS)[2:]).rjust(
                    32, b'\0'
                ),
            ],
        )
        return Web3.solidityKeccak(['bytes32'], [('0x' + abiEncoded.hex())]).hex()

def keccak(value: str) -> str:
    if not value:
        raise ValueError('Attempted to keccak hash an empty string')
    return Web3.solidityKeccak(['bytes32'], [value.encode()]).hex()


def _load_passport_abi(self) -> str:
    with open(os.path.join(ABI_PATH, PASSPORT_ABI_FILE_NAME)) as f:
        return json.load(f)

update_inputs = UpdateCreditScoreInputs(
    target_address = '', # target wallet address for credit score update
    token_id = 1, # configurable passport skin
    new_value = '',# new value
    verified_at = int(datetime.now(timezone.utc).timestamp()) - 60,
    quad_did = web3.constants.HASH_ZERO,
    issued_at = int(datetime.now(timezone.utc).timestamp()) - 60,
    update_fee = 0 # Update fee should be 0 so issuer does not have to pay for update
)

w3 = Web3(Web3.HTTPProvider(NETWORK_URI, request_kwargs={'timeout': W3_TIMEOUT}))
contract = w3.eth.contract(
    address=Web3.toChecksumAddress(PASSPORT_CONTRACT_ADDRESS),
    abi=self._load_passport_abi(),
)

# Assumes no pending transaction
nonce = w3.eth.getTransactionCount(
    Web3.toChecksumAddress(
        w3.eth.account.privateKeyToAccount(ISSUER_PRIVATE_KEY).address))


transaction = contract.functions.setAttributesIssuer(
    Web3.toChecksumAddress(update_inputs.target_address),
    update_inputs.attribute_setter_config(),
    update_inputs.update_message(CHAIN_ID),
).buildTransaction(
    {
        'gasPrice': w3.eth.gas_price,
        'gas': GAS_LIMIT, 
        'nonce': nonce,
        'chainId': CHAIN_ID,
    }
)
decoder = codecs.getdecoder('hex_codec')
signed_tx = self.w3.eth.account.signTransaction(
    transaction, private_key=decoder(str.encode(ISSUER_PRIVATE_KEY))[0]
)
tx_hash = self.w3.eth.sendRawTransaction(signed_tx.rawTransaction)