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

package/dist/esm/chunk-ILTEOGFF.mjs

@@ -1,407 +0,0 @@
-import {
-  deriveTransactionType,
-  generateSigningMessage
-} from "./chunk-F4VI7BNX.mjs";
-import {
-  AccountAuthenticatorSingleKey
-} from "./chunk-AGKEC2IM.mjs";
-import {
-  EphemeralKeyPair
-} from "./chunk-XIBOO3WF.mjs";
-import {
-  AnyPublicKey,
-  AnySignature
-} from "./chunk-IPUAVRGL.mjs";
-import {
-  FederatedKeylessPublicKey
-} from "./chunk-6SNGKTWE.mjs";
-import {
-  EphemeralCertificate,
-  KeylessPublicKey,
-  KeylessSignature,
-  ZeroKnowledgeSig,
-  getKeylessConfig,
-  getKeylessJWKs
-} from "./chunk-T573PCIR.mjs";
-import {
-  KeylessError
-} from "./chunk-32UQAST6.mjs";
-import {
-  base64UrlDecode
-} from "./chunk-RQS33JAS.mjs";
-import {
-  AccountAddress
-} from "./chunk-CXLXUSCG.mjs";
-import {
-  Serializable
-} from "./chunk-C7T6GW5P.mjs";
-import {
-  Hex
-} from "./chunk-BDM6FBUO.mjs";
-
-// src/account/AbstractKeylessAccount.ts
-import EventEmitter from "eventemitter3";
-import { jwtDecode } from "jwt-decode";
-function isKeylessSigner(obj) {
-  return obj !== null && obj !== void 0 && typeof obj.checkKeylessAccountValidity === "function";
-}
-var _AbstractKeylessAccount = class _AbstractKeylessAccount extends Serializable {
-  /**
-   * Use the static generator `create(...)` instead.
-   * Creates an instance of the KeylessAccount with an optional proof.
-   *
-   * @param args - The parameters for creating a KeylessAccount.
-   * @param args.address - Optional account address associated with the KeylessAccount.
-   * @param args.publicKey - A KeylessPublicKey or FederatedKeylessPublicKey.
-   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.
-   * @param args.iss - A JWT issuer.
-   * @param args.uidKey - The claim on the JWT to identify a user.  This is typically 'sub' or 'email'.
-   * @param args.uidVal - The unique id for this user, intended to be a stable user identifier.
-   * @param args.aud - The value of the 'aud' claim on the JWT, also known as client ID.  This is the identifier for the dApp's
-   * OIDC registration with the identity provider.
-   * @param args.pepper - A hexadecimal input used for additional security.
-   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.
-   * @param args.proofFetchCallback - Optional callback function for fetching proof.
-   * @param args.jwt - A JSON Web Token used for authentication.
-   * @param args.verificationKeyHash Optional 32-byte verification key hash as hex input used to check proof validity.
-   */
-  constructor(args) {
-    super();
-    /**
-     * Signing scheme used to sign transactions
-     * @group Implementation
-     * @category Account (On-Chain Model)
-     */
-    this.signingScheme = 2 /* SingleKey */;
-    const {
-      address,
-      ephemeralKeyPair,
-      publicKey,
-      uidKey,
-      uidVal,
-      aud,
-      pepper,
-      proof,
-      proofFetchCallback,
-      jwt,
-      verificationKeyHash
-    } = args;
-    this.ephemeralKeyPair = ephemeralKeyPair;
-    this.publicKey = publicKey;
-    this.accountAddress = address ? AccountAddress.from(address) : this.publicKey.authKey().derivedAddress();
-    this.uidKey = uidKey;
-    this.uidVal = uidVal;
-    this.aud = aud;
-    this.jwt = jwt;
-    this.emitter = new EventEmitter();
-    this.proofOrPromise = proof;
-    if (proof instanceof ZeroKnowledgeSig) {
-      this.proof = proof;
-    } else {
-      if (proofFetchCallback === void 0) {
-        throw new Error("Must provide callback for async proof fetch");
-      }
-      this.emitter.on("proofFetchFinish", async (status) => {
-        await proofFetchCallback(status);
-        this.emitter.removeAllListeners();
-      });
-      this.init(proof);
-    }
-    const pepperBytes = Hex.fromHexInput(pepper).toUint8Array();
-    if (pepperBytes.length !== _AbstractKeylessAccount.PEPPER_LENGTH) {
-      throw new Error(`Pepper length in bytes should be ${_AbstractKeylessAccount.PEPPER_LENGTH}`);
-    }
-    this.pepper = pepperBytes;
-    if (verificationKeyHash !== void 0) {
-      if (Hex.hexInputToUint8Array(verificationKeyHash).length !== 32) {
-        throw new Error("verificationKeyHash must be 32 bytes");
-      }
-      this.verificationKeyHash = Hex.hexInputToUint8Array(verificationKeyHash);
-    }
-  }
-  getAnyPublicKey() {
-    return new AnyPublicKey(this.publicKey);
-  }
-  /**
-   * This initializes the asynchronous proof fetch
-   * @return Emits whether the proof succeeds or fails, but has no return.
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  async init(promise) {
-    try {
-      this.proof = await promise;
-      this.emitter.emit("proofFetchFinish", { status: "Success" });
-    } catch (error) {
-      if (error instanceof Error) {
-        this.emitter.emit("proofFetchFinish", { status: "Failed", error: error.toString() });
-      } else {
-        this.emitter.emit("proofFetchFinish", { status: "Failed", error: "Unknown" });
-      }
-    }
-  }
-  /**
-   * Serializes the jwt data into a format suitable for transmission or storage.
-   * This function ensures that both the jwt data and the proof are properly serialized.
-   *
-   * @param serializer - The serializer instance used to convert the jwt data into bytes.
-   */
-  serialize(serializer) {
-    this.accountAddress.serialize(serializer);
-    serializer.serializeStr(this.jwt);
-    serializer.serializeStr(this.uidKey);
-    serializer.serializeFixedBytes(this.pepper);
-    this.ephemeralKeyPair.serialize(serializer);
-    if (this.proof === void 0) {
-      throw new Error("Cannot serialize - proof undefined");
-    }
-    this.proof.serialize(serializer);
-    serializer.serializeOption(this.verificationKeyHash, 32);
-  }
-  static partialDeserialize(deserializer) {
-    const address = AccountAddress.deserialize(deserializer);
-    const jwt = deserializer.deserializeStr();
-    const uidKey = deserializer.deserializeStr();
-    const pepper = deserializer.deserializeFixedBytes(31);
-    const ephemeralKeyPair = EphemeralKeyPair.deserialize(deserializer);
-    const proof = ZeroKnowledgeSig.deserialize(deserializer);
-    const verificationKeyHash = deserializer.deserializeOption("fixedBytes", 32);
-    return { address, jwt, uidKey, pepper, ephemeralKeyPair, proof, verificationKeyHash };
-  }
-  /**
-   * Checks if the proof is expired.  If so the account must be re-derived with a new EphemeralKeyPair
-   * and JWT token.
-   * @return boolean
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  isExpired() {
-    return this.ephemeralKeyPair.isExpired();
-  }
-  /**
-   * Sign a message using Keyless.
-   * @param message the message to sign, as binary input
-   * @return the AccountAuthenticator containing the signature, together with the account's public key
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  signWithAuthenticator(message) {
-    const signature = new AnySignature(this.sign(message));
-    const publicKey = new AnyPublicKey(this.publicKey);
-    return new AccountAuthenticatorSingleKey(publicKey, signature);
-  }
-  /**
-   * Sign a transaction using Keyless.
-   * @param transaction the raw transaction
-   * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  signTransactionWithAuthenticator(transaction) {
-    const signature = new AnySignature(this.signTransaction(transaction));
-    const publicKey = new AnyPublicKey(this.publicKey);
-    return new AccountAuthenticatorSingleKey(publicKey, signature);
-  }
-  /**
-   * Waits for asynchronous proof fetching to finish.
-   * @return
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  async waitForProofFetch() {
-    if (this.proofOrPromise instanceof Promise) {
-      await this.proofOrPromise;
-    }
-  }
-  /**
-   * Validates that the Keyless Account can be used to sign transactions.
-   * @return
-   */
-  async checkKeylessAccountValidity(aptosConfig) {
-    if (this.isExpired()) {
-      throw KeylessError.fromErrorType({
-        type: 0 /* EPHEMERAL_KEY_PAIR_EXPIRED */
-      });
-    }
-    await this.waitForProofFetch();
-    if (this.proof === void 0) {
-      throw KeylessError.fromErrorType({
-        type: 2 /* ASYNC_PROOF_FETCH_FAILED */
-      });
-    }
-    const header = jwtDecode(this.jwt, { header: true });
-    if (header.kid === void 0) {
-      throw KeylessError.fromErrorType({
-        type: 12 /* JWT_PARSING_ERROR */,
-        details: "checkKeylessAccountValidity failed. JWT is missing 'kid' in header. This should never happen."
-      });
-    }
-    if (this.verificationKeyHash !== void 0) {
-      const { verificationKey } = await getKeylessConfig({ aptosConfig });
-      if (Hex.hexInputToString(verificationKey.hash()) !== Hex.hexInputToString(this.verificationKeyHash)) {
-        throw KeylessError.fromErrorType({
-          type: 4 /* INVALID_PROOF_VERIFICATION_KEY_NOT_FOUND */
-        });
-      }
-    } else {
-      console.warn(
-        "[Aptos SDK] The verification key hash was not set. Proof may be invalid if the verification key has rotated."
-      );
-    }
-    await _AbstractKeylessAccount.fetchJWK({ aptosConfig, publicKey: this.publicKey, kid: header.kid });
-  }
-  /**
-   * Sign the given message using Keyless.
-   * @param message in HexInput format
-   * @returns Signature
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  sign(message) {
-    const { expiryDateSecs } = this.ephemeralKeyPair;
-    if (this.isExpired()) {
-      throw KeylessError.fromErrorType({
-        type: 0 /* EPHEMERAL_KEY_PAIR_EXPIRED */
-      });
-    }
-    if (this.proof === void 0) {
-      throw KeylessError.fromErrorType({
-        type: 1 /* PROOF_NOT_FOUND */,
-        details: "Proof not found - make sure to call `await account.checkKeylessAccountValidity()` before signing."
-      });
-    }
-    const ephemeralPublicKey = this.ephemeralKeyPair.getPublicKey();
-    const ephemeralSignature = this.ephemeralKeyPair.sign(message);
-    return new KeylessSignature({
-      jwtHeader: base64UrlDecode(this.jwt.split(".")[0]),
-      ephemeralCertificate: new EphemeralCertificate(this.proof, 0 /* ZkProof */),
-      expiryDateSecs,
-      ephemeralPublicKey,
-      ephemeralSignature
-    });
-  }
-  /**
-   * Sign the given transaction with Keyless.
-   * Signs the transaction and proof to guard against proof malleability.
-   * @param transaction the transaction to be signed
-   * @returns KeylessSignature
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  signTransaction(transaction) {
-    if (this.proof === void 0) {
-      throw KeylessError.fromErrorType({
-        type: 1 /* PROOF_NOT_FOUND */,
-        details: "Proof not found - make sure to call `await account.checkKeylessAccountValidity()` before signing."
-      });
-    }
-    const raw = deriveTransactionType(transaction);
-    const txnAndProof = new TransactionAndProof(raw, this.proof.proof);
-    const signMess = txnAndProof.hash();
-    return this.sign(signMess);
-  }
-  /**
-   * Note - This function is currently incomplete and should only be used to verify ownership of the KeylessAccount
-   *
-   * Verifies a signature given the message.
-   *
-   * TODO: Groth16 proof verification
-   *
-   * @param args.message the message that was signed.
-   * @param args.signature the KeylessSignature to verify
-   * @returns boolean
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  verifySignature(args) {
-    const { message, signature } = args;
-    if (this.isExpired()) {
-      return false;
-    }
-    if (!this.ephemeralKeyPair.getPublicKey().verifySignature({ message, signature: signature.ephemeralSignature })) {
-      return false;
-    }
-    return true;
-  }
-  /**
-   * Fetches the JWK from the issuer's well-known JWKS endpoint.
-   *
-   * @param args.publicKey The keyless public key to query
-   * @param args.kid The kid of the JWK to fetch
-   * @returns A JWK matching the `kid` in the JWT header.
-   * @throws {KeylessError} If the JWK cannot be fetched
-   */
-  static async fetchJWK(args) {
-    const { aptosConfig, publicKey, kid } = args;
-    const keylessPubKey = publicKey instanceof KeylessPublicKey ? publicKey : publicKey.keylessPublicKey;
-    const { iss } = keylessPubKey;
-    let allJWKs;
-    const jwkAddr = publicKey instanceof FederatedKeylessPublicKey ? publicKey.jwkAddress : void 0;
-    try {
-      allJWKs = await getKeylessJWKs({ aptosConfig, jwkAddr });
-    } catch (error) {
-      throw KeylessError.fromErrorType({
-        type: 24 /* FULL_NODE_JWKS_LOOKUP_ERROR */,
-        error,
-        details: `Failed to fetch ${jwkAddr ? "Federated" : "Patched"}JWKs ${jwkAddr ? `for address ${jwkAddr}` : "0x1"}`
-      });
-    }
-    const jwksForIssuer = allJWKs.get(iss);
-    if (jwksForIssuer === void 0) {
-      throw KeylessError.fromErrorType({
-        type: 7 /* INVALID_JWT_ISS_NOT_RECOGNIZED */,
-        details: `JWKs for issuer ${iss} not found.`
-      });
-    }
-    const jwk = jwksForIssuer.find((key) => key.kid === kid);
-    if (jwk === void 0) {
-      throw KeylessError.fromErrorType({
-        type: 6 /* INVALID_JWT_JWK_NOT_FOUND */,
-        details: `JWK with kid '${kid}' for issuer '${iss}' not found.`
-      });
-    }
-    return jwk;
-  }
-};
-_AbstractKeylessAccount.PEPPER_LENGTH = 31;
-var AbstractKeylessAccount = _AbstractKeylessAccount;
-var TransactionAndProof = class extends Serializable {
-  constructor(transaction, proof) {
-    super();
-    /**
-     * The domain separator prefix used when hashing.
-     * @group Implementation
-     * @category Account (On-Chain Model)
-     */
-    this.domainSeparator = "APTOS::TransactionAndProof";
-    this.transaction = transaction;
-    this.proof = proof;
-  }
-  /**
-   * Serializes the transaction data into a format suitable for transmission or storage.
-   * This function ensures that both the transaction bytes and the proof are properly serialized.
-   *
-   * @param serializer - The serializer instance used to convert the transaction data into bytes.
-   */
-  serialize(serializer) {
-    serializer.serializeFixedBytes(this.transaction.bcsToBytes());
-    serializer.serializeOption(this.proof);
-  }
-  /**
-   * Hashes the bcs serialized from of the class. This is the typescript corollary to the BCSCryptoHash macro in aptos-core.
-   *
-   * @returns Uint8Array
-   * @group Implementation
-   * @category Account (On-Chain Model)
-   */
-  hash() {
-    return generateSigningMessage(this.bcsToBytes(), this.domainSeparator);
-  }
-};
-
-export {
-  isKeylessSigner,
-  AbstractKeylessAccount,
-  TransactionAndProof
-};
-//# sourceMappingURL=chunk-ILTEOGFF.mjs.map