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

package/dist/esm/chunk-2ZEGJU43.mjs

@@ -1,252 +0,0 @@
-import {
-  getAccountDomains,
-  getAccountNames,
-  getAccountSubdomains,
-  getDomainSubdomains,
-  getExpiration,
-  getName,
-  getOwnerAddress,
-  getPrimaryName,
-  getTargetAddress,
-  registerName,
-  renewDomain,
-  setPrimaryName,
-  setTargetAddress
-} from "./chunk-DGV7DYU4.mjs";
-
-// src/api/ans.ts
-var ANS = class {
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * Retrieve the owner address of a domain name or subdomain name from the contract.
-   *
-   * @example
-   * // Will return the owner address of "test.aptos.apt" or undefined
-   * const owner = await aptos.getOwnerAddress({name: "test.aptos"})
-   * // owner = 0x123...
-   *
-   * @param args.name - A string of the name to retrieve
-   *
-   * @returns AccountAddress if the name is owned, undefined otherwise
-   */
-  async getOwnerAddress(args) {
-    return getOwnerAddress({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Retrieve the expiration time of a domain name or subdomain name from the contract.
-   *
-   * @example
-   * // Will return the expiration of "test.aptos.apt" or undefined
-   * const exp = await aptos.getExpiration({name: "test.aptos"})
-   * // new Date(exp) would give you the date in question: 2021-01-01T00:00:00.000Z
-   *
-   * @param args.name - A string of the name to retrieve
-   *
-   * @returns number as a unix timestamp in milliseconds.
-   */
-  async getExpiration(args) {
-    return getExpiration({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Retrieve the target address of a domain or subdomain name. This is the
-   * address the name points to for use on chain. Note, the target address can
-   * point to addresses that are not the owner of the name
-   *
-   * @example
-   * const targetAddr = await aptos.getTargetAddress({name: "test.aptos"})
-   * // targetAddr = 0x123...
-   *
-   * @param args.name - A string of the name: primary, primary.apt, secondary.primary, secondary.primary.apt, etc.
-   *
-   * @returns AccountAddress if the name has a target, undefined otherwise
-   */
-  async getTargetAddress(args) {
-    return getTargetAddress({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Sets the target address of a domain or subdomain name. This is the
-   * address the name points to for use on chain. Note, the target address can
-   * point to addresses that are not the owner of the name
-   *
-   * @example
-   * await aptos.setTargetAddress({sender: alice, name: "test.aptos", address: bob.accountAddress})
-   * const address = await aptos.getTargetAddress({name: "test.aptos"})
-   * // address = bob.accountAddress
-   *
-   * @param args.name - A string of the name: test.aptos.apt, test.apt, test, test.aptos, etc.
-   * @param args.address - A AccountAddressInput of the address to set the domain or subdomain to
-   *
-   * @returns SimpleTransaction
-   */
-  async setTargetAddress(args) {
-    return setTargetAddress({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Retrieve the primary name for an account. An account can have
-   * multiple names that target it, but only a single name that is primary. An
-   * account also may not have a primary name.
-   *
-   * @example
-   * const name = await aptos.getPrimaryName({address: alice.accountAddress})
-   * // name = test.aptos
-   *
-   * @param args.address - A AccountAddressInput (address) of the account
-   *
-   * @returns a string if the account has a primary name, undefined otherwise
-   */
-  async getPrimaryName(args) {
-    return getPrimaryName({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Sets the primary name for the sender. An account can have
-   * multiple names that target it, but only a single name that is primary. An
-   * account also may not have a primary name.
-   *
-   * @example
-   * await aptos.setPrimaryName({sender: alice, name: "test.aptos"})
-   * const primaryName = await aptos.getPrimaryName({address: alice.accountAddress})
-   * // primaryName = test.aptos
-   *
-   * @param args.sender - The sender account
-   * @param args.name - A string of the name: test, test.apt, test.aptos, test.aptos.apt, etc.
-   *
-   * @returns SimpleTransaction
-   */
-  async setPrimaryName(args) {
-    return setPrimaryName({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Registers a new name
-   *
-   * @example
-   * // An example of registering a subdomain name assuming def.apt is already registered
-   * // and belongs to the sender alice.
-   *  const txn = aptos.registerName({
-   *    sender: alice,
-   *    name: "test.aptos.apt",
-   *    expiration: {
-   *      policy: "subdomain:independent",
-   *      expirationDate: Date.now() + 30 * 24 * 60 * 60 * 1000,
-   *    },
-   *  });
-   *
-   * @param args.sender - The sender account
-   * @param args.name - A string of the name to register. This can be inclusive or exclusive of the .apt suffix.
-   * Examples include: "test", "test.apt", "test.aptos.apt", etc.
-   * @param args.expiration  - An object with the expiration policy of the name.
-   * @param args.expiration.policy - 'domain' | 'subdomain:follow-domain' | 'subdomain:independent'
-   * - domain: Years is required and the name will expire after the given number of years.
-   * - subdomain:follow-domain: The name will expire at the same time as the domain name.
-   * - subdomain:independent: The name will expire at the given date.
-   * @param args.expiration.expirationDate - An epoch number in milliseconds of
-   * the date when the subdomain will expire. Only applicable when the policy is
-   * set to 'subdomain:independent'.
-   * @param args.transferable  - Determines if the subdomain being minted is soul-bound. Applicable only to subdomains.
-   * @param args.targetAddress optional - The address the domain name will resolve to. If not provided,
-   * the sender's address will be used.
-   * @param args.toAddress optional - The address to send the domain name to. If not provided,
-   * the transaction will be sent to the router.
-   *
-   * @returns SimpleTransaction
-   */
-  async registerName(args) {
-    return registerName({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Renews a domain name
-   *
-   * Note: If a domain name was minted with V1 of the contract, it will automatically be upgraded to V2 via this transaction.
-   *
-   * @example
-   * await aptos.renewDomain({sender: alice, name: "test"})
-   * // test.apt will be renewed for one year
-   *
-   * @param args.sender - The sender account
-   * @param args.name - A string of the domain the subdomain will be under. The signer must be the domain owner.
-   * Subdomains cannot be renewed.
-   * @param args.years - The number of years to renew the name. Currently only one year is permitted.
-   *
-   * @returns SimpleTransaction
-   */
-  async renewDomain(args) {
-    return renewDomain({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Fetches a single name from the indexer
-   * @param args.name - A string of the name to retrieve, e.g. "test.aptos.apt"
-   * or "test.apt" or "test". Can be inclusive or exclusive of the .apt suffix.
-   * Can be a subdomain.
-   *
-   * @returns A promise of an ANSName or undefined
-   */
-  async getName(args) {
-    return getName({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Fetches all  names for an account (both top level domains and subdomains)
-   *
-   * @param args
-   * @param args.accountAddress - A AccountAddressInput of the address to retrieve names for.
-   * @param args.options.offset - Optional, the offset to start from when fetching names
-   * @param args.options.limit - Optional, A number of the names to fetch per request
-   * @param args.options.orderBy - The order to sort the names by
-   * @param args.options.where - Additional filters to apply to the query
-   *
-   * @returns a promise of an array of ANSName
-   */
-  async getAccountNames(args) {
-    return getAccountNames({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Fetches all top level domain names for an account
-   *
-   * @param args
-   * @param args.accountAddress - A AccountAddressInput of the address to retrieve domain names for.
-   * @param args.options.offset - Optional, the offset to start from when fetching names
-   * @param args.options.limit - Optional, A number of the names to fetch per request
-   * @param args.options.orderBy - The order to sort the names by
-   * @param args.options.where - Additional filters to apply to the query
-   *
-   * @returns a promise of an array of ANSName
-   */
-  async getAccountDomains(args) {
-    return getAccountDomains({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Fetches all subdomains names for an account
-   *
-   * @param args
-   * @param args.accountAddress - A AccountAddressInput of the address to retrieve subdomains names for.
-   * @param args.options.offset - Optional, the offset to start from when fetching names
-   * @param args.options.limit - Optional, A number of the names to fetch per request
-   * @param args.options.orderBy - The order to sort the names by
-   * @param args.options.where - Additional filters to apply to the query
-   *
-   * @returns a promise of an array of ANSName
-   */
-  async getAccountSubdomains(args) {
-    return getAccountSubdomains({ aptosConfig: this.config, ...args });
-  }
-  /**
-   * Fetches all subdomains names for a given domain. Note, this will not return the domain itself.
-   *
-   * @param args
-   * @param args.domain - A string of the domain name: eg. "test.apt" or "test" (without the suffix of .apt)
-   * @param args.options.offset - Optional, the offset to start from when fetching names
-   * @param args.options.limit - Optional, A number of the names to fetch per request
-   * @param args.options.orderBy - The order to sort the names by
-   * @param args.options.where - Additional filters to apply to the query
-   *
-   * @returns a promise of an array of ANSName
-   */
-  async getDomainSubdomains(args) {
-    return getDomainSubdomains({ aptosConfig: this.config, ...args });
-  }
-};
-
-export {
-  ANS
-};
-//# sourceMappingURL=chunk-2ZEGJU43.mjs.map

package/dist/esm/chunk-4OYYOYSO.mjs

@@ -1,336 +0,0 @@
-import {
-  bigIntToBytesLE,
-  bytesToBigIntLE,
-  hashASCIIStrToField,
-  poseidonHash
-} from "./chunk-76TSTAU4.mjs";
-import {
-  Proof
-} from "./chunk-WLTBF4DF.mjs";
-import {
-  EphemeralPublicKey,
-  EphemeralSignature
-} from "./chunk-B5S6DDUD.mjs";
-import {
-  Signature
-} from "./chunk-FDWJNY4U.mjs";
-import {
-  AccountPublicKey
-} from "./chunk-FXKSE3ZP.mjs";
-import {
-  AuthenticationKey
-} from "./chunk-UEBBLQJ5.mjs";
-import {
-  Deserializer
-} from "./chunk-7JRMOHBP.mjs";
-import {
-  Serializable,
-  Serializer
-} from "./chunk-FQQW55X7.mjs";
-import {
-  Hex
-} from "./chunk-YV7M4CFP.mjs";
-
-// src/core/crypto/keyless.ts
-var EPK_HORIZON_SECS = 1e7;
-var MAX_AUD_VAL_BYTES = 120;
-var MAX_UID_KEY_BYTES = 30;
-var MAX_UID_VAL_BYTES = 330;
-var MAX_ISS_VAL_BYTES = 120;
-var MAX_EXTRA_FIELD_BYTES = 350;
-var MAX_JWT_HEADER_B64_BYTES = 300;
-var MAX_COMMITED_EPK_BYTES = 93;
-var _KeylessPublicKey = class _KeylessPublicKey extends AccountPublicKey {
-  constructor(iss, idCommitment) {
-    super();
-    const idcBytes = Hex.fromHexInput(idCommitment).toUint8Array();
-    if (idcBytes.length !== _KeylessPublicKey.ID_COMMITMENT_LENGTH) {
-      throw new Error(`Address seed length in bytes should be ${_KeylessPublicKey.ID_COMMITMENT_LENGTH}`);
-    }
-    this.iss = iss;
-    this.idCommitment = idcBytes;
-  }
-  /**
-   * Get the authentication key for the keyless public key
-   *
-   * @returns AuthenticationKey
-   */
-  authKey() {
-    const serializer = new Serializer();
-    serializer.serializeU32AsUleb128(3 /* Keyless */);
-    serializer.serializeFixedBytes(this.bcsToBytes());
-    return AuthenticationKey.fromSchemeAndBytes({
-      scheme: 2 /* SingleKey */,
-      input: serializer.toUint8Array()
-    });
-  }
-  /**
-   * Get the public key in bytes (Uint8Array).
-   *
-   * @returns Uint8Array representation of the public key
-   */
-  toUint8Array() {
-    return this.bcsToBytes();
-  }
-  /**
-   * Get the public key as a hex string with the 0x prefix.
-   *
-   * @returns string representation of the public key
-   */
-  toString() {
-    return Hex.fromHexInput(this.toUint8Array()).toString();
-  }
-  /**
-   * Verifies a signed data with a public key
-   *
-   * @param args.message message
-   * @param args.signature The signature
-   * @returns true if the signature is valid
-   */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this
-  verifySignature(args) {
-    throw new Error("Not yet implemented");
-  }
-  serialize(serializer) {
-    serializer.serializeStr(this.iss);
-    serializer.serializeBytes(this.idCommitment);
-  }
-  static deserialize(deserializer) {
-    const iss = deserializer.deserializeStr();
-    const addressSeed = deserializer.deserializeBytes();
-    return new _KeylessPublicKey(iss, addressSeed);
-  }
-  static load(deserializer) {
-    const iss = deserializer.deserializeStr();
-    const addressSeed = deserializer.deserializeBytes();
-    return new _KeylessPublicKey(iss, addressSeed);
-  }
-  static isPublicKey(publicKey) {
-    return publicKey instanceof _KeylessPublicKey;
-  }
-  /**
-   * Creates a KeylessPublicKey from the JWT components plus pepper
-   *
-   * @param args.iss the iss of the identity
-   * @param args.uidKey the key to use to get the uidVal in the JWT token
-   * @param args.uidVal the value of the uidKey in the JWT token
-   * @param args.aud the client ID of the application
-   * @param args.pepper The pepper used to maintain privacy of the account
-   * @returns KeylessPublicKey
-   */
-  static create(args) {
-    computeIdCommitment(args);
-    return new _KeylessPublicKey(args.iss, computeIdCommitment(args));
-  }
-};
-_KeylessPublicKey.ID_COMMITMENT_LENGTH = 32;
-var KeylessPublicKey = _KeylessPublicKey;
-function computeIdCommitment(args) {
-  const { uidKey, uidVal, aud, pepper } = args;
-  const fields = [
-    bytesToBigIntLE(Hex.fromHexInput(pepper).toUint8Array()),
-    hashASCIIStrToField(aud, MAX_AUD_VAL_BYTES),
-    hashASCIIStrToField(uidVal, MAX_UID_VAL_BYTES),
-    hashASCIIStrToField(uidKey, MAX_UID_KEY_BYTES)
-  ];
-  return bigIntToBytesLE(poseidonHash(fields), KeylessPublicKey.ID_COMMITMENT_LENGTH);
-}
-var KeylessSignature = class _KeylessSignature extends Signature {
-  constructor(args) {
-    super();
-    const { jwtHeader, ephemeralCertificate, expiryDateSecs, ephemeralPublicKey, ephemeralSignature } = args;
-    this.jwtHeader = jwtHeader;
-    this.ephemeralCertificate = ephemeralCertificate;
-    this.expiryDateSecs = expiryDateSecs;
-    this.ephemeralPublicKey = ephemeralPublicKey;
-    this.ephemeralSignature = ephemeralSignature;
-  }
-  /**
-   * Get the signature in bytes (Uint8Array).
-   *
-   * @returns Uint8Array representation of the signature
-   */
-  toUint8Array() {
-    return this.bcsToBytes();
-  }
-  serialize(serializer) {
-    this.ephemeralCertificate.serialize(serializer);
-    serializer.serializeStr(this.jwtHeader);
-    serializer.serializeU64(this.expiryDateSecs);
-    this.ephemeralPublicKey.serialize(serializer);
-    this.ephemeralSignature.serialize(serializer);
-  }
-  static deserialize(deserializer) {
-    const ephemeralCertificate = EphemeralCertificate.deserialize(deserializer);
-    const jwtHeader = deserializer.deserializeStr();
-    const expiryDateSecs = deserializer.deserializeU64();
-    const ephemeralPublicKey = EphemeralPublicKey.deserialize(deserializer);
-    const ephemeralSignature = EphemeralSignature.deserialize(deserializer);
-    return new _KeylessSignature({
-      jwtHeader,
-      expiryDateSecs,
-      ephemeralCertificate,
-      ephemeralPublicKey,
-      ephemeralSignature
-    });
-  }
-  static load(deserializer) {
-    const ephemeralCertificate = EphemeralCertificate.deserialize(deserializer);
-    const jwtHeader = deserializer.deserializeStr();
-    const expiryDateSecs = deserializer.deserializeU64();
-    const ephemeralPublicKey = EphemeralPublicKey.deserialize(deserializer);
-    const ephemeralSignature = EphemeralSignature.deserialize(deserializer);
-    return new _KeylessSignature({
-      jwtHeader,
-      expiryDateSecs,
-      ephemeralCertificate,
-      ephemeralPublicKey,
-      ephemeralSignature
-    });
-  }
-  static isSignature(signature) {
-    return signature instanceof _KeylessSignature;
-  }
-};
-var EphemeralCertificate = class _EphemeralCertificate extends Signature {
-  constructor(signature, variant) {
-    super();
-    this.signature = signature;
-    this.variant = variant;
-  }
-  /**
-   * Get the public key in bytes (Uint8Array).
-   *
-   * @returns Uint8Array representation of the public key
-   */
-  toUint8Array() {
-    return this.signature.toUint8Array();
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(this.variant);
-    this.signature.serialize(serializer);
-  }
-  static deserialize(deserializer) {
-    const variant = deserializer.deserializeUleb128AsU32();
-    switch (variant) {
-      case 0 /* ZkProof */:
-        return new _EphemeralCertificate(ZeroKnowledgeSig.deserialize(deserializer), variant);
-      default:
-        throw new Error(`Unknown variant index for EphemeralCertificate: ${variant}`);
-    }
-  }
-};
-var Groth16Zkp = class _Groth16Zkp extends Proof {
-  constructor(args) {
-    super();
-    const { a, b, c } = args;
-    this.a = Hex.fromHexInput(a).toUint8Array();
-    this.b = Hex.fromHexInput(b).toUint8Array();
-    this.c = Hex.fromHexInput(c).toUint8Array();
-  }
-  serialize(serializer) {
-    serializer.serializeFixedBytes(this.a);
-    serializer.serializeFixedBytes(this.b);
-    serializer.serializeFixedBytes(this.c);
-  }
-  static deserialize(deserializer) {
-    const a = deserializer.deserializeFixedBytes(32);
-    const b = deserializer.deserializeFixedBytes(64);
-    const c = deserializer.deserializeFixedBytes(32);
-    return new _Groth16Zkp({ a, b, c });
-  }
-};
-var ZkProof = class _ZkProof extends Serializable {
-  constructor(proof, variant) {
-    super();
-    this.proof = proof;
-    this.variant = variant;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(this.variant);
-    this.proof.serialize(serializer);
-  }
-  static deserialize(deserializer) {
-    const variant = deserializer.deserializeUleb128AsU32();
-    switch (variant) {
-      case 0 /* Groth16 */:
-        return new _ZkProof(Groth16Zkp.deserialize(deserializer), variant);
-      default:
-        throw new Error(`Unknown variant index for ZkProof: ${variant}`);
-    }
-  }
-};
-var ZeroKnowledgeSig = class _ZeroKnowledgeSig extends Signature {
-  constructor(args) {
-    super();
-    const {
-      proof,
-      expHorizonSecs = BigInt(EPK_HORIZON_SECS),
-      trainingWheelsSignature,
-      extraField,
-      overrideAudVal
-    } = args;
-    this.proof = proof;
-    this.expHorizonSecs = expHorizonSecs;
-    this.trainingWheelsSignature = trainingWheelsSignature;
-    this.extraField = extraField;
-    this.overrideAudVal = overrideAudVal;
-  }
-  /**
-   * Get the signature in bytes (Uint8Array).
-   *
-   * @returns Uint8Array representation of the signature
-   */
-  toUint8Array() {
-    return this.bcsToBytes();
-  }
-  /**
-   * Return a ZeroKnowledgeSig object from its bcs serialization in bytes.
-   *
-   * @returns ZeroKnowledgeSig
-   */
-  static fromBytes(bytes) {
-    return _ZeroKnowledgeSig.deserialize(new Deserializer(bytes));
-  }
-  serialize(serializer) {
-    this.proof.serialize(serializer);
-    serializer.serializeU64(this.expHorizonSecs);
-    serializer.serializeOptionStr(this.extraField);
-    serializer.serializeOptionStr(this.overrideAudVal);
-    serializer.serializeOption(this.trainingWheelsSignature);
-  }
-  static deserialize(deserializer) {
-    const proof = ZkProof.deserialize(deserializer);
-    const expHorizonSecs = deserializer.deserializeU64();
-    const extraField = deserializer.deserializeOptionStr();
-    const overrideAudVal = deserializer.deserializeOptionStr();
-    const trainingWheelsSignature = deserializer.deserializeOption(EphemeralSignature);
-    return new _ZeroKnowledgeSig({ proof, expHorizonSecs, trainingWheelsSignature, extraField, overrideAudVal });
-  }
-  static load(deserializer) {
-    const proof = ZkProof.deserialize(deserializer);
-    const expHorizonSecs = deserializer.deserializeU64();
-    const extraField = deserializer.deserializeOptionStr();
-    const overrideAudVal = deserializer.deserializeOptionStr();
-    const trainingWheelsSignature = deserializer.deserializeOption(EphemeralSignature);
-    return new _ZeroKnowledgeSig({ proof, expHorizonSecs, trainingWheelsSignature, extraField, overrideAudVal });
-  }
-};
-
-export {
-  EPK_HORIZON_SECS,
-  MAX_AUD_VAL_BYTES,
-  MAX_UID_KEY_BYTES,
-  MAX_UID_VAL_BYTES,
-  MAX_ISS_VAL_BYTES,
-  MAX_EXTRA_FIELD_BYTES,
-  MAX_JWT_HEADER_B64_BYTES,
-  MAX_COMMITED_EPK_BYTES,
-  KeylessPublicKey,
-  KeylessSignature,
-  EphemeralCertificate,
-  Groth16Zkp,
-  ZkProof,
-  ZeroKnowledgeSig
-};
-//# sourceMappingURL=chunk-4OYYOYSO.mjs.map