@secondlayer/stacks 0.0.1

package/dist/src/bns/index.js

@@ -0,0 +1,611 @@
+import"../../shared/stacks-tjxmrssa.js";
+import"../../shared/stacks-k58k970n.js";
+import {
+  getContract
+} from "../../shared/stacks-vdfs3e5v.js";
+import"../../shared/stacks-zm0b3tgy.js";
+import"../../shared/stacks-709tra19.js";
+import"../../shared/stacks-d1fmkv3p.js";
+import {
+  Pc
+} from "../../shared/stacks-yfveb68e.js";
+import"../../shared/stacks-f7wdrzs3.js";
+import"../../shared/stacks-yfgsm6ap.js";
+import {
+  Cl
+} from "../../shared/stacks-j2cy7qtt.js";
+import"../../shared/stacks-8yykgdww.js";
+import"../../shared/stacks-v9jqcpd4.js";
+import {
+  hash160
+} from "../../shared/stacks-bycy6t9k.js";
+import"../../shared/stacks-gjvbq6w7.js";
+import"../../shared/stacks-nqytwfcc.js";
+import"../../shared/stacks-8m9byk2j.js";
+
+// src/bns/abi.ts
+var BNS_ABI = {
+  functions: [
+    {
+      name: "get-owner-name",
+      access: "read-only",
+      args: [
+        { name: "name", type: { buff: { length: 48 } } },
+        { name: "namespace", type: { buff: { length: 20 } } }
+      ],
+      outputs: {
+        response: {
+          ok: { optional: "principal" },
+          error: "uint128"
+        }
+      }
+    },
+    {
+      name: "get-id-from-bns",
+      access: "read-only",
+      args: [
+        { name: "name", type: { buff: { length: 48 } } },
+        { name: "namespace", type: { buff: { length: 20 } } }
+      ],
+      outputs: { optional: "uint128" }
+    },
+    {
+      name: "get-bns-from-id",
+      access: "read-only",
+      args: [{ name: "id", type: "uint128" }],
+      outputs: {
+        optional: {
+          tuple: [
+            { name: "name", type: { buff: { length: 48 } } },
+            { name: "namespace", type: { buff: { length: 20 } } }
+          ]
+        }
+      }
+    },
+    {
+      name: "get-owner",
+      access: "read-only",
+      args: [{ name: "id", type: "uint128" }],
+      outputs: {
+        response: {
+          ok: { optional: "principal" },
+          error: "none"
+        }
+      }
+    },
+    {
+      name: "get-primary",
+      access: "read-only",
+      args: [{ name: "owner", type: "principal" }],
+      outputs: {
+        response: {
+          ok: {
+            optional: {
+              tuple: [
+                { name: "name", type: { buff: { length: 48 } } },
+                { name: "namespace", type: { buff: { length: 20 } } }
+              ]
+            }
+          },
+          error: "none"
+        }
+      }
+    },
+    {
+      name: "can-resolve-name",
+      access: "read-only",
+      args: [
+        { name: "namespace", type: { buff: { length: 20 } } },
+        { name: "name", type: { buff: { length: 48 } } }
+      ],
+      outputs: {
+        response: {
+          ok: {
+            tuple: [
+              { name: "renewal", type: "uint128" },
+              { name: "owner", type: "principal" }
+            ]
+          },
+          error: "uint128"
+        }
+      }
+    },
+    {
+      name: "get-renewal-height",
+      access: "read-only",
+      args: [{ name: "id", type: "uint128" }],
+      outputs: { response: { ok: "uint128", error: "uint128" } }
+    },
+    {
+      name: "get-name-price",
+      access: "read-only",
+      args: [
+        { name: "namespace", type: { buff: { length: 20 } } },
+        { name: "name", type: { buff: { length: 48 } } }
+      ],
+      outputs: {
+        response: {
+          ok: { response: { ok: "uint128", error: "uint128" } },
+          error: "uint128"
+        }
+      }
+    },
+    {
+      name: "get-bns-info",
+      access: "read-only",
+      args: [
+        { name: "name", type: { buff: { length: 48 } } },
+        { name: "namespace", type: { buff: { length: 20 } } }
+      ],
+      outputs: {
+        optional: {
+          tuple: [
+            { name: "hashed-salted-fqn-preorder", type: { optional: { buff: { length: 20 } } } },
+            { name: "imported-at", type: { optional: "uint128" } },
+            { name: "owner", type: "principal" },
+            { name: "preordered-by", type: { optional: "principal" } },
+            { name: "registered-at", type: { optional: "uint128" } },
+            { name: "renewal-height", type: "uint128" },
+            { name: "stx-burn", type: "uint128" }
+          ]
+        }
+      }
+    },
+    {
+      name: "name-preorder",
+      access: "public",
+      args: [
+        { name: "hashed-salted-fqn", type: { buff: { length: 20 } } },
+        { name: "stx-to-burn", type: "uint128" }
+      ],
+      outputs: { response: { ok: "uint128", error: "uint128" } }
+    },
+    {
+      name: "name-register",
+      access: "public",
+      args: [
+        { name: "namespace", type: { buff: { length: 20 } } },
+        { name: "name", type: { buff: { length: 48 } } },
+        { name: "salt", type: { buff: { length: 20 } } }
+      ],
+      outputs: { response: { ok: "uint128", error: "uint128" } }
+    },
+    {
+      name: "name-claim-fast",
+      access: "public",
+      args: [
+        { name: "name", type: { buff: { length: 48 } } },
+        { name: "namespace", type: { buff: { length: 20 } } },
+        { name: "send-to", type: "principal" }
+      ],
+      outputs: { response: { ok: "uint128", error: "uint128" } }
+    },
+    {
+      name: "name-renewal",
+      access: "public",
+      args: [
+        { name: "namespace", type: { buff: { length: 20 } } },
+        { name: "name", type: { buff: { length: 48 } } }
+      ],
+      outputs: { response: { ok: "bool", error: "uint128" } }
+    },
+    {
+      name: "transfer",
+      access: "public",
+      args: [
+        { name: "id", type: "uint128" },
+        { name: "owner", type: "principal" },
+        { name: "recipient", type: "principal" }
+      ],
+      outputs: { response: { ok: "bool", error: "uint128" } }
+    },
+    {
+      name: "set-primary-name",
+      access: "public",
+      args: [{ name: "primary-name-id", type: "uint128" }],
+      outputs: { response: { ok: "bool", error: "uint128" } }
+    }
+  ],
+  non_fungible_tokens: [{ name: "BNS-V2", type: "uint128" }]
+};
+
+// src/bns/zonefile-abi.ts
+var ZONEFILE_RESOLVER_ABI = {
+  functions: [
+    {
+      name: "resolve-name",
+      access: "read-only",
+      args: [
+        { name: "name", type: { buff: { length: 48 } } },
+        { name: "namespace", type: { buff: { length: 20 } } }
+      ],
+      outputs: {
+        response: {
+          ok: { optional: { buff: { length: 8192 } } },
+          error: "uint128"
+        }
+      }
+    },
+    {
+      name: "update-zonefile",
+      access: "public",
+      args: [
+        { name: "name", type: { buff: { length: 48 } } },
+        { name: "namespace", type: { buff: { length: 20 } } },
+        { name: "new-zonefile", type: { optional: { buff: { length: 8192 } } } }
+      ],
+      outputs: { response: { ok: "bool", error: "uint128" } }
+    },
+    {
+      name: "revoke-name",
+      access: "public",
+      args: [
+        { name: "name", type: { buff: { length: 48 } } },
+        { name: "namespace", type: { buff: { length: 20 } } }
+      ],
+      outputs: { response: { ok: "bool", error: "uint128" } }
+    }
+  ]
+};
+
+// src/bns/constants.ts
+var BNS_CONTRACTS = {
+  mainnet: {
+    address: "SP2QEZ06AGJ3RKJPBV14SY1V5BBFNAW33D96YPGZF",
+    name: "BNS-V2"
+  },
+  testnet: {
+    address: "ST2QEZ06AGJ3RKJPBV14SY1V5BBFNAW33D9SZJQ0M",
+    name: "BNS-V2"
+  }
+};
+var ZONEFILE_RESOLVER_CONTRACTS = {
+  mainnet: {
+    address: "SP2QEZ06AGJ3RKJPBV14SY1V5BBFNAW33D96YPGZF",
+    name: "zonefile-resolver"
+  },
+  testnet: {
+    address: "ST2QEZ06AGJ3RKJPBV14SY1V5BBFNAW33D9SZJQ0M",
+    name: "zonefile-resolver"
+  }
+};
+var DEFAULT_NAMESPACE = "btc";
+
+// src/bns/utils.ts
+function parseFQN(fqn) {
+  const parts = fqn.split(".");
+  if (parts.length === 1) {
+    return {
+      name: parts[0],
+      namespace: DEFAULT_NAMESPACE
+    };
+  }
+  if (parts.length === 2) {
+    return {
+      name: parts[0],
+      namespace: parts[1]
+    };
+  }
+  throw new Error(`Invalid fully qualified name: ${fqn}. Expected format: "name.namespace" or "name"`);
+}
+function formatFQN(name, namespace) {
+  return `${name}.${namespace}`;
+}
+function validateName(name) {
+  if (name.length < 1 || name.length > 48)
+    return false;
+  const regex = /^[a-z0-9]([a-z0-9_-]*[a-z0-9])?$/;
+  return regex.test(name);
+}
+function validateNamespace(namespace) {
+  if (namespace.length < 1 || namespace.length > 20)
+    return false;
+  const regex = /^[a-z0-9]+$/;
+  return regex.test(namespace);
+}
+function validateFQN(fqn) {
+  try {
+    const { name, namespace } = parseFQN(fqn);
+    return validateName(name) && validateNamespace(namespace);
+  } catch {
+    return false;
+  }
+}
+function generateSalt() {
+  const salt = new Uint8Array(20);
+  crypto.getRandomValues(salt);
+  return salt;
+}
+function hashPreorder(name, namespace, salt) {
+  const nameBytes = new TextEncoder().encode(name);
+  const namespaceBytes = new TextEncoder().encode(namespace);
+  const combined = new Uint8Array(nameBytes.length + namespaceBytes.length + salt.length);
+  combined.set(nameBytes, 0);
+  combined.set(namespaceBytes, nameBytes.length);
+  combined.set(salt, nameBytes.length + namespaceBytes.length);
+  return hash160(combined);
+}
+
+// src/bns/actions.ts
+function getBnsContract(client) {
+  if (!client.chain) {
+    throw new Error("Client must have a chain configured");
+  }
+  const network = client.chain.network;
+  const contract = network === "mainnet" ? BNS_CONTRACTS.mainnet : BNS_CONTRACTS.testnet;
+  return getContract({
+    client,
+    address: contract.address,
+    name: contract.name,
+    abi: BNS_ABI
+  });
+}
+function getZonefileContract(client) {
+  if (!client.chain) {
+    throw new Error("Client must have a chain configured");
+  }
+  const network = client.chain.network;
+  const contract = network === "mainnet" ? ZONEFILE_RESOLVER_CONTRACTS.mainnet : ZONEFILE_RESOLVER_CONTRACTS.testnet;
+  return getContract({
+    client,
+    address: contract.address,
+    name: contract.name,
+    abi: ZONEFILE_RESOLVER_ABI
+  });
+}
+function stringToBytes(str) {
+  return new TextEncoder().encode(str);
+}
+async function resolveName(client, nameOrFQN) {
+  if (!validateFQN(nameOrFQN)) {
+    throw new Error(`Invalid name format: ${nameOrFQN}`);
+  }
+  const { name, namespace } = parseFQN(nameOrFQN);
+  const bns = getBnsContract(client);
+  const owner = await bns.read["get-owner-name"]({
+    name: stringToBytes(name),
+    namespace: stringToBytes(namespace)
+  });
+  return owner;
+}
+async function getPrimaryName(client, address) {
+  const bns = getBnsContract(client);
+  const result = await bns.read["get-primary"]({
+    owner: address
+  });
+  if (result === null)
+    return null;
+  const name = new TextDecoder().decode(result.name);
+  const namespace = new TextDecoder().decode(result.namespace);
+  return formatFQN(name, namespace);
+}
+async function canRegister(client, nameOrFQN) {
+  if (!validateFQN(nameOrFQN)) {
+    throw new Error(`Invalid name format: ${nameOrFQN}`);
+  }
+  const { name, namespace } = parseFQN(nameOrFQN);
+  const bns = getBnsContract(client);
+  try {
+    await bns.read["can-resolve-name"]({
+      namespace: stringToBytes(namespace),
+      name: stringToBytes(name)
+    });
+    return false;
+  } catch {
+    return true;
+  }
+}
+async function getNamePrice(client, nameOrFQN) {
+  if (!validateFQN(nameOrFQN)) {
+    throw new Error(`Invalid name format: ${nameOrFQN}`);
+  }
+  const { name, namespace } = parseFQN(nameOrFQN);
+  const bns = getBnsContract(client);
+  const result = await bns.read["get-name-price"]({
+    namespace: stringToBytes(namespace),
+    name: stringToBytes(name)
+  });
+  if ("ok" in result)
+    return result.ok;
+  throw new Error(`Failed to get name price for ${nameOrFQN}`);
+}
+async function getNameId(client, nameOrFQN) {
+  if (!validateFQN(nameOrFQN)) {
+    throw new Error(`Invalid name format: ${nameOrFQN}`);
+  }
+  const { name, namespace } = parseFQN(nameOrFQN);
+  const bns = getBnsContract(client);
+  return await bns.read["get-id-from-bns"]({
+    name: stringToBytes(name),
+    namespace: stringToBytes(namespace)
+  });
+}
+async function preorder(client, params) {
+  const { name: nameInput, namespace: namespaceInput, salt: providedSalt } = params;
+  const fqn = namespaceInput ? `${nameInput}.${namespaceInput}` : nameInput;
+  if (!validateFQN(fqn)) {
+    throw new Error(`Invalid name format: ${fqn}`);
+  }
+  const { name, namespace } = parseFQN(fqn);
+  const available = await canRegister(client, fqn);
+  if (!available) {
+    throw new Error(`Name ${fqn} is not available for registration`);
+  }
+  const price = await getNamePrice(client, fqn);
+  const salt = providedSalt ?? generateSalt();
+  const hashedSaltedFqn = hashPreorder(name, namespace, salt);
+  const bns = getBnsContract(client);
+  const txid = await bns.call["name-preorder"]({
+    hashedSaltedFqn,
+    stxToBurn: price
+  }, {
+    postConditions: [Pc.principal(client.account.address).willSendLte(price).ustx()]
+  });
+  return { txid, salt };
+}
+async function register(client, params) {
+  const { name: nameInput, namespace: namespaceInput, salt } = params;
+  const fqn = namespaceInput ? `${nameInput}.${namespaceInput}` : nameInput;
+  if (!validateFQN(fqn)) {
+    throw new Error(`Invalid name format: ${fqn}`);
+  }
+  const { name, namespace } = parseFQN(fqn);
+  const bns = getBnsContract(client);
+  return bns.call["name-register"]({
+    name: stringToBytes(name),
+    namespace: stringToBytes(namespace),
+    salt
+  });
+}
+async function claimFast(client, params) {
+  const { name: nameInput, namespace: namespaceInput, recipient } = params;
+  const fqn = namespaceInput ? `${nameInput}.${namespaceInput}` : nameInput;
+  if (!validateFQN(fqn)) {
+    throw new Error(`Invalid name format: ${fqn}`);
+  }
+  const { name, namespace } = parseFQN(fqn);
+  const available = await canRegister(client, fqn);
+  if (!available) {
+    throw new Error(`Name ${fqn} is not available for registration`);
+  }
+  const price = await getNamePrice(client, fqn);
+  const bns = getBnsContract(client);
+  return bns.call["name-claim-fast"]({
+    name: stringToBytes(name),
+    namespace: stringToBytes(namespace),
+    sendTo: recipient
+  }, {
+    postConditions: [Pc.principal(recipient).willSendLte(price).ustx()]
+  });
+}
+async function transfer(client, params) {
+  const { name: nameInput, namespace: namespaceInput, recipient } = params;
+  const fqn = namespaceInput ? `${nameInput}.${namespaceInput}` : nameInput;
+  if (!validateFQN(fqn)) {
+    throw new Error(`Invalid name format: ${fqn}`);
+  }
+  const id = await getNameId(client, fqn);
+  if (id === null) {
+    throw new Error(`Name ${fqn} does not exist`);
+  }
+  const currentOwner = await resolveName(client, fqn);
+  if (!currentOwner) {
+    throw new Error(`Cannot determine owner of ${fqn}`);
+  }
+  const bns = getBnsContract(client);
+  if (!client.chain) {
+    throw new Error("Client must have a chain configured");
+  }
+  const network = client.chain.network;
+  const contract = network === "mainnet" ? BNS_CONTRACTS.mainnet : BNS_CONTRACTS.testnet;
+  return bns.call.transfer({
+    id,
+    owner: currentOwner,
+    recipient
+  }, {
+    postConditions: [
+      Pc.principal(currentOwner).willSendAsset().nft(`${contract.address}.${contract.name}::BNS-V2`, Cl.uint(id))
+    ]
+  });
+}
+async function setPrimary(client, params) {
+  const { name: nameInput, namespace: namespaceInput } = params;
+  const fqn = namespaceInput ? `${nameInput}.${namespaceInput}` : nameInput;
+  if (!validateFQN(fqn)) {
+    throw new Error(`Invalid name format: ${fqn}`);
+  }
+  const id = await getNameId(client, fqn);
+  if (id === null) {
+    throw new Error(`Name ${fqn} does not exist`);
+  }
+  const bns = getBnsContract(client);
+  return bns.call["set-primary-name"]({ primaryNameId: id });
+}
+async function getZonefile(client, nameOrFQN) {
+  if (!validateFQN(nameOrFQN)) {
+    throw new Error(`Invalid name format: ${nameOrFQN}`);
+  }
+  const { name, namespace } = parseFQN(nameOrFQN);
+  const zonefile = getZonefileContract(client);
+  try {
+    const result = await zonefile.read["resolve-name"]({
+      name: stringToBytes(name),
+      namespace: stringToBytes(namespace)
+    });
+    return result;
+  } catch {
+    return null;
+  }
+}
+async function updateZonefile(client, params) {
+  const { name: nameInput, namespace: namespaceInput, zonefile } = params;
+  const fqn = namespaceInput ? `${nameInput}.${namespaceInput}` : nameInput;
+  if (!validateFQN(fqn)) {
+    throw new Error(`Invalid name format: ${fqn}`);
+  }
+  const { name, namespace } = parseFQN(fqn);
+  const currentOwner = await resolveName(client, fqn);
+  if (!currentOwner) {
+    throw new Error(`Name ${fqn} does not exist`);
+  }
+  const zonefileContract = getZonefileContract(client);
+  let zonefileBytes = null;
+  if (zonefile !== null) {
+    zonefileBytes = typeof zonefile === "string" ? new TextEncoder().encode(zonefile) : zonefile;
+    if (zonefileBytes.length > 8192) {
+      throw new Error(`Zonefile too large: ${zonefileBytes.length} bytes (max 8192)`);
+    }
+  }
+  return zonefileContract.call["update-zonefile"]({
+    name: stringToBytes(name),
+    namespace: stringToBytes(namespace),
+    newZonefile: zonefileBytes
+  });
+}
+async function revokeZonefile(client, nameOrFQN) {
+  if (!validateFQN(nameOrFQN)) {
+    throw new Error(`Invalid name format: ${nameOrFQN}`);
+  }
+  const { name, namespace } = parseFQN(nameOrFQN);
+  const zonefileContract = getZonefileContract(client);
+  return zonefileContract.call["revoke-name"]({
+    name: stringToBytes(name),
+    namespace: stringToBytes(namespace)
+  });
+}
+
+// src/bns/index.ts
+function bns() {
+  return (client) => ({
+    bns: {
+      resolveName: (name) => resolveName(client, name),
+      getPrimaryName: (address) => getPrimaryName(client, address),
+      canRegister: (name) => canRegister(client, name),
+      getNamePrice: (name) => getNamePrice(client, name),
+      getNameId: (name) => getNameId(client, name),
+      preorder: (params) => preorder(client, params),
+      register: (params) => register(client, params),
+      claimFast: (params) => claimFast(client, params),
+      transfer: (params) => transfer(client, params),
+      setPrimary: (params) => setPrimary(client, params),
+      getZonefile: (name) => getZonefile(client, name),
+      updateZonefile: (params) => updateZonefile(client, params),
+      revokeZonefile: (name) => revokeZonefile(client, name)
+    }
+  });
+}
+export {
+  validateNamespace,
+  validateName,
+  validateFQN,
+  parseFQN,
+  hashPreorder,
+  generateSalt,
+  formatFQN,
+  bns,
+  ZONEFILE_RESOLVER_CONTRACTS,
+  BNS_CONTRACTS
+};
+
+//# debugId=0D633A7E4933680A64756E2164756E21
+//# sourceMappingURL=index.js.map