@aptos-labs/ts-sdk 1.14.0-zeta.2 → 1.14.0-zeta.4

package/dist/esm/chunk-DGV7DYU4.mjs

@@ -1,413 +0,0 @@
-import {
-  generateTransaction
-} from "./chunk-IHNPN5CQ.mjs";
-import {
-  view
-} from "./chunk-RCQMWXEW.mjs";
-import {
-  queryIndexer
-} from "./chunk-LYMY63SO.mjs";
-import {
-  GetNames
-} from "./chunk-4PJ5FYGQ.mjs";
-import {
-  AccountAddress
-} from "./chunk-CMNJG4NN.mjs";
-
-// src/internal/ans.ts
-var VALIDATION_RULES_DESCRIPTION = [
-  "A name must be between 3 and 63 characters long,",
-  "and can only contain lowercase a-z, 0-9, and hyphens.",
-  "A name may not start or end with a hyphen."
-].join(" ");
-function isValidANSSegment(fragment) {
-  if (!fragment)
-    return false;
-  if (fragment.length < 3)
-    return false;
-  if (fragment.length > 63)
-    return false;
-  if (!/^[a-z\d][a-z\d-]{1,61}[a-z\d]$/.test(fragment))
-    return false;
-  return true;
-}
-function isValidANSName(name) {
-  const [first, second, ...rest] = name.replace(/\.apt$/, "").split(".");
-  if (rest.length > 0) {
-    throw new Error(`${name} is invalid. A name can only have two parts, a domain and a subdomain separated by a "."`);
-  }
-  if (!isValidANSSegment(first)) {
-    throw new Error(`${first} is not valid. ${VALIDATION_RULES_DESCRIPTION}`);
-  }
-  if (second && !isValidANSSegment(second)) {
-    throw new Error(`${second} is not valid. ${VALIDATION_RULES_DESCRIPTION}`);
-  }
-  return {
-    domainName: second || first,
-    subdomainName: second ? first : void 0
-  };
-}
-var LOCAL_ANS_ACCOUNT_PK = "0x37368b46ce665362562c6d1d4ec01a08c8644c488690df5a17e13ba163e20221";
-var LOCAL_ANS_ACCOUNT_ADDRESS = "0x585fc9f0f0c54183b039ffc770ca282ebd87307916c215a3e692f2f8e4305e82";
-var NetworkToAnsContract = {
-  ["testnet" /* TESTNET */]: "0x5f8fd2347449685cf41d4db97926ec3a096eaf381332be4f1318ad4d16a8497c",
-  ["mainnet" /* MAINNET */]: "0x867ed1f6bf916171b1de3ee92849b8978b7d1b9e0a8cc982a3d19d535dfd9c0c",
-  ["local" /* LOCAL */]: LOCAL_ANS_ACCOUNT_ADDRESS,
-  ["custom" /* CUSTOM */]: null,
-  ["devnet" /* DEVNET */]: null
-};
-function getRouterAddress(aptosConfig) {
-  const address = NetworkToAnsContract[aptosConfig.network];
-  if (!address)
-    throw new Error(`The ANS contract is not deployed to ${aptosConfig.network}`);
-  return address;
-}
-var unwrapOption = (option) => {
-  if (!!option && typeof option === "object" && "vec" in option && Array.isArray(option.vec)) {
-    return option.vec[0];
-  }
-  return void 0;
-};
-async function getOwnerAddress(args) {
-  const { aptosConfig, name } = args;
-  const routerAddress = getRouterAddress(aptosConfig);
-  const { domainName, subdomainName } = isValidANSName(name);
-  const res = await view({
-    aptosConfig,
-    payload: {
-      function: `${routerAddress}::router::get_owner_addr`,
-      functionArguments: [domainName, subdomainName]
-    }
-  });
-  const owner = unwrapOption(res[0]);
-  return owner ? AccountAddress.from(owner) : void 0;
-}
-async function registerName(args) {
-  const { aptosConfig, expiration, name, sender, targetAddress, toAddress, options, transferable } = args;
-  const routerAddress = getRouterAddress(aptosConfig);
-  const { domainName, subdomainName } = isValidANSName(name);
-  const hasSubdomainPolicy = expiration.policy === "subdomain:independent" || expiration.policy === "subdomain:follow-domain";
-  if (subdomainName && !hasSubdomainPolicy) {
-    throw new Error(
-      "Subdomains must have an expiration policy of either 'subdomain:independent' or 'subdomain:follow-domain'"
-    );
-  }
-  if (hasSubdomainPolicy && !subdomainName) {
-    throw new Error(`Policy is set to ${expiration.policy} but no subdomain was provided`);
-  }
-  if (expiration.policy === "domain") {
-    const years = expiration.years ?? 1;
-    if (years !== 1) {
-      throw new Error("For now, names can only be registered for 1 year at a time");
-    }
-    const secondsInYear = 31536e3;
-    const registrationDuration = years * secondsInYear;
-    const transaction2 = await generateTransaction({
-      aptosConfig,
-      sender: sender.accountAddress.toString(),
-      data: {
-        function: `${routerAddress}::router::register_domain`,
-        functionArguments: [domainName, registrationDuration, targetAddress, toAddress]
-      },
-      options
-    });
-    return transaction2;
-  }
-  if (!subdomainName) {
-    throw new Error(`${expiration.policy} requires a subdomain to be provided.`);
-  }
-  const tldExpiration = await getExpiration({ aptosConfig, name: domainName });
-  if (!tldExpiration) {
-    throw new Error("The domain does not exist");
-  }
-  const expirationDateInMillisecondsSinceEpoch = expiration.policy === "subdomain:independent" ? expiration.expirationDate : tldExpiration;
-  if (expirationDateInMillisecondsSinceEpoch > tldExpiration) {
-    throw new Error("The subdomain expiration time cannot be greater than the domain expiration time");
-  }
-  const transaction = await generateTransaction({
-    aptosConfig,
-    sender: sender.accountAddress.toString(),
-    data: {
-      function: `${routerAddress}::router::register_subdomain`,
-      functionArguments: [
-        domainName,
-        subdomainName,
-        Math.round(expirationDateInMillisecondsSinceEpoch / 1e3),
-        expiration.policy === "subdomain:follow-domain" ? 1 : 0,
-        !!transferable,
-        targetAddress,
-        toAddress
-      ]
-    },
-    options
-  });
-  return transaction;
-}
-async function getExpiration(args) {
-  const { aptosConfig, name } = args;
-  const routerAddress = getRouterAddress(aptosConfig);
-  const { domainName, subdomainName } = isValidANSName(name);
-  try {
-    const res = await view({
-      aptosConfig,
-      payload: {
-        function: `${routerAddress}::router::get_expiration`,
-        functionArguments: [domainName, subdomainName]
-      }
-    });
-    return Number(res[0]) * 1e3;
-  } catch (e) {
-    return void 0;
-  }
-}
-async function getPrimaryName(args) {
-  const { aptosConfig, address } = args;
-  const routerAddress = getRouterAddress(aptosConfig);
-  const res = await view({
-    aptosConfig,
-    payload: {
-      function: `${routerAddress}::router::get_primary_name`,
-      functionArguments: [AccountAddress.from(address).toString()]
-    }
-  });
-  const domainName = unwrapOption(res[1]);
-  const subdomainName = unwrapOption(res[0]);
-  if (!domainName)
-    return void 0;
-  return [subdomainName, domainName].filter(Boolean).join(".");
-}
-async function setPrimaryName(args) {
-  const { aptosConfig, sender, name, options } = args;
-  const routerAddress = getRouterAddress(aptosConfig);
-  if (!name) {
-    const transaction2 = await generateTransaction({
-      aptosConfig,
-      sender: sender.accountAddress.toString(),
-      data: {
-        function: `${routerAddress}::router::clear_primary_name`,
-        functionArguments: []
-      },
-      options
-    });
-    return transaction2;
-  }
-  const { domainName, subdomainName } = isValidANSName(name);
-  const transaction = await generateTransaction({
-    aptosConfig,
-    sender: sender.accountAddress.toString(),
-    data: {
-      function: `${routerAddress}::router::set_primary_name`,
-      functionArguments: [domainName, subdomainName]
-    },
-    options
-  });
-  return transaction;
-}
-async function getTargetAddress(args) {
-  const { aptosConfig, name } = args;
-  const routerAddress = getRouterAddress(aptosConfig);
-  const { domainName, subdomainName } = isValidANSName(name);
-  const res = await view({
-    aptosConfig,
-    payload: {
-      function: `${routerAddress}::router::get_target_addr`,
-      functionArguments: [domainName, subdomainName]
-    }
-  });
-  const target = unwrapOption(res[0]);
-  return target ? AccountAddress.from(target) : void 0;
-}
-async function setTargetAddress(args) {
-  const { aptosConfig, sender, name, address, options } = args;
-  const routerAddress = getRouterAddress(aptosConfig);
-  const { domainName, subdomainName } = isValidANSName(name);
-  const transaction = await generateTransaction({
-    aptosConfig,
-    sender: sender.accountAddress.toString(),
-    data: {
-      function: `${routerAddress}::router::set_target_addr`,
-      functionArguments: [domainName, subdomainName, address]
-    },
-    options
-  });
-  return transaction;
-}
-async function getName(args) {
-  const { aptosConfig, name } = args;
-  const { domainName, subdomainName = "" } = isValidANSName(name);
-  const where = {
-    domain: { _eq: domainName },
-    subdomain: { _eq: subdomainName },
-    is_active: { _eq: true }
-  };
-  const data = await queryIndexer({
-    aptosConfig,
-    query: {
-      query: GetNames,
-      variables: {
-        where_condition: where,
-        limit: 1
-      }
-    },
-    originMethod: "getName"
-  });
-  let res = data.current_aptos_names[0];
-  if (res) {
-    res = sanitizeANSName(res);
-  }
-  return res;
-}
-async function getAccountNames(args) {
-  const { aptosConfig, options, accountAddress } = args;
-  const expirationDate = await getANSExpirationDate({ aptosConfig });
-  const data = await queryIndexer({
-    aptosConfig,
-    originMethod: "getAccountNames",
-    query: {
-      query: GetNames,
-      variables: {
-        limit: options?.limit,
-        offset: options?.offset,
-        order_by: options?.orderBy,
-        where_condition: {
-          ...args.options?.where ?? {},
-          owner_address: { _eq: accountAddress.toString() },
-          expiration_timestamp: { _gte: expirationDate }
-        }
-      }
-    }
-  });
-  return data.current_aptos_names.map(sanitizeANSName);
-}
-async function getAccountDomains(args) {
-  const { aptosConfig, options, accountAddress } = args;
-  const expirationDate = await getANSExpirationDate({ aptosConfig });
-  const data = await queryIndexer({
-    aptosConfig,
-    originMethod: "getAccountDomains",
-    query: {
-      query: GetNames,
-      variables: {
-        limit: options?.limit,
-        offset: options?.offset,
-        order_by: options?.orderBy,
-        where_condition: {
-          ...args.options?.where ?? {},
-          owner_address: { _eq: accountAddress.toString() },
-          expiration_timestamp: { _gte: expirationDate },
-          subdomain: { _eq: "" }
-        }
-      }
-    }
-  });
-  return data.current_aptos_names.map(sanitizeANSName);
-}
-async function getAccountSubdomains(args) {
-  const { aptosConfig, options, accountAddress } = args;
-  const expirationDate = await getANSExpirationDate({ aptosConfig });
-  const data = await queryIndexer({
-    aptosConfig,
-    originMethod: "getAccountSubdomains",
-    query: {
-      query: GetNames,
-      variables: {
-        limit: options?.limit,
-        offset: options?.offset,
-        order_by: options?.orderBy,
-        where_condition: {
-          ...args.options?.where ?? {},
-          owner_address: { _eq: accountAddress.toString() },
-          expiration_timestamp: { _gte: expirationDate },
-          subdomain: { _neq: "" }
-        }
-      }
-    }
-  });
-  return data.current_aptos_names.map(sanitizeANSName);
-}
-async function getDomainSubdomains(args) {
-  const { aptosConfig, options, domain } = args;
-  const data = await queryIndexer({
-    aptosConfig,
-    originMethod: "getDomainSubdomains",
-    query: {
-      query: GetNames,
-      variables: {
-        limit: options?.limit,
-        offset: options?.offset,
-        order_by: options?.orderBy,
-        where_condition: {
-          ...args.options?.where ?? {},
-          domain: { _eq: domain },
-          subdomain: { _neq: "" },
-          is_active: { _eq: true }
-        }
-      }
-    }
-  });
-  return data.current_aptos_names.map(sanitizeANSName);
-}
-async function getANSExpirationDate(args) {
-  const { aptosConfig } = args;
-  const routerAddress = getRouterAddress(aptosConfig);
-  const [gracePeriodInSeconds] = await view({
-    aptosConfig,
-    payload: {
-      function: `${routerAddress}::config::reregistration_grace_sec`,
-      functionArguments: []
-    }
-  });
-  const gracePeriodInDays = gracePeriodInSeconds / 60 / 60 / 24;
-  const now = () => /* @__PURE__ */ new Date();
-  return new Date(now().setDate(now().getDate() - gracePeriodInDays)).toISOString();
-}
-async function renewDomain(args) {
-  const { aptosConfig, sender, name, years = 1, options } = args;
-  const routerAddress = getRouterAddress(aptosConfig);
-  const renewalDuration = years * 31536e3;
-  const { domainName, subdomainName } = isValidANSName(name);
-  if (subdomainName) {
-    throw new Error("Subdomains cannot be renewed");
-  }
-  if (years !== 1) {
-    throw new Error("Currently, only 1 year renewals are supported");
-  }
-  const transaction = await generateTransaction({
-    aptosConfig,
-    sender: sender.accountAddress.toString(),
-    data: {
-      function: `${routerAddress}::router::renew_domain`,
-      functionArguments: [domainName, renewalDuration]
-    },
-    options
-  });
-  return transaction;
-}
-function sanitizeANSName(name) {
-  return {
-    ...name,
-    expiration_timestamp: new Date(name.expiration_timestamp).getTime()
-  };
-}
-
-export {
-  VALIDATION_RULES_DESCRIPTION,
-  isValidANSSegment,
-  isValidANSName,
-  LOCAL_ANS_ACCOUNT_PK,
-  LOCAL_ANS_ACCOUNT_ADDRESS,
-  getOwnerAddress,
-  registerName,
-  getExpiration,
-  getPrimaryName,
-  setPrimaryName,
-  getTargetAddress,
-  setTargetAddress,
-  getName,
-  getAccountNames,
-  getAccountDomains,
-  getAccountSubdomains,
-  getDomainSubdomains,
-  renewDomain
-};
-//# sourceMappingURL=chunk-DGV7DYU4.mjs.map

