@bonfida/spl-name-service 0.2.4 → 0.2.5

package/src/bindings.ts

@@ -1,445 +0,0 @@
-import {
-  Connection,
-  PublicKey,
-  SystemProgram,
-  TransactionInstruction,
-  SYSVAR_RENT_PUBKEY,
-} from "@solana/web3.js";
-import {
-  createInstruction,
-  deleteInstruction,
-  transferInstruction,
-  updateInstruction,
-  createReverseInstruction,
-  createInstructionV3,
-} from "./instructions";
-import { NameRegistryState } from "./state";
-import { Numberu64, Numberu32 } from "./int";
-import {
-  getHashedName,
-  getNameAccountKey,
-  getNameOwner,
-} from "./deprecated/utils";
-import {
-  NAME_PROGRAM_ID,
-  ROOT_DOMAIN_ACCOUNT,
-  REGISTER_PROGRAM_ID,
-  REFERRERS,
-  USDC_MINT,
-  TOKENS_SYM_MINT,
-  PYTH_MAPPING_ACC,
-  VAULT_OWNER,
-} from "./constants";
-import {
-  getPythProgramKeyForCluster,
-  PythHttpClient,
-} from "@pythnetwork/client";
-import {
-  getDomainKeySync,
-  getHashedNameSync,
-  getNameAccountKeySync,
-} from "./utils";
-import {
-  TOKEN_PROGRAM_ID,
-  getAssociatedTokenAddressSync,
-  createAssociatedTokenAccountInstruction,
-} from "@solana/spl-token";
-
-/**
- * Creates a name account with the given rent budget, allocated space, owner and class.
- *
- * @param connection The solana connection object to the RPC node
- * @param name The name of the new account
- * @param space The space in bytes allocated to the account
- * @param payerKey The allocation cost payer
- * @param nameOwner The pubkey to be set as owner of the new name account
- * @param lamports The budget to be set for the name account. If not specified, it'll be the minimum for rent exemption
- * @param nameClass The class of this new name
- * @param parentName The parent name of the new name. If specified its owner needs to sign
- * @returns
- */
-export async function createNameRegistry(
-  connection: Connection,
-  name: string,
-  space: number,
-  payerKey: PublicKey,
-  nameOwner: PublicKey,
-  lamports?: number,
-  nameClass?: PublicKey,
-  parentName?: PublicKey
-): Promise<TransactionInstruction> {
-  const hashed_name = await getHashedName(name);
-  const nameAccountKey = await getNameAccountKey(
-    hashed_name,
-    nameClass,
-    parentName
-  );
-
-  const balance = lamports
-    ? lamports
-    : await connection.getMinimumBalanceForRentExemption(space);
-
-  let nameParentOwner: PublicKey | undefined;
-  if (parentName) {
-    const { registry: parentAccount } = await getNameOwner(
-      connection,
-      parentName
-    );
-    nameParentOwner = parentAccount.owner;
-  }
-
-  const createNameInstr = createInstruction(
-    NAME_PROGRAM_ID,
-    SystemProgram.programId,
-    nameAccountKey,
-    nameOwner,
-    payerKey,
-    hashed_name,
-    //@ts-ignore
-    new Numberu64(balance),
-    //@ts-ignore
-    new Numberu32(space),
-    nameClass,
-    parentName,
-    nameParentOwner
-  );
-
-  return createNameInstr;
-}
-
-/**
- * Overwrite the data of the given name registry.
- *
- * @param connection The solana connection object to the RPC node
- * @param name The name of the name registry to update
- * @param offset The offset to which the data should be written into the registry
- * @param input_data The data to be written
- * @param nameClass The class of this name, if it exsists
- * @param nameParent The parent name of this name, if it exists
- */
-export async function updateNameRegistryData(
-  connection: Connection,
-  name: string,
-  offset: number,
-  input_data: Buffer,
-  nameClass?: PublicKey,
-  nameParent?: PublicKey
-): Promise<TransactionInstruction> {
-  const hashed_name = await getHashedName(name);
-  const nameAccountKey = await getNameAccountKey(
-    hashed_name,
-    nameClass,
-    nameParent
-  );
-
-  let signer: PublicKey;
-  if (nameClass) {
-    signer = nameClass;
-  } else {
-    signer = (await NameRegistryState.retrieve(connection, nameAccountKey))
-      .registry.owner;
-  }
-
-  const updateInstr = updateInstruction(
-    NAME_PROGRAM_ID,
-    nameAccountKey,
-    //@ts-ignore
-    new Numberu32(offset),
-    input_data,
-    signer
-  );
-
-  return updateInstr;
-}
-
-/**
- * Change the owner of a given name account.
- *
- * @param connection The solana connection object to the RPC node
- * @param name The name of the name account
- * @param newOwner The new owner to be set
- * @param curentNameOwner the current name Owner
- * @param nameClass The class of this name, if it exsists
- * @param nameParent The parent name of this name, if it exists
- * @param parentOwner Parent name owner
- * @returns
- */
-export async function transferNameOwnership(
-  connection: Connection,
-  name: string,
-  newOwner: PublicKey,
-  nameClass?: PublicKey,
-  nameParent?: PublicKey,
-  parentOwner?: PublicKey
-): Promise<TransactionInstruction> {
-  const hashed_name = await getHashedName(name);
-  const nameAccountKey = await getNameAccountKey(
-    hashed_name,
-    nameClass,
-    nameParent
-  );
-
-  let curentNameOwner: PublicKey;
-  if (nameClass) {
-    curentNameOwner = nameClass;
-  } else {
-    curentNameOwner = (
-      await NameRegistryState.retrieve(connection, nameAccountKey)
-    ).registry.owner;
-  }
-
-  const transferInstr = transferInstruction(
-    NAME_PROGRAM_ID,
-    nameAccountKey,
-    newOwner,
-    curentNameOwner,
-    nameClass,
-    nameParent,
-    parentOwner
-  );
-
-  return transferInstr;
-}
-
-/**
- * Delete the name account and transfer the rent to the target.
- *
- * @param connection The solana connection object to the RPC node
- * @param name The name of the name account
- * @param refundTargetKey The refund destination address
- * @param nameClass The class of this name, if it exsists
- * @param nameParent The parent name of this name, if it exists
- * @returns
- */
-export async function deleteNameRegistry(
-  connection: Connection,
-  name: string,
-  refundTargetKey: PublicKey,
-  nameClass?: PublicKey,
-  nameParent?: PublicKey
-): Promise<TransactionInstruction> {
-  const hashed_name = await getHashedName(name);
-  const nameAccountKey = await getNameAccountKey(
-    hashed_name,
-    nameClass,
-    nameParent
-  );
-
-  let nameOwner: PublicKey;
-  if (nameClass) {
-    nameOwner = nameClass;
-  } else {
-    nameOwner = (await NameRegistryState.retrieve(connection, nameAccountKey))
-      .registry.owner;
-  }
-
-  const changeAuthoritiesInstr = deleteInstruction(
-    NAME_PROGRAM_ID,
-    nameAccountKey,
-    refundTargetKey,
-    nameOwner
-  );
-
-  return changeAuthoritiesInstr;
-}
-
-/**
- * This function can be used to register a .sol domain
- * @param connection The Solana RPC connection object
- * @param name The domain name to register e.g bonfida if you want to register bonfida.sol
- * @param space The domain name account size (max 10kB)
- * @param buyer The public key of the buyer
- * @param buyerTokenAccount The buyer token account (USDC)
- * @param mint Optional mint used to purchase the domain, defaults to USDC
- * @param referrerKey Optional referrer key
- * @returns
- */
-export const registerDomainName = async (
-  connection: Connection,
-  name: string,
-  space: number,
-  buyer: PublicKey,
-  buyerTokenAccount: PublicKey,
-  mint = USDC_MINT,
-  referrerKey?: PublicKey
-) => {
-  const [cs] = PublicKey.findProgramAddressSync(
-    [REGISTER_PROGRAM_ID.toBuffer()],
-    REGISTER_PROGRAM_ID
-  );
-
-  const hashed = getHashedNameSync(name);
-  const nameAccount = getNameAccountKeySync(
-    hashed,
-    undefined,
-    ROOT_DOMAIN_ACCOUNT
-  );
-
-  const hashedReverseLookup = getHashedNameSync(nameAccount.toBase58());
-  const reverseLookupAccount = getNameAccountKeySync(hashedReverseLookup, cs);
-
-  const [derived_state] = PublicKey.findProgramAddressSync(
-    [nameAccount.toBuffer()],
-    REGISTER_PROGRAM_ID
-  );
-
-  const refIdx = REFERRERS.findIndex((e) => referrerKey?.equals(e));
-  let refTokenAccount: PublicKey | undefined = undefined;
-
-  const ixs: TransactionInstruction[] = [];
-
-  if (refIdx !== -1 && !!referrerKey) {
-    refTokenAccount = getAssociatedTokenAddressSync(mint, referrerKey, true);
-    const acc = await connection.getAccountInfo(refTokenAccount);
-    if (!acc?.data) {
-      const ix = createAssociatedTokenAccountInstruction(
-        buyer,
-        refTokenAccount,
-        referrerKey,
-        mint
-      );
-      ixs.push(ix);
-    }
-  }
-
-  const pythConnection = new PythHttpClient(
-    connection,
-    getPythProgramKeyForCluster("mainnet-beta")
-  );
-  const data = await pythConnection.getData();
-
-  const symbol = TOKENS_SYM_MINT.get(mint.toBase58());
-
-  if (!symbol) {
-    throw new Error("Symbol not found");
-  }
-
-  const priceData = data.productPrice.get("Crypto." + symbol + "/USD")!;
-  const productData = data.productFromSymbol.get("Crypto." + symbol + "/USD")!;
-
-  const vault = getAssociatedTokenAddressSync(mint, VAULT_OWNER);
-
-  const ix = new createInstructionV3({
-    name,
-    space,
-    referrerIdxOpt: refIdx != -1 ? refIdx : null,
-  }).getInstruction(
-    REGISTER_PROGRAM_ID,
-    NAME_PROGRAM_ID,
-    ROOT_DOMAIN_ACCOUNT,
-    nameAccount,
-    reverseLookupAccount,
-    SystemProgram.programId,
-    cs,
-    buyer,
-    buyerTokenAccount,
-    PYTH_MAPPING_ACC,
-    priceData.productAccountKey,
-    new PublicKey(productData.price_account),
-    vault,
-    TOKEN_PROGRAM_ID,
-    SYSVAR_RENT_PUBKEY,
-    derived_state,
-    refTokenAccount
-  );
-  ixs.push(ix);
-
-  return [[], ixs];
-};
-
-/**
- *
- * @param nameAccount The name account to create the reverse account for
- * @param name The name of the domain
- * @param feePayer The fee payer of the transaction
- * @param parentName The parent name account
- * @param parentNameOwner The parent name owner
- * @returns
- */
-export const createReverseName = async (
-  nameAccount: PublicKey,
-  name: string,
-  feePayer: PublicKey,
-  parentName?: PublicKey,
-  parentNameOwner?: PublicKey
-) => {
-  let [centralState] = await PublicKey.findProgramAddress(
-    [REGISTER_PROGRAM_ID.toBuffer()],
-    REGISTER_PROGRAM_ID
-  );
-
-  let hashedReverseLookup = await getHashedName(nameAccount.toBase58());
-  let reverseLookupAccount = await getNameAccountKey(
-    hashedReverseLookup,
-    centralState,
-    parentName
-  );
-
-  let initCentralStateInstruction = new createReverseInstruction({
-    name,
-  }).getInstruction(
-    REGISTER_PROGRAM_ID,
-    SYSVAR_RENT_PUBKEY,
-    NAME_PROGRAM_ID,
-    ROOT_DOMAIN_ACCOUNT,
-    reverseLookupAccount,
-    centralState,
-    feePayer,
-    parentName,
-    parentNameOwner
-  );
-
-  let instructions = [initCentralStateInstruction];
-
-  return [[], instructions];
-};
-
-/**
- * This function can be used to create a subdomain
- * @param connection The Solana RPC connection object
- * @param subdomain The subdomain to create with or without .sol e.g something.bonfida.sol or something.bonfida
- * @param owner The owner of the parent domain creating the subdomain
- * @param space The space to allocate to the subdomain (defaults to 2kb)
- */
-export const createSubdomain = async (
-  connection: Connection,
-  subdomain: string,
-  owner: PublicKey,
-  space = 2_000
-) => {
-  const ixs: TransactionInstruction[] = [];
-  const sub = subdomain.split(".")[0];
-  if (!sub) {
-    throw new Error("Invalid subdomain input");
-  }
-
-  const { parent, pubkey } = getDomainKeySync(subdomain);
-
-  // Space allocated to the subdomains
-  const lamports = await connection.getMinimumBalanceForRentExemption(
-    space + NameRegistryState.HEADER_LEN
-  );
-
-  const ix_create = await createNameRegistry(
-    connection,
-    "\0".concat(sub),
-    space, // Hardcode space to 2kB
-    owner,
-    owner,
-    lamports,
-    undefined,
-    parent
-  );
-  ixs.push(ix_create);
-
-  // Create the reverse name
-  const [, ix_reverse] = await createReverseName(
-    pubkey,
-    "\0".concat(sub),
-    owner,
-    parent,
-    owner
-  );
-  ixs.push(...ix_reverse);
-  return [[], ixs];
-};

