sample-name-service-sdk/src/index.ts

Name Service SDK

import {
  getEndpointsForNetwork,
  Network,
  toUtf8,
  ChainGrpcWasmApi
} from '@routerprotocol/router-chain-sdk-ts';
import { constants } from './constants';

interface Constants {
  testnet: {
    contract_address: string
  };
  mainnet: {
    contract_address: string
  }
}

interface DomainInfo {
  domainName: string;
  fees?: number;
  data?: string;
};

export async function getAllDomains(owner: String, network: keyof Constants) {
  const endpoint = getEndpointsForNetwork(network == 'testnet' ? Network.Testnet : Network.Mainnet);
  const wasmClient = new ChainGrpcWasmApi(endpoint.grpcEndpoint);
  const request = {
    address: constants[network].contract_address,
    queryData: toUtf8(JSON.stringify({
      "tokens": {
        "owner": owner
      }
    }))
  };
  try {
    let fetchSmartContractStateResult = await wasmClient.fetchSmartContractState(
      request.address,
      request.queryData
    );
    return fetchSmartContractStateResult;
  } catch (err) {
    throw err;
  }
}
export async function checkDomainAndCalculateFees(domain_name: string, duration: number, tokenAddr: String, network: keyof Constants): Promise<DomainInfo | null> {
  const domainExistsResult = await domainExists(domain_name, network);
  if (!domainExistsResult) {
    const fees = await domainFees(domain_name, duration, tokenAddr, network);
    const custom_data = await getCustomInfo(domain_name, network);
    console.log(`Domain '${domain_name}' doesn't exists.`);
    console.log(`Fees for '${domain_name}' is ${fees} `);
    console.log(`No custom info found`);
    const data = {
      domainName: domain_name,
      fees: fees as unknown as number
    };
    console.log(data);
    return data
  }
  else {
    console.log(`Domain '${domain_name}' exists.`);
    console.log(`Custom Info for '${domain_name}' is `);
    const custom_data = await getCustomInfo(domain_name, network);
    const data = {
      domainName: domain_name,
      data: custom_data?.data as unknown as string
    };
    console.log(data)
    return data
  }
}

export async function domainExists(domain_name: String, network: keyof Constants) {
  const endpoint = getEndpointsForNetwork(network == 'testnet' ? Network.Testnet : Network.Mainnet);
  const wasmClient = new ChainGrpcWasmApi(endpoint.grpcEndpoint);

  const request = {
    address: constants[network].contract_address,
    queryData: toUtf8(JSON.stringify({
      "owner_of": {
        "token_id": domain_name
      }
    })),
  };
  try {
    let fetchSmartContractStateResult = await wasmClient.fetchSmartContractState(
      request.address,
      request.queryData
    );
    return fetchSmartContractStateResult;
  } catch (err) {
  }
}


export async function domainFees(domain_name: String, duration: Number, tokenAddr: String, network: keyof Constants) {
  const endpoint = getEndpointsForNetwork(network == 'testnet' ? Network.Testnet : Network.Mainnet);
  const wasmClient = new ChainGrpcWasmApi(endpoint.grpcEndpoint);
  const request = {
    address: constants[network].contract_address,
    queryData: toUtf8(JSON.stringify({
      "extension": {
        "msg": {
          "get_fees_for_domain": {
            "domain_name": domain_name,
            "duration": duration,
            "token_addr": tokenAddr
          }
        }
      }
    })),
  };
  try {
    let fetchSmartContractStateResult = await wasmClient.fetchSmartContractState(
      request.address,
      request.queryData
    );
    let fees = fetchSmartContractStateResult.data;
    let usdcPrice = await getUSDCPrice(network);
    let adjustedFeesInUSD = Math.floor((parseInt(fees.toString()) * parseInt(usdcPrice)) / 1e9);
    //console.log("Fees in USD", adjustedFees)
    return adjustedFeesInUSD;
  } catch (err) {
    throw err
    //console.log(err);
  }
}

export async function getRenewalFees(duration: Number, network: keyof Constants) {
  const endPoint = getEndpointsForNetwork(network == 'testnet' ? Network.Testnet : Network.Mainnet);
  const wasmClient = new ChainGrpcWasmApi(endPoint.grpcEndpoint);
  const request = {
    address: constants[network].contract_address,
    queryData: toUtf8(JSON.stringify({
      "extension": {
        "msg": {
          "get_renewal_fees": {
            "duration": duration
          }
        }
      }
    })),
  };
  try {
    let fetchSmartContractStateResult = await wasmClient.fetchSmartContractState(
      request.address,
      request.queryData
    );
    let fees = fetchSmartContractStateResult.data;
    let usdcPrice = await getUSDCPrice(network);
    let adjustedFeesInUSD = Math.floor((parseInt(fees.toString()) * parseInt(usdcPrice)) / 1e9);
    console.log(`Renewal fees is ${adjustedFeesInUSD}`);
    return adjustedFeesInUSD;
  } catch (err) {
    console.log(err);
  }
}

export async function getCustomInfo(domain_name: String, network: keyof Constants) {
  const endPoint = getEndpointsForNetwork(network == 'testnet' ? Network.Testnet : Network.Mainnet);
  const wasmClient = new ChainGrpcWasmApi(endPoint.grpcEndpoint);
  const request = {
    address: constants[network].contract_address,
    queryData: toUtf8(JSON.stringify(
      {
        "extension": {
          "msg": {
            "get_custom_info_for_domain": {
              "domain_name": domain_name
            }
          }
        }
      }
    ))
  };
  try {
    let fetchSmartContractStateResult = await wasmClient.fetchSmartContractState(
      request.address,
      request.queryData
    );
    return fetchSmartContractStateResult
  }
  catch (err) {
  }
}

export function getFeeManagerAddress(network: Network): string {
  switch (network) {
    case Network.AlphaDevnet:
      return 'router17r3faruez552kdxy0lsjydmj0nu22mxax33azx326039hfe7pnhq7xma7f';
    case Network.Devnet:
      return 'router17r3faruez552kdxy0lsjydmj0nu22mxax33azx326039hfe7pnhq7xma7f';
    case Network.Testnet:
      return 'router1gh3r6u3j77nvsl2q2rq5r53qecwqx2gr2ya8dk7dy0e6lec8873quadtje';
    case Network.Mainnet:
      return 'router1nv8f4hy8792daa42q08akgzzc9r3u6f959qz7xknhzu2qzxd4kast3mg9n';
    default:
      throw new Error('Invalid network');
  }
}

export async function getUSDCPrice(
  network: keyof Constants
): Promise<string> {
  const endPoint = getEndpointsForNetwork(network == 'testnet' ? Network.Testnet : Network.Mainnet);
  const wasmClient: ChainGrpcWasmApi = new ChainGrpcWasmApi(
    endPoint.grpcEndpoint,
  );

  const feeManagerAddress = getFeeManagerAddress(network == 'testnet' ? Network.Testnet : Network.Mainnet);
  const queryMessage = JSON.stringify({
    fetch_symbol_price: {
      "symbol": "USDC"
    }
  });

  const request = {
    address: feeManagerAddress,
    queryData: toUtf8(queryMessage)
  };

  try {
    const queryResponse = await wasmClient.fetchSmartContractState(
      request.address,
      request.queryData
    );
    let data = queryResponse.data.toString();
    return data
  } catch (err) {
    console.error(err)
    throw err;
  }
}

// checkDomainAndCalculateFees("alice", 1, "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359", "mainnet")
// getRenewalFees(2, "mainnet");