@aptos-labs/ts-sdk 1.35.0-zeta.2 → 1.36.0

package/dist/esm/chunk-UK7SPHIE.mjs

@@ -1,420 +0,0 @@
-import {
-  view
-} from "./chunk-ORCQEMJL.mjs";
-import {
-  generateTransaction
-} from "./chunk-HKQY5GXT.mjs";
-import {
-  queryIndexer
-} from "./chunk-YK66QBML.mjs";
-import {
-  GetNames
-} from "./chunk-EPTUAWRA.mjs";
-import {
-  AccountAddress
-} from "./chunk-CXLXUSCG.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 SubdomainExpirationPolicy = /* @__PURE__ */ ((SubdomainExpirationPolicy2) => {
-  SubdomainExpirationPolicy2[SubdomainExpirationPolicy2["Independent"] = 0] = "Independent";
-  SubdomainExpirationPolicy2[SubdomainExpirationPolicy2["FollowsDomain"] = 1] = "FollowsDomain";
-  return SubdomainExpirationPolicy2;
-})(SubdomainExpirationPolicy || {});
-function isActiveANSName(name) {
-  if (!name) return false;
-  const isTLDExpired = new Date(name.domain_expiration_timestamp).getTime() < Date.now();
-  const isExpired = new Date(name.expiration_timestamp).getTime() < Date.now();
-  if (name.subdomain && isTLDExpired) return false;
-  if (name.subdomain && name.subdomain_expiration_policy === 1 /* FollowsDomain */) return true;
-  return !isExpired;
-}
-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 }
-  };
-  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 isActiveANSName(res) ? res : void 0;
-}
-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: "" }
-        }
-      }
-    }
-  });
-  return data.current_aptos_names.map(sanitizeANSName).filter(isActiveANSName);
-}
-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,
-  SubdomainExpirationPolicy,
-  isActiveANSName,
-  LOCAL_ANS_ACCOUNT_PK,
-  LOCAL_ANS_ACCOUNT_ADDRESS,
-  getOwnerAddress,
-  registerName,
-  getExpiration,
-  getPrimaryName,
-  setPrimaryName,
-  getTargetAddress,
-  setTargetAddress,
-  getName,
-  getAccountNames,
-  getAccountDomains,
-  getAccountSubdomains,
-  getDomainSubdomains,
-  renewDomain
-};
-//# sourceMappingURL=chunk-UK7SPHIE.mjs.map

package/dist/esm/chunk-UOHCJOXI.mjs

@@ -1,150 +0,0 @@
-import {
-  Ed25519PublicKey,
-  Ed25519Signature
-} from "./chunk-TFW6N66T.mjs";
-import {
-  PublicKey
-} from "./chunk-R4JTQQBX.mjs";
-import {
-  Signature
-} from "./chunk-KLUO6XPE.mjs";
-import {
-  Deserializer
-} from "./chunk-NUT2VOX2.mjs";
-import {
-  Hex
-} from "./chunk-BDM6FBUO.mjs";
-
-// src/core/crypto/ephemeral.ts
-var EphemeralPublicKey = class _EphemeralPublicKey extends PublicKey {
-  /**
-   * Creates an instance of EphemeralPublicKey using the provided public key.
-   * This constructor ensures that only supported signature types are accepted.
-   *
-   * @param publicKey - The public key to be used for the ephemeral public key.
-   * @throws Error if the signature type is unsupported.
-   * @group Implementation
-   * @category Serialization
-   */
-  constructor(publicKey) {
-    super();
-    const publicKeyType = publicKey.constructor.name;
-    switch (publicKeyType) {
-      case Ed25519PublicKey.name:
-        this.publicKey = publicKey;
-        this.variant = 0 /* Ed25519 */;
-        break;
-      default:
-        throw new Error(`Unsupported key for EphemeralPublicKey - ${publicKeyType}`);
-    }
-  }
-  /**
-   * Verifies a signed message using the ephemeral public key.
-   *
-   * @param args - The arguments for the verification.
-   * @param args.message - The message that was signed.
-   * @param args.signature - The signature that was signed by the private key of the ephemeral public key.
-   * @returns true if the signature is valid, otherwise false.
-   * @group Implementation
-   * @category Serialization
-   */
-  verifySignature(args) {
-    const { message, signature } = args;
-    return this.publicKey.verifySignature({ message, signature: signature.signature });
-  }
-  /**
-   * Serializes the current instance, specifically handling the Ed25519 signature type.
-   * This function ensures that the signature is properly serialized using the provided serializer.
-   *
-   * @param serializer - The serializer instance used to serialize the signature.
-   * @throws Error if the signature type is unknown.
-   * @group Implementation
-   * @category Serialization
-   */
-  serialize(serializer) {
-    if (this.publicKey instanceof Ed25519PublicKey) {
-      serializer.serializeU32AsUleb128(0 /* Ed25519 */);
-      this.publicKey.serialize(serializer);
-    } else {
-      throw new Error("Unknown public key type");
-    }
-  }
-  /**
-   * Deserializes an EphemeralSignature from the provided deserializer.
-   * This function allows you to retrieve an EphemeralSignature based on the deserialized data.
-   *
-   * @param deserializer - The deserializer instance used to read the serialized data.
-   * @group Implementation
-   * @category Serialization
-   */
-  static deserialize(deserializer) {
-    const index = deserializer.deserializeUleb128AsU32();
-    switch (index) {
-      case 0 /* Ed25519 */:
-        return new _EphemeralPublicKey(Ed25519PublicKey.deserialize(deserializer));
-      default:
-        throw new Error(`Unknown variant index for EphemeralPublicKey: ${index}`);
-    }
-  }
-  /**
-   * Determines if the provided public key is an instance of `EphemeralPublicKey`.
-   *
-   * @param publicKey - The public key to check.
-   * @returns A boolean indicating whether the public key is an ephemeral type.
-   * @group Implementation
-   * @category Serialization
-   */
-  static isPublicKey(publicKey) {
-    return publicKey instanceof _EphemeralPublicKey;
-  }
-};
-var EphemeralSignature = class _EphemeralSignature extends Signature {
-  constructor(signature) {
-    super();
-    const signatureType = signature.constructor.name;
-    switch (signatureType) {
-      case Ed25519Signature.name:
-        this.signature = signature;
-        break;
-      default:
-        throw new Error(`Unsupported signature for EphemeralSignature - ${signatureType}`);
-    }
-  }
-  /**
-   * Deserializes an ephemeral signature from a hexadecimal input.
-   * This function allows you to convert a hexadecimal representation of an ephemeral signature into its deserialized form for
-   * further processing.
-   *
-   * @param hexInput - The hexadecimal input representing the ephemeral signature.
-   * @group Implementation
-   * @category Serialization
-   */
-  static fromHex(hexInput) {
-    const data = Hex.fromHexInput(hexInput);
-    const deserializer = new Deserializer(data.toUint8Array());
-    return _EphemeralSignature.deserialize(deserializer);
-  }
-  serialize(serializer) {
-    if (this.signature instanceof Ed25519Signature) {
-      serializer.serializeU32AsUleb128(0 /* Ed25519 */);
-      this.signature.serialize(serializer);
-    } else {
-      throw new Error("Unknown signature type");
-    }
-  }
-  static deserialize(deserializer) {
-    const index = deserializer.deserializeUleb128AsU32();
-    switch (index) {
-      case 0 /* Ed25519 */:
-        return new _EphemeralSignature(Ed25519Signature.deserialize(deserializer));
-      default:
-        throw new Error(`Unknown variant index for EphemeralSignature: ${index}`);
-    }
-  }
-};
-
-export {
-  EphemeralPublicKey,
-  EphemeralSignature
-};
-//# sourceMappingURL=chunk-UOHCJOXI.mjs.map

