@aptos-labs/ts-sdk 1.34.0 → 1.35.0-zeta.1

package/src/internal/account.ts

@@ -12,11 +12,19 @@ import { AptosConfig } from "../api/aptosConfig";
 import { getAptosFullNode, paginateWithCursor, paginateWithObfuscatedCursor } from "../client";
 import {
   AccountData,
+  AnyPublicKeyVariant,
   GetAccountCoinsDataResponse,
   GetAccountCollectionsWithOwnedTokenResponse,
   GetAccountOwnedTokensFromCollectionResponse,
   GetAccountOwnedTokensQueryResponse,
+  GetMultiKeyForAuthKeyResponse,
   GetObjectDataQueryResponse,
+  isEd25519Signature,
+  isMultiEd25519Signature,
+  isSingleSenderMultiKeySignature,
+  isSingleSenderSignature,
+  isSingleSenderSingleKeySignature,
+  isUserTransactionResponse,
   LedgerVersionArg,
   MoveModuleBytecode,
   MoveResource,
@@ -29,7 +37,19 @@ import {
 } from "../types";
 import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
 import { Account } from "../account";
-import { AnyPublicKey, Ed25519PublicKey, PrivateKey } from "../core/crypto";
+import {
+  AbstractMultiKey,
+  AccountPublicKey,
+  AnyPublicKey,
+  Ed25519PublicKey,
+  FederatedKeylessPublicKey,
+  KeylessPublicKey,
+  MultiEd25519PublicKey,
+  MultiKey,
+  PrivateKey,
+  PublicKey,
+  Secp256k1PublicKey,
+} from "../core/crypto";
 import { queryIndexer } from "./general";
 import {
   GetAccountCoinsCountQuery,
@@ -40,6 +60,10 @@ import {
   GetAccountOwnedTokensQuery,
   GetAccountTokensCountQuery,
   GetAccountTransactionsCountQuery,
+  GetMultiKeyForAuthKeyQuery,
+  GetAuthKeysForPublicKeyQuery,
+  GetAccountAddressesForAuthKeyQuery,
+  GetSignaturesQuery,
 } from "../types/generated/operations";
 import {
   GetAccountCoinsCount,
@@ -50,13 +74,20 @@ import {
   GetAccountOwnedTokensFromCollection,
   GetAccountTokensCount,
   GetAccountTransactionsCount,
+  GetMultiKeyForAuthKey,
+  GetAuthKeysForPublicKey,
+  GetAccountAddressesForAuthKey,
+  GetSignatures,
 } from "../types/generated/queries";
 import { memoizeAsync } from "../utils/memoize";
-import { Secp256k1PrivateKey, AuthenticationKey, Ed25519PrivateKey, createObjectAddress } from "../core";
+import { Secp256k1PrivateKey, AuthenticationKey, Ed25519PrivateKey, createObjectAddress, Hex } from "../core";
 import { CurrentFungibleAssetBalancesBoolExp } from "../types/generated/types";
 import { getTableItem } from "./table";
 import { APTOS_COIN } from "../utils";
 import { AptosApiError } from "../errors";
+import { Deserializer } from "../bcs";
+import { getTransactionByVersion } from "./transaction";
+import { deriveKeylessAccount, DeriveKeylessAccountParams } from "./keyless";
 
 /**
  * Retrieves account information for a specified account address.
@@ -815,3 +846,366 @@ export async function isAccountExist(args: { aptosConfig: AptosConfig; authKey:
     throw new Error(`Error while looking for an account info ${accountAddress.toString()}`);
   }
 }
+
+async function getMultiKeysForAuthenticationKeys(args: {
+  aptosConfig: AptosConfig;
+  authKeys: AuthenticationKey[];
+}): Promise<{ authKey: AuthenticationKey; publicKey: MultiKey | MultiEd25519PublicKey }[]> {
+  const { aptosConfig, authKeys } = args;
+  if (authKeys.length === 0) {
+    throw new Error("No authentication keys provided");
+  }
+
+  const whereCondition: { auth_key: { _in: string[] } } = {
+    auth_key: { _in: authKeys.map((authKey) => authKey.toString()) },
+  };
+
+  const graphqlQuery = {
+    query: GetMultiKeyForAuthKey,
+    variables: {
+      where_condition: whereCondition,
+    },
+  };
+  const { auth_key_multikey_layout: data } = await queryIndexer<GetMultiKeyForAuthKeyQuery>({
+    aptosConfig,
+    query: graphqlQuery,
+    originMethod: "getMultiKeysForAuthenticationKeys",
+  });
+
+  const authKeyToMultiKey = new Map(data.map((entry) => [entry.auth_key, entry]));
+
+  const result: { authKey: AuthenticationKey; publicKey: MultiKey | MultiEd25519PublicKey }[] = [];
+  for (let i = 0; i < authKeys.length; i += 1) {
+    const entry = authKeyToMultiKey.get(authKeys[i].toString());
+    if (!entry) {
+      throw new Error(`Failed to find multikey for authentication key ${authKeys[i]}`);
+    }
+    const publicKey = extractMultiKeyFromData(entry);
+    result.push({ authKey: authKeys[i], publicKey });
+  }
+
+  return result;
+}
+
+function extractMultiKeyFromData(data: GetMultiKeyForAuthKeyResponse): MultiKey | MultiEd25519PublicKey {
+  const signaturesRequired = data.signatures_required;
+  const multikeyLayout = data.multikey_layout_with_prefixes;
+  const multikeyType = data.multikey_type;
+
+  if (multikeyType === "multi_ed25519") {
+    const ed25519PublicKeys: Array<Ed25519PublicKey> = [];
+    for (const key of multikeyLayout) {
+      ed25519PublicKeys.push(new Ed25519PublicKey(key));
+    }
+    return new MultiEd25519PublicKey({
+      publicKeys: ed25519PublicKeys,
+      threshold: signaturesRequired,
+    });
+  }
+  if (multikeyType === "multi_key") {
+    const publicKeys: Array<PublicKey> = [];
+    for (const key of multikeyLayout) {
+      const deserializer = Deserializer.fromHex(key);
+      const variantIndex = deserializer.deserializeUleb128AsU32();
+      let publicKey: PublicKey;
+      switch (variantIndex) {
+        case AnyPublicKeyVariant.Ed25519:
+          publicKey = new Ed25519PublicKey(deserializer.deserializeFixedBytes(32));
+          break;
+        case AnyPublicKeyVariant.Secp256k1:
+          publicKey = new Secp256k1PublicKey(deserializer.deserializeFixedBytes(65));
+          break;
+        case AnyPublicKeyVariant.Keyless:
+          publicKey = KeylessPublicKey.deserialize(deserializer);
+          break;
+        case AnyPublicKeyVariant.FederatedKeyless:
+          publicKey = FederatedKeylessPublicKey.deserialize(deserializer);
+          break;
+        default:
+          throw new Error(`Unknown variant index for AnyPublicKey: ${variantIndex}`);
+      }
+      publicKeys.push(new AnyPublicKey(publicKey));
+    }
+    return new MultiKey({
+      publicKeys,
+      signaturesRequired,
+    });
+  }
+  throw new Error("Unknown multikey type");
+}
+
+async function getAuthKeysForPublicKey(args: {
+  aptosConfig: AptosConfig;
+  publicKey: Exclude<AccountPublicKey, AbstractMultiKey>;
+  options?: { verified?: boolean };
+}): Promise<AuthenticationKey[]> {
+  const { aptosConfig, publicKey, options } = args;
+  const verified = options?.verified ?? true;
+  let baseKey: PublicKey = publicKey;
+  if (publicKey instanceof AnyPublicKey) {
+    baseKey = publicKey.publicKey;
+  }
+  const whereCondition: any = {
+    public_key: { _eq: baseKey.toString() },
+    verified: { _eq: verified },
+  };
+  const graphqlQuery = {
+    query: GetAuthKeysForPublicKey,
+    variables: {
+      where_condition: whereCondition,
+    },
+  };
+  const { public_key_auth_keys: data } = await queryIndexer<GetAuthKeysForPublicKeyQuery>({
+    aptosConfig,
+    query: graphqlQuery,
+    originMethod: "getAuthKeysForPublicKey",
+  });
+
+  const sortedData = data.sort((a, b) => Number(b.last_transaction_version) - Number(a.last_transaction_version));
+  const authKeys = sortedData.map((entry) => new AuthenticationKey({ data: entry.auth_key }));
+  return authKeys;
+}
+
+async function getLastestTransactionVersionForAddress(args: {
+  aptosConfig: AptosConfig;
+  accountAddress: AccountAddressInput;
+}): Promise<number> {
+  const { aptosConfig, accountAddress } = args;
+  const address = AccountAddress.from(accountAddress).toString();
+
+  const whereCondition: any = {
+    signer: { _eq: accountAddress.toString() },
+  };
+
+  const graphqlQuery = {
+    query: GetSignatures,
+    variables: {
+      where_condition: whereCondition,
+      limit: 1,
+      order_by: { transaction_version: "desc" },
+    },
+  };
+
+  const { signatures: data } = await queryIndexer<GetSignaturesQuery>({
+    aptosConfig,
+    query: graphqlQuery,
+    originMethod: "getSignatures",
+  });
+
+  if (data.length !== 1) {
+    throw new Error(`Expected 1 account address for address ${address}, got ${data.length}`);
+  }
+  return Number(data[0].transaction_version);
+}
+
+async function getAccountAddressesForAuthKeys(args: {
+  aptosConfig: AptosConfig;
+  authKeys: AuthenticationKey[];
+  options?: { verified?: boolean };
+}): Promise<
+  { authKey: AuthenticationKey; accountAddress: AccountAddress; verified: boolean; lastTransactionVersion: number }[]
+> {
+  const { aptosConfig, options, authKeys } = args;
+  const verified = options?.verified ?? true;
+  if (authKeys.length === 0) {
+    throw new Error("No authentication keys provided");
+  }
+
+  const whereCondition: any = {
+    auth_key: { _in: authKeys.map((authKey) => authKey.toString()) },
+    verified: { _eq: verified },
+  };
+
+  const graphqlQuery = {
+    query: GetAccountAddressesForAuthKey,
+    variables: {
+      where_condition: whereCondition,
+    },
+  };
+  const { auth_key_account_addresses: data } = await queryIndexer<GetAccountAddressesForAuthKeyQuery>({
+    aptosConfig,
+    query: graphqlQuery,
+    originMethod: "getAccountAddressesForAuthKeys",
+  });
+  return data.map((entry) => ({
+    authKey: new AuthenticationKey({ data: entry.auth_key }),
+    accountAddress: new AccountAddress(Hex.hexInputToUint8Array(entry.address)),
+    verified: entry.verified,
+    lastTransactionVersion: Number(entry.last_transaction_version),
+  }));
+}
+
+export async function getAccountsForPublicKey(args: {
+  aptosConfig: AptosConfig;
+  publicKey: AccountPublicKey;
+}): Promise<
+  { accountAddress: AccountAddress; publicKey: PublicKey; verified: boolean; lastTransactionVersion: number }[]
+> {
+  const { aptosConfig, publicKey } = args;
+
+  let baseKey: PublicKey = publicKey;
+  if (publicKey instanceof AnyPublicKey) {
+    baseKey = publicKey.publicKey;
+  }
+  const singleKeyPublicKeys: AccountPublicKey[] = [];
+  if (baseKey instanceof Ed25519PublicKey) {
+    singleKeyPublicKeys.push(baseKey);
+  }
+  const anyPublicKey = new AnyPublicKey(baseKey);
+  singleKeyPublicKeys.push(anyPublicKey);
+
+  const singleKeyAuthKeyPublicKeyPairs = singleKeyPublicKeys.map((pubKey) => {
+    const authKey = pubKey.authKey();
+    return { authKey, publicKey: pubKey };
+  });
+
+  const multiKeyAuthKeys = await getAuthKeysForPublicKey({ aptosConfig, publicKey });
+
+  const [multiKeyPairs, authKeyAccountAddressPairs] = await Promise.all([
+    getMultiKeysForAuthenticationKeys({ aptosConfig, authKeys: multiKeyAuthKeys }),
+    getAccountAddressesForAuthKeys({
+      aptosConfig,
+      authKeys: multiKeyAuthKeys.concat(singleKeyAuthKeyPublicKeyPairs.map((pair) => pair.publicKey.authKey())),
+    }),
+  ]);
+
+  const authKeyPublicKeyPairs = singleKeyAuthKeyPublicKeyPairs.concat(multiKeyPairs);
+
+  const result: {
+    accountAddress: AccountAddress;
+    publicKey: PublicKey;
+    verified: boolean;
+    lastTransactionVersion: number;
+  }[] = [];
+  const authKeyToPublicKey = new Map(authKeyPublicKeyPairs.map((pair) => [pair.authKey.toString(), pair.publicKey]));
+  for (const authKeyAccountAddressPair of authKeyAccountAddressPairs) {
+    if (!authKeyToPublicKey.has(authKeyAccountAddressPair.authKey.toString())) {
+      throw new Error(`No publicKey found for authentication key ${authKeyAccountAddressPair.authKey}.`);
+    }
+    result.push({
+      accountAddress: authKeyAccountAddressPair.accountAddress,
+      publicKey: authKeyToPublicKey.get(authKeyAccountAddressPair.authKey.toString()) as PublicKey,
+      verified: authKeyAccountAddressPair.verified,
+      lastTransactionVersion: authKeyAccountAddressPair.lastTransactionVersion,
+    });
+  }
+
+  return result;
+}
+
+export async function getPublicKeyFromAccountAddress(args: {
+  aptosConfig: AptosConfig;
+  accountAddress: AccountAddressInput;
+}): Promise<PublicKey> {
+  const { aptosConfig, accountAddress } = args;
+
+  const accountData = await getInfo({ aptosConfig, accountAddress });
+
+  const lastTransactionVersion = await getLastestTransactionVersionForAddress({
+    aptosConfig,
+    accountAddress,
+  });
+  console.log("lastTransactionVersion", lastTransactionVersion);
+
+  const transaction = await getTransactionByVersion({ aptosConfig, ledgerVersion: lastTransactionVersion });
+  if (!isUserTransactionResponse(transaction)) {
+    throw new Error("Transaction is not a user transaction");
+  }
+
+  const { signature } = transaction;
+  if (!signature) {
+    throw new Error("Transaction has no signature");
+  }
+
+  let publicKey: AccountPublicKey;
+  if (isEd25519Signature(signature)) {
+    publicKey = new Ed25519PublicKey(signature.public_key);
+  } else if (isMultiEd25519Signature(signature)) {
+    publicKey = new MultiEd25519PublicKey({
+      publicKeys: signature.public_keys.map((pk) => new Ed25519PublicKey(pk)),
+      threshold: signature.threshold,
+    });
+  } else if (isSingleSenderSingleKeySignature(signature)) {
+    publicKey = parsePublicKey(signature.public_key);
+  } else if (isSingleSenderMultiKeySignature(signature)) {
+    const publicKeys: Array<PublicKey> = [];
+    for (const pk of signature.public_keys) {
+      publicKeys.push(parsePublicKey(pk));
+    }
+    publicKey = new MultiKey({
+      publicKeys,
+      signaturesRequired: signature.signatures_required,
+    });
+  } else {
+    throw new Error("Unknown signature type");
+  }
+  if (publicKey.authKey().toString() !== accountData.authentication_key) {
+    throw new Error(
+      "Derived public key does not match authentication key. The most recent signature was likely a key rotation.",
+    );
+  }
+  return publicKey;
+}
+
+export async function getMultiKeyFromAuthenticationKey(args: {
+  aptosConfig: AptosConfig;
+  authKey: AuthenticationKey;
+}): Promise<MultiKey | MultiEd25519PublicKey> {
+  const { aptosConfig, authKey } = args;
+
+  const result = await getMultiKeysForAuthenticationKeys({ aptosConfig, authKeys: [authKey] });
+
+  if (result.length === 0) {
+    throw new Error(`No multikey found for the given authentication key ${authKey}`);
+  }
+  if (result.length > 1) {
+    // This should never happen. Rows are uniquely keyed by auth key.
+    throw new Error(`More than one multikey found for the given authentication key ${authKey}`);
+  }
+
+  return result[0].publicKey;
+}
+
+// export async function deriveAccount(
+//   args: { aptosConfig: AptosConfig } & (
+//     | { privateKey: PrivateKey }
+//     | DeriveKeylessAccountParams
+//     | { multiKeyDerivation: (PrivateKey | DeriveKeylessAccountParams)[] }
+//   ),
+// ): Promise<Account> {
+//   const { aptosConfig, ...rest } = args;
+//   if ("privateKey" in rest) {
+//     const accounts = await getAccountsForPublicKey({ aptosConfig, publicKey: rest.privateKey.publicKey() as AccountPublicKey });
+//     return deriveAccountFromPrivateKey({ aptosConfig, ...rest });
+//   } else if ("jwt" in rest) {
+//     return deriveKeylessAccount({ aptosConfig, ...rest });
+//   }
+//   const accounts: Account[] = [];
+//   for (const derivation of rest.multiKeyDerivation) { 
+//     if ("privateKey" in derivation) {
+//       accounts.push(deriveAccountFromPrivateKey({ aptosConfig, ...derivation }));
+//     } else if ("jwt" in derivation) {
+//       accounts.push(deriveKeylessAccount({ aptosConfig, ...derivation }));
+//     }
+//   }
+//   return new MultiKey({
+//     publicKeys: accounts.map((account) => account.publicKey),
+//     threshold: rest.multiKeyDerivation.length,
+//   });
+// } 
+
+type AccountDerivationParams = { privateKey: PrivateKey } | DeriveKeylessAccountParams;
+
+function parsePublicKey(data: { value: string; type: string }): AnyPublicKey {
+  if (data.type === "keyless") {
+    const deserializer = Deserializer.fromHex(data.value);
+    return new AnyPublicKey(KeylessPublicKey.deserialize(deserializer));
+  }
+  if (data.type === "ed25519") {
+    return new AnyPublicKey(new Ed25519PublicKey(data.value));
+  }
+  if (data.type === "secp256k1_ecdsa") {
+    return new AnyPublicKey(new Secp256k1PublicKey(data.value));
+  }
+  throw new Error("Unknown public key type");
+}

package/src/internal/experimental.ts

@@ -0,0 +1,55 @@
+import { AptosConfig } from "../api/aptosConfig";
+import { generateViewFunctionPayload, InputViewFunctionData } from "../transactions";
+import { LedgerVersionArg, MimeType } from "../types";
+import { Serializer } from "../bcs";
+import { postBinaryAptosFullNode } from "../client";
+
+export async function viewBinary(args: {
+  aptosConfig: AptosConfig;
+  payload: InputViewFunctionData;
+  options?: LedgerVersionArg & { convert?: undefined };
+}): Promise<Uint8Array>;
+
+export async function viewBinary<T extends {}>(args: {
+  aptosConfig: AptosConfig;
+  payload: InputViewFunctionData;
+  options?: LedgerVersionArg & { convert?: (input: Uint8Array) => T };
+}): Promise<T>;
+
+/**
+ * Reads a binary view function, and converts into the appropriate type if a converter is provided.
+ * @experimental
+ * @param args
+ */
+export async function viewBinary<T extends {} = Uint8Array>(args: {
+  aptosConfig: AptosConfig;
+  payload: InputViewFunctionData;
+  options?: LedgerVersionArg & { convert?: (input: Uint8Array) => T };
+}): Promise<Uint8Array | T> {
+  const { aptosConfig, payload, options } = args;
+  const viewFunctionPayload = await generateViewFunctionPayload({
+    ...payload,
+    aptosConfig,
+  });
+
+  const serializer = new Serializer();
+  viewFunctionPayload.serialize(serializer);
+  const bytes = serializer.toUint8Array();
+
+  const { data } = await postBinaryAptosFullNode<Uint8Array>({
+    aptosConfig,
+    path: "view",
+    originMethod: "view",
+    contentType: MimeType.BCS_VIEW_FUNCTION,
+    acceptType: MimeType.BCS,
+    params: { ledger_version: options?.ledgerVersion },
+    body: bytes,
+  });
+
+  const array = new Uint8Array(data);
+  if (options?.convert) {
+    return options.convert(array);
+  }
+
+  return array;
+}

package/src/internal/keyless.ts

@@ -145,6 +145,18 @@ export async function getProof(args: {
   return signedProof;
 }
 
+/**
+ * Parameters for deriving a keyless account
+ */
+export type DeriveKeylessAccountParams = {
+  jwt: string;
+  ephemeralKeyPair: EphemeralKeyPair;
+  jwkAddress?: AccountAddressInput;
+  uidKey?: string;
+  pepper?: HexInput;
+  proofFetchCallback?: ProofFetchCallback;
+};
+
 /**
  * Derives a keyless account by fetching the necessary proof and looking up the original account address.
  * This function helps in creating a keyless account that can be used without managing private keys directly.
@@ -178,15 +190,11 @@ export async function deriveKeylessAccount(args: {
   proofFetchCallback?: ProofFetchCallback;
 }): Promise<FederatedKeylessAccount>;
 
-export async function deriveKeylessAccount(args: {
-  aptosConfig: AptosConfig;
-  jwt: string;
-  ephemeralKeyPair: EphemeralKeyPair;
-  jwkAddress?: AccountAddressInput;
-  uidKey?: string;
-  pepper?: HexInput;
-  proofFetchCallback?: ProofFetchCallback;
-}): Promise<KeylessAccount | FederatedKeylessAccount> {
+export async function deriveKeylessAccount(
+  args: {
+    aptosConfig: AptosConfig;
+  } & DeriveKeylessAccountParams,
+): Promise<KeylessAccount | FederatedKeylessAccount> {
   const { aptosConfig, jwt, jwkAddress, uidKey, proofFetchCallback, pepper = await getPepper(args) } = args;
   const { verificationKey, maxExpHorizonSecs } = await getKeylessConfig({ aptosConfig });
 

package/src/internal/move/jwks/build/jwk/BuildInfo.yaml

@@ -0,0 +1,56 @@
+---
+compiled_package_info:
+  package_name: jwk
+  address_alias_instantiation:
+    Extensions: "0000000000000000000000000000000000000000000000000000000000000001"
+    aptos_framework: "0000000000000000000000000000000000000000000000000000000000000001"
+    aptos_fungible_asset: 000000000000000000000000000000000000000000000000000000000000000a
+    aptos_std: "0000000000000000000000000000000000000000000000000000000000000001"
+    aptos_token: "0000000000000000000000000000000000000000000000000000000000000003"
+    core_resources: 000000000000000000000000000000000000000000000000000000000a550c18
+    std: "0000000000000000000000000000000000000000000000000000000000000001"
+    vm: "0000000000000000000000000000000000000000000000000000000000000000"
+    vm_reserved: "0000000000000000000000000000000000000000000000000000000000000000"
+  source_digest: 3437D4FB002907781F0FE5D46FC4E668C8B8F0420AA77751774AD63B0C2730BF
+  build_flags:
+    dev_mode: false
+    test_mode: false
+    override_std: ~
+    generate_docs: false
+    generate_abis: false
+    generate_move_model: true
+    full_model_generation: false
+    install_dir: ~
+    force_recompilation: false
+    additional_named_addresses: {}
+    architecture: ~
+    fetch_deps_only: false
+    skip_fetch_latest_git_deps: false
+    compiler_config:
+      bytecode_version: 6
+      known_attributes:
+        - bytecode_instruction
+        - deprecated
+        - event
+        - expected_failure
+        - "fmt::skip"
+        - legacy_entry_fun
+        - "lint::allow_unsafe_randomness"
+        - "lint::skip"
+        - native_interface
+        - randomness
+        - resource_group
+        - resource_group_member
+        - test
+        - test_only
+        - verify_only
+        - view
+      skip_attribute_checks: false
+      compiler_version: ~
+      language_version: ~
+      experiments:
+        - optimize=on
+dependencies:
+  - AptosFramework
+  - AptosStdlib
+  - MoveStdlib