@aptos-labs/ts-sdk 1.17.0-zeta.0 → 1.17.0

package/src/account/EphemeralKeyPair.ts

@@ -1,158 +0,0 @@
-// Copyright © Aptos Foundation
-// SPDX-License-Identifier: Apache-2.0
-
-import { randomBytes } from "@noble/hashes/utils";
-
-import { Ed25519PrivateKey, EphemeralPublicKey, EphemeralSignature, PrivateKey } from "../core/crypto";
-import { Hex } from "../core/hex";
-import { bytesToBigIntLE, padAndPackBytesWithLen, poseidonHash } from "../core/crypto/poseidon";
-import { EphemeralPublicKeyVariant, HexInput } from "../types";
-import { Deserializer, Serializable, Serializer } from "../bcs";
-import { floorToWholeHour, nowInSeconds } from "../utils/helpers";
-
-const TWO_WEEKS_IN_SECONDS = 1_209_600;
-
-/**
- * A class which contains a key pair that is used in signing transactions via the Keyless authentication scheme. This key pair
- * is ephemeral and has an expiration time.  For more details on how this class is used -
- * https://aptos.dev/guides/keyless-accounts/#1-present-the-user-with-a-sign-in-with-idp-button-on-the-ui
- */
-export class EphemeralKeyPair extends Serializable {
-  static readonly BLINDER_LENGTH: number = 31;
-
-  /**
-   * A byte array of length BLINDER_LENGTH used to obfuscate the public key from the IdP.
-   * Used in calculating the nonce passed to the IdP and as a secret witness in proof generation.
-   */
-  readonly blinder: Uint8Array;
-
-  /**
-   * A timestamp in seconds indicating when the ephemeral key pair is expired.  After expiry, a new
-   * EphemeralKeyPair must be generated and a new JWT needs to be created.
-   */
-  readonly expiryDateSecs: number;
-
-  /**
-   * The value passed to the IdP when the user authenticates.  It comprises of a hash of the
-   * ephermeral public key, expiry date, and blinder.
-   */
-  readonly nonce: string;
-
-  /**
-   * A private key used to sign transactions.  This private key is not tied to any account on the chain as it
-   * is ephemeral (not permanent) in nature.
-   */
-  private privateKey: PrivateKey;
-
-  /**
-   * A public key used to verify transactions.  This public key is not tied to any account on the chain as it
-   * is ephemeral (not permanent) in nature.
-   */
-  private publicKey: EphemeralPublicKey;
-
-  constructor(args: { privateKey: PrivateKey; expiryDateSecs?: number; blinder?: HexInput }) {
-    super();
-    const { privateKey, expiryDateSecs, blinder } = args;
-    this.privateKey = privateKey;
-    this.publicKey = new EphemeralPublicKey(privateKey.publicKey());
-    // By default, we set the expiry date to be two weeks in the future floored to the nearest hour
-    this.expiryDateSecs = expiryDateSecs || floorToWholeHour(nowInSeconds() + TWO_WEEKS_IN_SECONDS);
-    // Generate the blinder if not provided
-    this.blinder = blinder !== undefined ? Hex.fromHexInput(blinder).toUint8Array() : generateBlinder();
-    // Calculate the nonce
-    this.nonce = this.generateNonce();
-  }
-
-  /**
-   * Returns the public key of the key pair.
-   * @return EphemeralPublicKey
-   */
-  getPublicKey(): EphemeralPublicKey {
-    return this.publicKey;
-  }
-
-  /**
-   * Returns the public key of the key pair.
-   * @return boolean
-   */
-  isExpired(): boolean {
-    const currentTimeSecs: number = Math.floor(Date.now() / 1000);
-    return currentTimeSecs > this.expiryDateSecs;
-  }
-
-  serialize(serializer: Serializer): void {
-    serializer.serializeU32AsUleb128(this.publicKey.variant);
-    serializer.serializeBytes(this.privateKey.toUint8Array());
-    serializer.serializeU64(this.expiryDateSecs);
-    serializer.serializeFixedBytes(this.blinder);
-  }
-
-  static deserialize(deserializer: Deserializer): EphemeralKeyPair {
-    const variantIndex = deserializer.deserializeUleb128AsU32();
-    let privateKey: PrivateKey;
-    switch (variantIndex) {
-      case EphemeralPublicKeyVariant.Ed25519:
-        privateKey = Ed25519PrivateKey.deserialize(deserializer);
-        break;
-      default:
-        throw new Error(`Unknown variant index for EphemeralPublicKey: ${variantIndex}`);
-    }
-    const expiryDateSecs = deserializer.deserializeU64();
-    const blinder = deserializer.deserializeFixedBytes(31);
-    return new EphemeralKeyPair({ privateKey, expiryDateSecs: Number(expiryDateSecs), blinder });
-  }
-
-  static fromBytes(bytes: Uint8Array): EphemeralKeyPair {
-    return EphemeralKeyPair.deserialize(new Deserializer(bytes));
-  }
-
-  /**
-   * Returns the public key of the key pair.
-   * @param scheme the type of keypair to use for the EphemeralKeyPair.  Only Ed25519 supported for now.
-   * @param expiryDateSecs the date of expiry.
-   * @return boolean
-   */
-  static generate(args?: { scheme?: EphemeralPublicKeyVariant; expiryDateSecs?: number }): EphemeralKeyPair {
-    let privateKey: PrivateKey;
-
-    switch (args?.scheme) {
-      case EphemeralPublicKeyVariant.Ed25519:
-      default:
-        privateKey = Ed25519PrivateKey.generate();
-    }
-
-    return new EphemeralKeyPair({ privateKey, expiryDateSecs: args?.expiryDateSecs });
-  }
-
-  /**
-   * From the ephemeral public key, expiry timestamp, and blinder, calculate the nonce to be used at authentication via OIDC.
-   * @returns string
-   */
-  private generateNonce(): string {
-    const fields = padAndPackBytesWithLen(this.publicKey.bcsToBytes(), 93);
-    fields.push(BigInt(this.expiryDateSecs));
-    fields.push(bytesToBigIntLE(this.blinder));
-    const nonceHash = poseidonHash(fields);
-    return nonceHash.toString();
-  }
-
-  /**
-   * Sign the given message with the private key.
-   * @param data in HexInput format
-   * @returns EphemeralSignature
-   */
-  sign(data: HexInput): EphemeralSignature {
-    if (this.isExpired()) {
-      throw new Error("EphemeralKeyPair has expired");
-    }
-    return new EphemeralSignature(this.privateKey.sign(data));
-  }
-}
-
-/**
- * Generates a random byte array of length EphemeralKeyPair.BLINDER_LENGTH
- * @returns Uint8Array
- */
-function generateBlinder(): Uint8Array {
-  return randomBytes(EphemeralKeyPair.BLINDER_LENGTH);
-}

