Set Sore

import { type Address, createPublicClient, getContract, http } from "viem";
import { polygon } from "viem/chains";
 
import { abi } from "./abi";
 
const calculationModel = 11;
const id = 9999999999999n;
 
const publicClient = createPublicClient({
  chain: polygon,
  transport: http(),
});
 
const contract = getContract({
  abi,
  address: "0x4724F4B3936B4c2d52f8F452719870c5d4c86b4D",
  client: publicClient,
});
 
const getValue = async (address: Address) => {
  try {
    // if account is whitelisted both mint and update fees are 0
    const isWhitelisted = await contract.read.whitelist([
      address,
      calculationModel,
    ]);
    if (isWhitelisted) return 0n;
 
    const [score] = await contract.read.getScore([
      address,
      chainId,
      calculationModel,
    ]);
 
    // update
    if (score !== 0) {
      const individual = await contract.read.getIndividualUpdateFee([
        address,
        calculationModel,
      ]);
      if (individual !== 0n) return individual;
      return await contract.read.getUpdateFee();
    }
 
    // mint
    const individual = await contract.read.getIndividualMintFee([
      address,
      calculationModel,
    ]);
    if (individual !== 0n) return individual;
    return await contract.read.getMintFee();
  } catch (error) {
    console.error(error);
  }
};
 
console.log(await getValue("0x..."));

import { ethers, type BigNumberish } from "ethers";
 
import { abi } from "./abi";
 
type Score = [
  score: BigNumberish,
  timestamp: BigNumberish,
  tokenId: BigNumberish,
  chainId: BigNumberish,
  calculationModel: BigNumberish,
  address: string
];
 
const calculationModel = 11;
const chainId = 9999999999999n;
 
const provider = new JsonRpcProvider("https://..."); // we need to only read so we don't need a signer
const contract = new Contract(
  "0x4724F4B3936B4c2d52f8F452719870c5d4c86b4D",
  abi,
  provider
);
 
const getValue = async (address: Address) => {
  try {
    // if wl both mint and update fees are 0
    const isWhitelisted = await contract.read.whitelist([
      address,
      calculationModel,
    ]);
    if (isWhitelisted) return 0n;
 
    const [score] = await contract.read.getScore([
      address,
      chainId,
      calculationModel,
    ]);
 
    // update
    if (score !== 0) {
      const individual = await contract.read.getIndividualUpdateFee([
        address,
        calculationModel,
      ]);
      if (individual !== 0n) return individual;
      return await contract.read.getUpdateFee();
    }
 
    // mint
    const individual = await contract.read.getIndividualMintFee([
      address,
      calculationModel,
    ]);
    if (individual !== 0n) return individual;
    return await contract.read.getMintFee();
  } catch (error) {
    console.error(error);
  }
};
 
console.log(await getValue("0x..."));

const getNonce = async (address: Address) => {
  return await contract.read.getNonce([address]);
};
 
console.log(await getNonce("0x..."));

const getNonce = async (address: string) => {
  return await contract.getNonce(address);
};
 
console.log(await getNonce("0x..."));

const scoreData = {...} // data from the API response
 
const setScore = async (address: Address) => {
  try {
    const scoreData = getScoreData(address);
 
    const trx = contract.write.setScore([
      scoreData.signature,
      scoreData.score,
      scoreData.calculationModel,
      scoreData.deadline,
      scoreData.metadataUrl,
      scoreData.chainId,
      scoreData.referralCode,
      scoreData.referrerCode
    ])
  } catch (error) {
    console.error(error)
  }
}