package/src/constants.ts

@@ -1,101 +0,0 @@
-import { PublicKey } from "@solana/web3.js";
-
-/**
- * The Solana Name Service program ID
- */
-export const NAME_PROGRAM_ID = new PublicKey(
-  "namesLPneVptA9Z5rqUDD9tMTWEJwofgaYwp8cawRkX"
-);
-
-/**
- * Hash prefix used to derive domain name addresses
- */
-export const HASH_PREFIX = "SPL Name Service";
-
-/**
- * The `.sol` TLD
- */
-export const ROOT_DOMAIN_ACCOUNT = new PublicKey(
-  "58PwtjSDuFHuUkYjH9BYnnQKHfwo9reZhC2zMJv9JPkx"
-);
-
-/**
- * The Registry program ID
- */
-export const REGISTER_PROGRAM_ID = new PublicKey(
-  "jCebN34bUfdeUYJT13J1yG16XWQpt5PDx6Mse9GUqhR"
-);
-
-/**
- * The FIDA Pyth price feed
- */
-export const PYTH_FIDA_PRICE_ACC = new PublicKey(
-  "ETp9eKXVv1dWwHSpsXRUuXHmw24PwRkttCGVgpZEY9zF"
-);
-
-/**
- * The FIDA buy and burn address
- */
-export const BONFIDA_FIDA_BNB = new PublicKey(
-  "AUoZ3YAhV3b2rZeEH93UMZHXUZcTramBvb4d9YEVySkc"
-);
-
-/**
- * The reverse look up class
- */
-export const REVERSE_LOOKUP_CLASS = new PublicKey(
-  "33m47vH6Eav6jr5Ry86XjhRft2jRBLDnDgPSHoquXi2Z"
-);
-
-/**
- * The `.twitter` TLD authority
- */
-export const TWITTER_VERIFICATION_AUTHORITY = new PublicKey(
-  "FvPH7PrVrLGKPfqaf3xJodFTjZriqrAXXLTVWEorTFBi"
-);
-
-/**
- * The `.twitter` TLD
- */
-export const TWITTER_ROOT_PARENT_REGISTRY_KEY = new PublicKey(
-  "4YcexoW3r78zz16J2aqmukBLRwGq6rAvWzJpkYAXqebv"
-);
-
-/**
- * The length of the SOL record signature
- */
-export const SOL_RECORD_SIG_LEN = 96;
-
-export const BONFIDA_USDC_BNB = new PublicKey(
-  "DmSyHDSM9eSLyvoLsPvDr5fRRFZ7Bfr3h3ULvWpgQaq7"
-);
-
-export const USDC_MINT = new PublicKey(
-  "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
-);
-
-export const REFERRERS: PublicKey[] = [
-  new PublicKey("3ogYncmMM5CmytsGCqKHydmXmKUZ6sGWvizkzqwT7zb1"), // Test wallet,
-  new PublicKey("DM1jJCkZZEwY5tmWbgvKRxsDFzXCdbfrYCCH1CtwguEs"), // 4Everland
-];
-
-export const TOKENS_SYM_MINT = new Map<string, string>([
-  ["EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "USDC"],
-  ["Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB", "USDT"],
-  ["So11111111111111111111111111111111111111112", "SOL"],
-  ["EchesyfXePKdLtoiZSL8pBe8Myagyy8ZRqsACNCFGnvp", "FIDA"],
-  ["FeGn77dhg1KXRRFeSwwMiykZnZPw5JXW6naf2aQgZDQf", "ETH"],
-  ["7i5KKsX2weiTkry7jA4ZwSuXGhs5eJBEjY8vVxR4pfRx", "GMT"],
-  ["AFbX8oGjGpmVFywbVouvhQSRmiW2aR1mohfahi4Y2AdB", "GST"],
-  ["mSoLzYCxHdYgdzU16g5QSh3i5K3z3KZK7ytfqcJm7So", "MSOL"],
-  ["DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263", "BONK"],
-  ["EPeUFDgHRxs9xxEPVaL6kfGQvCon7jmAWKVUHuux1Tpz", "BAT"],
-]);
-
-export const PYTH_MAPPING_ACC = new PublicKey(
-  "AHtgzX45WTKfkPG53L6WYhGEXwQkN1BVknET3sVsLL8J"
-);
-
-export const VAULT_OWNER = new PublicKey(
-  "GcWEQ9K78FV7LEHteFVciYApERk5YvQuFDQPk1yYJVXi"
-);

package/src/deprecated/index.ts

@@ -1 +0,0 @@
-export * from "./utils";

package/src/deprecated/record.ts

@@ -1,14 +0,0 @@
-import { Record } from "../types/record";
-import { getDomainKey } from "./utils";
-
-/**
- * @deprecated Use {@link getRecordKeySync} instead
- * This function can be used to derive a record key
- * @param domain The .sol domain name
- * @param record The record to derive the key for
- * @returns
- */
-export const getRecordKey = async (domain: string, record: Record) => {
-  const { pubkey } = await getDomainKey(record + "." + domain, true);
-  return pubkey;
-};

package/src/deprecated/tokens.ts

@@ -1,52 +0,0 @@
-import { PublicKey, Connection } from "@solana/web3.js";
-import { getHashedName, getNameAccountKey } from "./utils";
-import { NameRegistryState, TokenData, Mint } from "../state";
-
-/**
- * @deprecated
- */
-export const TOKEN_TLD = new PublicKey(
-  "6NSu2tci4apRKQtt257bAVcvqYjB3zV2H1dWo56vgpa6"
-);
-
-/**
- * @deprecated
- */
-export const getTokenInfoFromMint = async (
-  connection: Connection,
-  mint: PublicKey
-) => {
-  const nameKey = await getNameAccountKey(
-    await getHashedName(mint.toBase58()),
-    undefined,
-    TOKEN_TLD
-  );
-  const { registry } = await NameRegistryState.retrieve(connection, nameKey);
-  if (!registry.data) {
-    throw new Error("Invalid account data");
-  }
-  return TokenData.deserialize(registry.data);
-};
-
-/**
- * @deprecated
- */
-export const getTokenInfoFromName = async (
-  connection: Connection,
-  name: string
-) => {
-  const reverseNameKey = await getNameAccountKey(
-    await getHashedName(name),
-    undefined,
-    TOKEN_TLD
-  );
-  const { registry: reverseRegistry } = await NameRegistryState.retrieve(
-    connection,
-    reverseNameKey
-  );
-  if (!reverseRegistry.data) {
-    throw new Error("Invalid account data");
-  }
-  const mint = new PublicKey(Mint.deserialize(reverseRegistry.data).mint);
-  return await getTokenInfoFromMint(connection, mint);
-};