package/src/account/KeylessAccount.ts

@@ -1,367 +0,0 @@
-// Copyright © Aptos Foundation
-// SPDX-License-Identifier: Apache-2.0
-
-import { JwtPayload, jwtDecode } from "jwt-decode";
-import EventEmitter from "eventemitter3";
-import { EphemeralCertificateVariant, HexInput, SigningScheme } from "../types";
-import { AccountAddress } from "../core/accountAddress";
-import {
-  AnyPublicKey,
-  AnySignature,
-  KeylessPublicKey,
-  KeylessSignature,
-  EphemeralCertificate,
-  Signature,
-  ZeroKnowledgeSig,
-  ZkProof,
-} from "../core/crypto";
-
-import { Account } from "./Account";
-import { EphemeralKeyPair } from "./EphemeralKeyPair";
-import { Hex } from "../core/hex";
-import { AccountAuthenticatorSingleKey } from "../transactions/authenticator/account";
-import { Deserializer, Serializable, Serializer } from "../bcs";
-import { deriveTransactionType } from "../transactions/transactionBuilder/signingMessage";
-import { AnyRawTransaction, AnyRawTransactionInstance } from "../transactions/types";
-import { AptsoDomainSeparator, CryptoHashable } from "../core/crypto/cryptoHashable";
-import { base64UrlDecode } from "../utils/helpers";
-
-/**
- * Account implementation for the Keyless authentication scheme.
- *
- * Used to represent a Keyless based account and sign transactions with it.
- *
- * Use KeylessAccount.fromJWTAndProof to instantiate a KeylessAccount with a JWT, proof and EphemeralKeyPair.
- *
- * When the proof expires or the JWT becomes invalid, the KeylessAccount must be instantiated again with a new JWT,
- * EphemeralKeyPair, and corresponding proof.
- */
-export class KeylessAccount extends Serializable implements Account {
-  static readonly PEPPER_LENGTH: number = 31;
-
-  /**
-   * The KeylessPublicKey associated with the account
-   */
-  readonly publicKey: KeylessPublicKey;
-
-  /**
-   * The EphemeralKeyPair used to generate sign.
-   */
-  readonly ephemeralKeyPair: EphemeralKeyPair;
-
-  /**
-   * The claim on the JWT to identify a user.  This is typically 'sub' or 'email'.
-   */
-  readonly uidKey: string;
-
-  /**
-   * The value of the uidKey claim on the JWT.  This intended to be a stable user identifier.
-   */
-  readonly uidVal: string;
-
-  /**
-   * 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.
-   */
-  readonly aud: string;
-
-  /**
-   * A value contains 31 bytes of entropy that preserves privacy of the account. Typically fetched from a pepper provider.
-   */
-  readonly pepper: Uint8Array;
-
-  /**
-   * Account address associated with the account
-   */
-  readonly accountAddress: AccountAddress;
-
-  /**
-   * The zero knowledge signature (if ready) which contains the proof used to validate the EphemeralKeyPair.
-   */
-  proof: ZeroKnowledgeSig | undefined;
-
-  /**
-   * The proof of the EphemeralKeyPair or a promise that provides the proof.  This is used to allow for awaiting on
-   * fetching the proof.
-   */
-  readonly proofOrPromise: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;
-
-  /**
-   * Signing scheme used to sign transactions
-   */
-  readonly signingScheme: SigningScheme;
-
-  /**
-   * The JWT token used to derive the account
-   */
-  private jwt: string;
-
-  /**
-   * A value that caches the JWT's validity.  A JWT becomes invalid when it's corresponding JWK is rotated from the
-   * identity provider's JWK keyset.
-   */
-  private isJwtValid: boolean;
-
-  /**
-   * An event emitter used to assist in handling asycronous proof fetching.
-   */
-  private readonly emitter: EventEmitter<ProofFetchEvents>;
-
-  constructor(args: {
-    address?: AccountAddress;
-    ephemeralKeyPair: EphemeralKeyPair;
-    iss: string;
-    uidKey: string;
-    uidVal: string;
-    aud: string;
-    pepper: HexInput;
-    proofOrFetcher: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;
-    proofFetchCallback?: ProofFetchCallback;
-    jwt: string;
-  }) {
-    super();
-    const { address, ephemeralKeyPair, uidKey, uidVal, aud, pepper, proofOrFetcher, proofFetchCallback, jwt } = args;
-    this.ephemeralKeyPair = ephemeralKeyPair;
-    this.publicKey = KeylessPublicKey.create(args);
-    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<ProofFetchEvents>();
-    this.proofOrPromise = proofOrFetcher;
-    if (proofOrFetcher instanceof ZeroKnowledgeSig) {
-      this.proof = proofOrFetcher;
-    } else {
-      if (proofFetchCallback === undefined) {
-        throw new Error("Must provide callback for async proof fetch");
-      }
-      this.emitter.on("proofFetchFinish", async (status) => {
-        await proofFetchCallback(status);
-        this.emitter.removeAllListeners();
-      });
-      this.init(proofOrFetcher);
-    }
-    this.signingScheme = SigningScheme.SingleKey;
-    const pepperBytes = Hex.fromHexInput(pepper).toUint8Array();
-    if (pepperBytes.length !== KeylessAccount.PEPPER_LENGTH) {
-      throw new Error(`Pepper length in bytes should be ${KeylessAccount.PEPPER_LENGTH}`);
-    }
-    this.pepper = pepperBytes;
-    this.isJwtValid = true;
-  }
-
-  /**
-   * This initializes the asyncronous proof fetch
-   * @return
-   */
-  async init(promise: Promise<ZeroKnowledgeSig>) {
-    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" });
-      }
-    }
-  }
-
-  serialize(serializer: Serializer): void {
-    serializer.serializeStr(this.jwt);
-    serializer.serializeStr(this.uidKey);
-    serializer.serializeFixedBytes(this.pepper);
-    this.ephemeralKeyPair.serialize(serializer);
-    if (this.proof === undefined) {
-      throw new Error("Connot serialize - proof undefined");
-    }
-    this.proof.serialize(serializer);
-  }
-
-  static deserialize(deserializer: Deserializer): KeylessAccount {
-    const jwt = deserializer.deserializeStr();
-    const uidKey = deserializer.deserializeStr();
-    const pepper = deserializer.deserializeFixedBytes(31);
-    const ephemeralKeyPair = EphemeralKeyPair.deserialize(deserializer);
-    const proof = ZeroKnowledgeSig.deserialize(deserializer);
-    return KeylessAccount.create({
-      proof,
-      pepper,
-      uidKey,
-      jwt,
-      ephemeralKeyPair,
-    });
-  }
-
-  /**
-   * Checks if the proof is expired.  If so the account must be rederived with a new EphemeralKeyPair
-   * and JWT token.
-   * @return boolean
-   */
-  isExpired(): boolean {
-    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
-   */
-  signWithAuthenticator(message: HexInput): AccountAuthenticatorSingleKey {
-    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
-   */
-  signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorSingleKey {
-    const signature = new AnySignature(this.signTransaction(transaction));
-    const publicKey = new AnyPublicKey(this.publicKey);
-    return new AccountAuthenticatorSingleKey(publicKey, signature);
-  }
-
-  /**
-   * Waits for asyncronous proof fetching to finish.
-   * @return
-   */
-  async waitForProofFetch() {
-    if (this.proofOrPromise instanceof Promise) {
-      await this.proofOrPromise;
-    }
-  }
-
-  /**
-   * Sign the given message using Keyless.
-   * @param message in HexInput format
-   * @returns Signature
-   */
-  sign(data: HexInput): KeylessSignature {
-    const { expiryDateSecs } = this.ephemeralKeyPair;
-    if (this.isExpired()) {
-      throw new Error("EphemeralKeyPair is expired");
-    }
-    if (this.proof === undefined) {
-      throw new Error("Proof not defined");
-    }
-    const ephemeralPublicKey = this.ephemeralKeyPair.getPublicKey();
-    const ephemeralSignature = this.ephemeralKeyPair.sign(data);
-
-    return new KeylessSignature({
-      jwtHeader: base64UrlDecode(this.jwt.split(".")[0]),
-      ephemeralCertificate: new EphemeralCertificate(this.proof, EphemeralCertificateVariant.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
-   */
-  signTransaction(transaction: AnyRawTransaction): KeylessSignature {
-    if (this.proof === undefined) {
-      throw new Error("Proof not found");
-    }
-    const raw = deriveTransactionType(transaction);
-    const txnAndProof = new TransactionAndProof(raw, this.proof.proof);
-    const signMess = txnAndProof.hash();
-    return this.sign(signMess);
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this
-  verifySignature(args: { message: HexInput; signature: Signature }): boolean {
-    throw new Error("Not implemented");
-  }
-
-  static fromBytes(bytes: Uint8Array): KeylessAccount {
-    return KeylessAccount.deserialize(new Deserializer(bytes));
-  }
-
-  static create(args: {
-    proof: ZeroKnowledgeSig | Promise<ZeroKnowledgeSig>;
-    jwt: string;
-    ephemeralKeyPair: EphemeralKeyPair;
-    pepper: HexInput;
-    uidKey?: string;
-    proofFetchCallback?: ProofFetchCallback;
-  }): KeylessAccount {
-    const { proof, jwt, ephemeralKeyPair, pepper, uidKey = "sub", proofFetchCallback } = args;
-
-    const jwtPayload = jwtDecode<JwtPayload & { [key: string]: string }>(jwt);
-    const iss = jwtPayload.iss!;
-    if (typeof jwtPayload.aud !== "string") {
-      throw new Error("aud was not found or an array of values");
-    }
-    const aud = jwtPayload.aud!;
-    const uidVal = jwtPayload[uidKey];
-    return new KeylessAccount({
-      proofOrFetcher: proof,
-      ephemeralKeyPair,
-      iss,
-      uidKey,
-      uidVal,
-      aud,
-      pepper,
-      jwt,
-      proofFetchCallback,
-    });
-  }
-}
-
-/**
- * A container class to hold a transaction and a proof.  It implements CryptoHashable which is used to create
- * the signing message for Keyless transactions.  We sign over the proof to ensure non-malleability.
- */
-export class TransactionAndProof extends CryptoHashable {
-  /**
-   * The transaction to sign.
-   */
-  transaction: AnyRawTransactionInstance;
-
-  /**
-   * The zero knowledge proof used in signing the transaction.
-   */
-  proof?: ZkProof;
-
-  /**
-   * The domain separator prefix used when hashing.
-   */
-  domainSeparator: AptsoDomainSeparator;
-
-  constructor(transaction: AnyRawTransactionInstance, proof?: ZkProof) {
-    super();
-    this.transaction = transaction;
-    this.proof = proof;
-    this.domainSeparator = "APTOS::TransactionAndProof";
-  }
-
-  serialize(serializer: Serializer): void {
-    serializer.serializeFixedBytes(this.transaction.bcsToBytes());
-    serializer.serializeOption(this.proof);
-  }
-}
-
-export type ProofFetchSuccess = {
-  status: "Success";
-};
-
-export type ProofFetchFailure = {
-  status: "Failed";
-  error: string;
-};
-
-export type ProofFetchStatus = ProofFetchSuccess | ProofFetchFailure;
-
-export type ProofFetchCallback = (status: ProofFetchStatus) => Promise<void>;
-
-export interface ProofFetchEvents {
-  proofFetchFinish: (status: ProofFetchStatus) => void;
-}

package/src/api/keyless.ts

@@ -1,51 +0,0 @@
-// Copyright © Aptos Foundation
-// SPDX-License-Identifier: Apache-2.0
-
-import { EphemeralKeyPair, KeylessAccount, ProofFetchCallback } from "../account";
-import { deriveKeylessAccount, getPepper } from "../internal/keyless";
-import { HexInput } from "../types";
-import { AptosConfig } from "./aptosConfig";
-
-/**
- * A class to query all `Keyless` related queries on Aptos.
- *
- * More documentation on how to integrate Keyless Accounts see the below
- * https://aptos.dev/guides/keyless-accounts/#aptos-keyless-integration-guide
- */
-export class Keyless {
-  constructor(readonly config: AptosConfig) {}
-
-  /**
-   * Fetches the pepper from the Aptos pepper service API.
-   *
-   * @param args.jwt JWT token
-   * @param args.ephemeralKeyPair the EphemeralKeyPair used to generate the nonce in the JWT token
-   * @returns The pepper which is a Uint8Array of length 31.
-   */
-  async getPepper(args: { jwt: string; ephemeralKeyPair: EphemeralKeyPair }): Promise<Uint8Array> {
-    return getPepper({ aptosConfig: this.config, ...args });
-  }
-
-  /**
-   * Fetches the pepper from the Aptos pepper service API.
-   *
-   * @param args.jwt JWT token
-   * @param args.ephemeralKeyPair the EphemeralKeyPair used to generate the nonce in the JWT token
-   * @param args.uidKey a key in the JWT token to use to set the uidVal in the IdCommitment
-   * @param args.pepper the pepper
-   * @param args.proofFetchCallback a callback function that if set, the fetch of the proof will be done in the background. Once
-   * fetching finishes the callback function will be called.  This should be used to provide a more responsive user experience as now
-   * they are not blocked on fetching the proof. Thus the function will return much more quickly.
-   *
-   * @returns A KeylessAccount that can be used to sign transactions
-   */
-  async deriveKeylessAccount(args: {
-    jwt: string;
-    ephemeralKeyPair: EphemeralKeyPair;
-    uidKey?: string;
-    pepper?: HexInput;
-    proofFetchCallback?: ProofFetchCallback;
-  }): Promise<KeylessAccount> {
-    return deriveKeylessAccount({ aptosConfig: this.config, ...args });
-  }
-}

package/src/core/crypto/cryptoHashable.ts

@@ -1,16 +0,0 @@
-import { generateSigningMessage } from "../../transactions/transactionBuilder/signingMessage";
-import { Serializable } from "../../bcs/serializer";
-
-export type AptsoDomainSeparator = `APTOS::${string}`;
-export abstract class CryptoHashable extends Serializable {
-  abstract readonly domainSeparator: AptsoDomainSeparator;
-
-  /**
-   * Hashes the bcs serialized from of the class. This is the typescript corollary to the BCSCryptoHash macro in aptos-core.
-   *
-   * @returns Uint8Array
-   */
-  hash(): Uint8Array {
-    return generateSigningMessage(this.bcsToBytes(), this.domainSeparator);
-  }
-}