package/dist/esm/chunk-WHSS6I7T.mjs

@@ -1,90 +0,0 @@
-import {
-  SingleKeyAccount
-} from "./chunk-G7BB6K4B.mjs";
-import {
-  Ed25519Account
-} from "./chunk-62LC4PPC.mjs";
-import {
-  Ed25519PrivateKey
-} from "./chunk-TFW6N66T.mjs";
-
-// src/account/Account.ts
-var Account = class {
-  static generate(args = {}) {
-    const { scheme = 0 /* Ed25519 */, legacy = true } = args;
-    if (scheme === 0 /* Ed25519 */ && legacy) {
-      return Ed25519Account.generate();
-    }
-    return SingleKeyAccount.generate({ scheme });
-  }
-  static fromPrivateKey(args) {
-    const { privateKey, address, legacy = true } = args;
-    if (privateKey instanceof Ed25519PrivateKey && legacy) {
-      return new Ed25519Account({
-        privateKey,
-        address
-      });
-    }
-    return new SingleKeyAccount({ privateKey, address });
-  }
-  /**
-   * @deprecated use `fromPrivateKey` instead.
-   * Instantiates an account using a private key and a specified account address. This is primarily used to instantiate an
-   * `Account` that has had its authentication key rotated.
-   *
-   * @param args - The arguments required to create an account from a private key.
-   * @param args.privateKey - The underlying private key for the account.
-   * @param args.address - The account address the `Account` will sign for.
-   * @param args.legacy - Optional. If set to false, the keypair generated is a Unified keypair. Defaults to generating a Legacy
-   * Ed25519 keypair.
-   *
-   * @returns Account
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  static fromPrivateKeyAndAddress(args) {
-    return this.fromPrivateKey(args);
-  }
-  static fromDerivationPath(args) {
-    const { scheme = 0 /* Ed25519 */, mnemonic, path, legacy = true } = args;
-    if (scheme === 0 /* Ed25519 */ && legacy) {
-      return Ed25519Account.fromDerivationPath({ mnemonic, path });
-    }
-    return SingleKeyAccount.fromDerivationPath({ scheme, mnemonic, path });
-  }
-  /**
-   * Retrieve the authentication key for the associated account using the provided public key.
-   * This key enables account owners to rotate their private key(s) associated with the account without changing the address that
-   * hosts their account.
-   * See here for more info: {@link https://aptos.dev/concepts/accounts#single-signer-authentication}
-   *
-   * @param args - The arguments for retrieving the authentication key.
-   * @param args.publicKey - The public key of the account.
-   * @returns The authentication key for the associated account.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  static authKey(args) {
-    const { publicKey } = args;
-    return publicKey.authKey();
-  }
-  /**
-   * Verify the given message and signature with the public key.
-   * This function helps ensure the integrity and authenticity of a message by validating its signature.
-   *
-   * @param args - The arguments for verifying the signature.
-   * @param args.message - The raw message data in HexInput format.
-   * @param args.signature - The signed message signature.
-   * @returns A boolean indicating whether the signature is valid.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  verifySignature(args) {
-    return this.publicKey.verifySignature(args);
-  }
-};
-
-export {
-  Account
-};
-//# sourceMappingURL=chunk-WHSS6I7T.mjs.map