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

package/src/internal/account.ts

@@ -12,18 +12,11 @@ import { AptosConfig } from "../api/aptosConfig";
 import { getAptosFullNode, paginateWithCursor, paginateWithObfuscatedCursor } from "../client";
 import {
   AccountData,
-  AnyPublicKeyVariant,
   GetAccountCoinsDataResponse,
   GetAccountCollectionsWithOwnedTokenResponse,
   GetAccountOwnedTokensFromCollectionResponse,
   GetAccountOwnedTokensQueryResponse,
-  GetMultiKeyForAuthKeyResponse,
   GetObjectDataQueryResponse,
-  isEd25519Signature,
-  isMultiEd25519Signature,
-  isSingleSenderMultiKeySignature,
-  isSingleSenderSingleKeySignature,
-  isUserTransactionResponse,
   LedgerVersionArg,
   MoveModuleBytecode,
   MoveResource,
@@ -37,19 +30,7 @@ import {
 } from "../types";
 import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
 import { Account, Ed25519Account, MultiEd25519Account } from "../account";
-import {
-  AbstractMultiKey,
-  AccountPublicKey,
-  AnyPublicKey,
-  Ed25519PublicKey,
-  FederatedKeylessPublicKey,
-  KeylessPublicKey,
-  MultiEd25519PublicKey,
-  MultiKey,
-  PrivateKey,
-  PublicKey,
-  Secp256k1PublicKey,
-} from "../core/crypto";
+import { AnyPublicKey, Ed25519PublicKey, PrivateKey } from "../core/crypto";
 import { queryIndexer } from "./general";
 import { getModules as getModulesUtil, getModule as getModuleUtil, getInfo as getInfoUtil } from "./utils";
 import {
@@ -61,10 +42,6 @@ import {
   GetAccountOwnedTokensQuery,
   GetAccountTokensCountQuery,
   GetAccountTransactionsCountQuery,
-  GetMultiKeyForAuthKeyQuery,
-  GetAuthKeysForPublicKeyQuery,
-  GetAccountAddressesForAuthKeyQuery,
-  GetSignaturesQuery,
 } from "../types/generated/operations";
 import {
   GetAccountCoinsCount,
@@ -75,23 +52,16 @@ import {
   GetAccountOwnedTokensFromCollection,
   GetAccountTokensCount,
   GetAccountTransactionsCount,
-  GetMultiKeyForAuthKey,
-  GetAuthKeysForPublicKey,
-  GetAccountAddressesForAuthKey,
-  GetSignatures,
 } from "../types/generated/queries";
-import { Secp256k1PrivateKey, AuthenticationKey, Ed25519PrivateKey, createObjectAddress, Hex } from "../core";
+import { Secp256k1PrivateKey, AuthenticationKey, Ed25519PrivateKey, createObjectAddress } 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 { signAndSubmitTransaction, generateTransaction } from "./transactionSubmission";
 import { EntryFunctionABI, RotationProofChallenge, TypeTagU8, TypeTagVector } from "../transactions";
 import { U8, MoveVector } from "../bcs";
 import { waitForTransaction } from "./transaction";
-import { deriveKeylessAccount, DeriveKeylessAccountParams } from "./keyless";
 
 /**
  * Retrieves account information for a specified account address.
@@ -987,366 +957,3 @@ async function rotateAuthKeyUnverified(args: {
     transaction: rawTxn,
   });
 }
-
-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(`No signatures found for address ${address}`);
-  }
-  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/keyless.ts

@@ -145,18 +145,6 @@ 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.
@@ -190,11 +178,15 @@ export async function deriveKeylessAccount(args: {
   proofFetchCallback?: ProofFetchCallback;
 }): Promise<FederatedKeylessAccount>;
 
-export async function deriveKeylessAccount(
-  args: {
-    aptosConfig: AptosConfig;
-  } & DeriveKeylessAccountParams,
-): Promise<KeylessAccount | FederatedKeylessAccount> {
+export async function deriveKeylessAccount(args: {
+  aptosConfig: AptosConfig;
+  jwt: string;
+  ephemeralKeyPair: EphemeralKeyPair;
+  jwkAddress?: AccountAddressInput;
+  uidKey?: string;
+  pepper?: HexInput;
+  proofFetchCallback?: ProofFetchCallback;
+}): Promise<KeylessAccount | FederatedKeylessAccount> {
   const { aptosConfig, jwt, jwkAddress, uidKey, proofFetchCallback, pepper = await getPepper(args) } = args;
   const { verificationKey, maxExpHorizonSecs } = await getKeylessConfig({ aptosConfig });
 

package/src/transactions/scriptComposer/index.ts

@@ -5,9 +5,9 @@ import { ScriptComposerWasm } from "@aptos-labs/script-composer-pack";
 import { AptosApiType, getFunctionParts } from "../../utils";
 import { AptosConfig } from "../../api/aptosConfig";
 import { InputBatchedFunctionData } from "../types";
-import { fetchMoveFunctionAbi, standardizeTypeTags } from "../transactionBuilder";
+import { standardizeTypeTags } from "../transactionBuilder";
 import { CallArgument } from "../../types";
-import { convertCallArgument } from "../transactionBuilder/remoteAbi";
+import { convertArgument, fetchModuleAbi } from "../transactionBuilder/remoteAbi";
 
 /**
  * A wrapper class around TransactionComposer, which is a WASM library compiled
@@ -63,16 +63,29 @@ export class AptosScriptComposer {
       }
     }
     const typeArguments = standardizeTypeTags(input.typeArguments);
-    const functionAbi = await fetchMoveFunctionAbi(moduleAddress, moduleName, functionName, this.config);
+    const moduleAbi = await fetchModuleAbi(moduleAddress, moduleName, this.config);
+    if (!moduleAbi) {
+      throw new Error(`Could not find module ABI for '${moduleAddress}::${moduleName}'`);
+    }
+
     // Check the type argument count against the ABI
-    if (typeArguments.length !== functionAbi.typeParameters.length) {
+    const functionAbi = moduleAbi?.exposed_functions.find((func) => func.name === functionName);
+    if (!functionAbi) {
+      throw new Error(`Could not find function ABI for '${moduleAddress}::${moduleName}::${functionName}'`);
+    }
+
+    if (typeArguments.length !== functionAbi.generic_type_params.length) {
       throw new Error(
-        `Type argument count mismatch, expected ${functionAbi.typeParameters.length}, received ${typeArguments.length}`,
+        `Type argument count mismatch, expected ${functionAbi?.generic_type_params.length}, received ${typeArguments.length}`,
       );
     }
 
     const functionArguments: CallArgument[] = input.functionArguments.map((arg, i) =>
-      convertCallArgument(arg, functionName, functionAbi, i, typeArguments),
+      arg instanceof CallArgument
+        ? arg
+        : CallArgument.newBytes(
+            convertArgument(functionName, moduleAbi, arg, i, typeArguments, { allowUnknownStructs: true }).bcsToBytes(),
+          ),
     );
 
     return this.builder.add_batched_call(