package/dist/esm/chunk-DIYZRGR6.mjs

@@ -1,242 +0,0 @@
-import {
-  Signature
-} from "./chunk-FDWJNY4U.mjs";
-import {
-  convertSigningMessage
-} from "./chunk-NMKCJNQM.mjs";
-import {
-  PublicKey
-} from "./chunk-FXKSE3ZP.mjs";
-import {
-  isValidBIP44Path,
-  mnemonicToSeed
-} from "./chunk-PU5AFUX3.mjs";
-import {
-  Serializable
-} from "./chunk-FQQW55X7.mjs";
-import {
-  Hex
-} from "./chunk-YV7M4CFP.mjs";
-
-// src/core/crypto/secp256k1.ts
-import { sha3_256 } from "@noble/hashes/sha3";
-import { secp256k1 } from "@noble/curves/secp256k1";
-import { HDKey } from "@scure/bip32";
-var _Secp256k1PublicKey = class _Secp256k1PublicKey extends PublicKey {
-  /**
-   * Create a new PublicKey instance from a Uint8Array or String.
-   *
-   * @param hexInput A HexInput (string or Uint8Array)
-   */
-  constructor(hexInput) {
-    super();
-    const hex = Hex.fromHexInput(hexInput);
-    if (hex.toUint8Array().length !== _Secp256k1PublicKey.LENGTH) {
-      throw new Error(`PublicKey length should be ${_Secp256k1PublicKey.LENGTH}`);
-    }
-    this.key = hex;
-  }
-  // region PublicKey
-  /**
-   * Verifies a Secp256k1 signature against the public key
-   *
-   * Note signatures are validated to be canonical as a malleability check
-   */
-  verifySignature(args) {
-    const { message, signature } = args;
-    if (!(signature instanceof Secp256k1Signature)) {
-      return false;
-    }
-    const messageToVerify = convertSigningMessage(message);
-    const messageBytes = Hex.fromHexInput(messageToVerify).toUint8Array();
-    const messageSha3Bytes = sha3_256(messageBytes);
-    const signatureBytes = signature.toUint8Array();
-    return secp256k1.verify(signatureBytes, messageSha3Bytes, this.key.toUint8Array(), { lowS: true });
-  }
-  toUint8Array() {
-    return this.key.toUint8Array();
-  }
-  // endregion
-  // region Serializable
-  serialize(serializer) {
-    serializer.serializeBytes(this.key.toUint8Array());
-  }
-  static deserialize(deserializer) {
-    const bytes = deserializer.deserializeBytes();
-    return new _Secp256k1PublicKey(bytes);
-  }
-  // endregion
-  /**
-   * @deprecated use `instanceof Secp256k1PublicKey` instead
-   * @param publicKey
-   */
-  static isPublicKey(publicKey) {
-    return publicKey instanceof _Secp256k1PublicKey;
-  }
-};
-// Secp256k1 ecdsa public keys contain a prefix indicating compression and two 32-byte coordinates.
-_Secp256k1PublicKey.LENGTH = 65;
-var Secp256k1PublicKey = _Secp256k1PublicKey;
-var _Secp256k1PrivateKey = class _Secp256k1PrivateKey extends Serializable {
-  // region Constructors
-  /**
-   * Create a new PrivateKey instance from a Uint8Array or String.
-   *
-   * @param hexInput A HexInput (string or Uint8Array)
-   */
-  constructor(hexInput) {
-    super();
-    const privateKeyHex = Hex.fromHexInput(hexInput);
-    if (privateKeyHex.toUint8Array().length !== _Secp256k1PrivateKey.LENGTH) {
-      throw new Error(`PrivateKey length should be ${_Secp256k1PrivateKey.LENGTH}`);
-    }
-    this.key = privateKeyHex;
-  }
-  /**
-   * Generate a new random private key.
-   *
-   * @returns Secp256k1PrivateKey
-   */
-  static generate() {
-    const hexInput = secp256k1.utils.randomPrivateKey();
-    return new _Secp256k1PrivateKey(hexInput);
-  }
-  /**
-   * Derives a private key from a mnemonic seed phrase.
-   *
-   * @param path the BIP44 path
-   * @param mnemonics the mnemonic seed phrase
-   *
-   * @returns The generated key
-   */
-  static fromDerivationPath(path, mnemonics) {
-    if (!isValidBIP44Path(path)) {
-      throw new Error(`Invalid derivation path ${path}`);
-    }
-    return _Secp256k1PrivateKey.fromDerivationPathInner(path, mnemonicToSeed(mnemonics));
-  }
-  /**
-   * A private inner function so we can separate from the main fromDerivationPath() method
-   * to add tests to verify we create the keys correctly.
-   *
-   * @param path the BIP44 path
-   * @param seed the seed phrase created by the mnemonics
-   *
-   * @returns The generated key
-   */
-  static fromDerivationPathInner(path, seed) {
-    const { privateKey } = HDKey.fromMasterSeed(seed).derive(path);
-    if (privateKey === null) {
-      throw new Error("Invalid key");
-    }
-    return new _Secp256k1PrivateKey(privateKey);
-  }
-  // endregion
-  // region PrivateKey
-  /**
-   * Sign the given message with the private key.
-   *
-   * Note: signatures are canonical, and non-malleable
-   *
-   * @param message a message as a string or Uint8Array
-   * @returns Signature
-   */
-  sign(message) {
-    const messageToSign = convertSigningMessage(message);
-    const messageBytes = Hex.fromHexInput(messageToSign);
-    const messageHashBytes = sha3_256(messageBytes.toUint8Array());
-    const signature = secp256k1.sign(messageHashBytes, this.key.toUint8Array(), { lowS: true });
-    return new Secp256k1Signature(signature.toCompactRawBytes());
-  }
-  /**
-   * Derive the Secp256k1PublicKey from this private key.
-   *
-   * @returns Secp256k1PublicKey
-   */
-  publicKey() {
-    const bytes = secp256k1.getPublicKey(this.key.toUint8Array(), false);
-    return new Secp256k1PublicKey(bytes);
-  }
-  /**
-   * Get the private key in bytes (Uint8Array).
-   *
-   * @returns
-   */
-  toUint8Array() {
-    return this.key.toUint8Array();
-  }
-  /**
-   * Get the private key as a hex string with the 0x prefix.
-   *
-   * @returns string representation of the private key
-   */
-  toString() {
-    return this.key.toString();
-  }
-  // endregion
-  // region Serializable
-  serialize(serializer) {
-    serializer.serializeBytes(this.toUint8Array());
-  }
-  static deserialize(deserializer) {
-    const bytes = deserializer.deserializeBytes();
-    return new _Secp256k1PrivateKey(bytes);
-  }
-  // endregion
-  /**
-   * @deprecated use `instanceof Secp256k1PrivateKey` instead
-   */
-  static isPrivateKey(privateKey) {
-    return privateKey instanceof _Secp256k1PrivateKey;
-  }
-};
-/**
- * Length of Secp256k1 ecdsa private key
- */
-_Secp256k1PrivateKey.LENGTH = 32;
-var Secp256k1PrivateKey = _Secp256k1PrivateKey;
-var _Secp256k1Signature = class _Secp256k1Signature extends Signature {
-  // region Constructors
-  /**
-   * Create a new Signature instance from a Uint8Array or String.
-   *
-   * @param hexInput A HexInput (string or Uint8Array)
-   */
-  constructor(hexInput) {
-    super();
-    const data = Hex.fromHexInput(hexInput);
-    if (data.toUint8Array().length !== _Secp256k1Signature.LENGTH) {
-      throw new Error(
-        `Signature length should be ${_Secp256k1Signature.LENGTH}, received ${data.toUint8Array().length}`
-      );
-    }
-    this.data = data;
-  }
-  // endregion
-  // region Signature
-  toUint8Array() {
-    return this.data.toUint8Array();
-  }
-  // endregion
-  // region Serializable
-  serialize(serializer) {
-    serializer.serializeBytes(this.data.toUint8Array());
-  }
-  static deserialize(deserializer) {
-    const hex = deserializer.deserializeBytes();
-    return new _Secp256k1Signature(hex);
-  }
-  // endregion
-};
-/**
- * Secp256k1 ecdsa signatures are 256-bit.
- */
-_Secp256k1Signature.LENGTH = 64;
-var Secp256k1Signature = _Secp256k1Signature;
-
-export {
-  Secp256k1PublicKey,
-  Secp256k1PrivateKey,
-  Secp256k1Signature
-};
-//# sourceMappingURL=chunk-DIYZRGR6.mjs.map