@routerprotocol/router-name-service-sdk/src/index.ts

Router 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 fetchSourceChainContracts(chain_id: 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": {
          "fetch_whitelisted": {
            "chain_id": chain_id
          }
        }
      }
    })),
  };
  try {
    let fetchSmartContractStateResult = await wasmClient.fetchSmartContractState(
      request.address,
      request.queryData
    );
    return fetchSmartContractStateResult;
  } catch (err) {
  }
}

export async function fetchDefaultMintingFeeConfig(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_default_minting_fees": {}
        }
      }
    })),
  };
  try {
    let fetchSmartContractStateResult = await wasmClient.fetchSmartContractState(
      request.address,
      request.queryData
    );
    return fetchSmartContractStateResult;
  } catch (err) {
  }
}

export async function checkDomainAndCalculateFees(domain_name: string, duration: number, chain_id: String, tokenAddr: String, network: keyof Constants): Promise<DomainInfo | null> {
  const domainExistsResult = await domainExists(domain_name, network);
  if (!domainExistsResult) {
    const fees = await domainFees(domain_name, duration, chain_id, 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 getAllDomains(network: keyof Constants, limit?: number, start_key?: string) {
  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({
      "all_tokens": {
        "start_after": start_key,
        "limit": limit
      }
    }))
  };
  try {
    let fetchSmartContractStateResult = await wasmClient.fetchSmartContractState(
      request.address,
      request.queryData
    );
    return fetchSmartContractStateResult;
  } catch (err) {
    throw err;
  }
}

export async function domainExists(domain_name: String, network: keyof Constants): Promise<boolean> {
  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
    );
    if (fetchSmartContractStateResult) {
      return true;
    }
  } catch (err) {
  }
  return false;
}

export async function getAllDomainsForOwner(network: keyof Constants, owner: string, limit?: number, start_key?: string) {
  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,
        "limit": limit,
        "start_after": start_key
      }
    }))
  };
  try {
    let fetchSmartContractStateResult = await wasmClient.fetchSmartContractState(
      request.address,
      request.queryData
    );
    return fetchSmartContractStateResult;
  } catch (err) {
    throw err;
  }
}

export async function getRNSOwner(network: keyof Constants, domain: string, chain_id: string) {
  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_nft_owner": {
            "token_id": domain,
            "chain_id": chain_id
          }
        }
      }
    }))
  };
  try {
    let fetchSmartContractStateResult = await wasmClient.fetchSmartContractState(
      request.address,
      request.queryData
    );
    return fetchSmartContractStateResult;
  } catch (err) {
    throw err;
  }
}

export async function getRNSMetadata(domain: 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({
      "nft_info": {
        "token_id": domain
      }
    }))
  };
  try {
    let fetchSmartContractStateResult = await wasmClient.fetchSmartContractState(
      request.address,
      request.queryData
    );
    return fetchSmartContractStateResult;
  } catch (err) {
    throw err;
  }
}

export async function domainFees(domain_name: String, duration: Number, chain_id: String, 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,
            "chain_id": chain_id,
            "token_addr": tokenAddr
          }
        }
      }
    })),
  };
  try {
    let fetchSmartContractStateResult = await wasmClient.fetchSmartContractState(
      request.address,
      request.queryData
    );
    console.log(fetchSmartContractStateResult);
    let fees = fetchSmartContractStateResult.data;
    let usdcPrice = await getUSDCPrice(network);
    let adjustedFeesInUSD = Math.floor((parseInt(fees.toString()) * parseInt(usdcPrice)) / 1e9);
    return adjustedFeesInUSD;
  } catch (err) {
    throw err
    //console.log(err);
  }
}


export async function getRNSInfo(network: keyof Constants, domain_name: string, custom_info1?: string, custom_info2?: string) {
  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_nft_info": {
            "domain_name": domain_name,
            "custom_info1": custom_info1,
            "custom_info2": custom_info2
          }

        }
      }
    }))
  };
  try {
    let fetchSmartContractStateResult = await wasmClient.fetchSmartContractState(
      request.address,
      request.queryData
    );
    return fetchSmartContractStateResult;
  } catch (err) {
    throw err;
  }
}

export async function getRenewalFees(duration: Number, chain_id: String, token_addr: 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_renewal_fees": {
            "duration": duration,
            "chain_id": chain_id,
            "token_addr": token_addr
          }
        }
      }
    })),
  };
  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);
    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");