support general proof challenege

Author: 0xmaayan

src/api/general.ts

@@ -3,6 +3,7 @@
 
 import { AptosConfig } from "./aptosConfig";
 import {
+  createProofChallenge,
   getBlockByHeight,
   getBlockByVersion,
   getChainTopUserTransactions,
@@ -21,11 +22,12 @@ import {
   GraphqlQuery,
   LedgerInfo,
   LedgerVersionArg,
+  MoveFunctionId,
   MoveValue,
   TableItemRequest,
 } from "../types";
 import { ProcessorType } from "../utils/const";
-import { InputViewFunctionData } from "../transactions";
+import { InputViewFunctionData, ProofChallenge } from "../transactions";
 
 /**
  * A class to query all `General` Aptos related queries
@@ -224,4 +226,11 @@ export class General {
   async getProcessorStatus(processorType: ProcessorType): Promise<GetProcessorStatusResponse[0]> {
     return getProcessorStatus({ aptosConfig: this.config, processorType });
   }
+
+  async createProofChallenge(args: { struct: MoveFunctionId; data: Array<any> }): Promise<ProofChallenge> {
+    return createProofChallenge({
+      config: this.config,
+      ...args,
+    });
+  }
 }

src/api/transaction.ts

@@ -25,15 +25,17 @@ import {
   publicPackageTransaction,
   rotateAuthKey,
   signAndSubmitTransaction,
+  signProofChallenge,
   signTransaction,
 } from "../internal/transactionSubmission";
 import {
   AccountAuthenticator,
   AnyRawTransaction,
   InputGenerateTransactionOptions,
   InputGenerateTransactionPayloadData,
+  ProofChallenge,
 } from "../transactions";
-import { AccountAddressInput, Account, PrivateKey } from "../core";
+import { AccountAddressInput, Account, PrivateKey, Signature } from "../core";
 import { Build } from "./transactionSubmission/build";
 import { Simulate } from "./transactionSubmission/simulate";
 import { Submit } from "./transactionSubmission/submit";
@@ -306,6 +308,13 @@ export class Transaction {
     });
   }
 
+  // eslint-disable-next-line class-methods-use-this
+  signProofChallenge(args: { challenge: ProofChallenge; signer: Account }): Signature {
+    return signProofChallenge({
+      ...args,
+    });
+  }
+
   // TRANSACTION SUBMISSION //
 
   /**

src/internal/general.ts

@@ -9,7 +9,13 @@
  */
 
 import { AptosConfig } from "../api/aptosConfig";
+import { MoveString } from "../bcs";
 import { getAptosFullNode, postAptosFullNode, postAptosIndexer } from "../client";
+import { AccountAddress } from "../core";
+import { getFunctionParts } from "../transactions/transactionBuilder/helpers";
+import { fetchStructFieldsAbi, convertArgument } from "../transactions/transactionBuilder/remoteAbi";
+import { ProofChallenge } from "../transactions/instances";
+import { EntryFunctionArgumentTypes } from "../transactions/types";
 import {
   AnyNumber,
   Block,
@@ -18,6 +24,7 @@ import {
   GraphqlQuery,
   LedgerInfo,
   LedgerVersionArg,
+  MoveFunctionId,
   TableItemRequest,
 } from "../types";
 import { GetChainTopUserTransactionsQuery, GetProcessorStatusQuery } from "../types/generated/operations";
@@ -162,3 +169,33 @@ export async function getProcessorStatus(args: {
 
   return data.processor_status[0];
 }
+
+export async function createProofChallenge(args: {
+  config: AptosConfig;
+  struct: MoveFunctionId;
+  data: Array<any>;
+}): Promise<ProofChallenge> {
+  const { config, struct, data } = args;
+  const { moduleAddress, moduleName, functionName } = getFunctionParts(struct);
+  const structFieldsAbi = await fetchStructFieldsAbi(moduleAddress, moduleName, functionName, config);
+
+  // Check all BCS types, and convert any non-BCS types
+  const functionArguments: Array<EntryFunctionArgumentTypes> =
+    data.map((arg, i) => convertArgument(functionName, structFieldsAbi, arg, i, structFieldsAbi.parameters)) ?? [];
+
+  // Check that all arguments are accounted for
+  if (functionArguments.length !== structFieldsAbi.parameters.length) {
+    throw new Error(
+      // eslint-disable-next-line max-len
+      `Too few arguments for '${moduleAddress}::${moduleName}::${functionName}', expected ${structFieldsAbi.parameters.length} but got ${functionArguments.length}`,
+    );
+  }
+
+  const challenge = new ProofChallenge([
+    AccountAddress.from(moduleAddress),
+    new MoveString(moduleName),
+    new MoveString(functionName),
+    ...functionArguments,
+  ]);
+  return challenge;
+}

src/internal/transactionSubmission.ts

@@ -10,9 +10,9 @@ import { MoveVector, U8 } from "../bcs";
 import { postAptosFullNode } from "../client";
 import { Account } from "../core/account";
 import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
-import { PrivateKey } from "../core/crypto";
+import { PrivateKey, Signature } from "../core/crypto";
 import { AccountAuthenticator } from "../transactions/authenticator/account";
-import { RotationProofChallenge } from "../transactions/instances/rotationProofChallenge";
+import { ProofChallenge, RotationProofChallenge } from "../transactions/instances/rotationProofChallenge";
 import {
   buildTransaction,
   generateTransactionPayload,
@@ -208,6 +208,13 @@ export function signTransaction(args: { signer: Account; transaction: AnyRawTran
   return accountAuthenticator;
 }
 
+export function signProofChallenge(args: { challenge: ProofChallenge; signer: Account }): Signature {
+  const { challenge, signer } = args;
+  const challengeHex = challenge.bcsToBytes();
+  const signature = signer.sign(challengeHex);
+  return signature;
+}
+
 /**
  * Simulates a transaction before singing it.
  *
@@ -350,6 +357,7 @@ export async function rotateAuthKey(args: {
 
   // Sign the challenge
   const challengeHex = challenge.bcsToBytes();
+
   const proofSignedByCurrentPrivateKey = fromAccount.sign(challengeHex);
   const proofSignedByNewPrivateKey = newAccount.sign(challengeHex);
 

src/transactions/instances/rotationProofChallenge.ts

@@ -7,6 +7,21 @@ import { AnyNumber } from "../../types";
 import { PublicKey } from "../../core/crypto";
 import { MoveString, MoveVector, U64, U8 } from "../../bcs";
 
+export class ProofChallenge extends Serializable {
+  public readonly data: Serializable[];
+
+  constructor(data: Serializable[]) {
+    super();
+    this.data = data;
+  }
+
+  serialize(serializer: Serializer): void {
+    this.data.forEach((data) => {
+      serializer.serialize(data);
+    });
+  }
+}
+
 /**
  * Representation of the challenge which is needed to sign by owner of the account
  * to rotate the authentication key.

src/transactions/transactionBuilder/remoteAbi.ts

@@ -75,6 +75,22 @@ export async function fetchFunctionAbi(
   return undefined;
 }
 
+export async function fetchStructAbi(
+  moduleAddress: string,
+  moduleName: string,
+  structName: string,
+  aptosConfig: AptosConfig,
+) {
+  // This fetch from the API is currently cached
+  const module = await getModule({ aptosConfig, accountAddress: moduleAddress, moduleName });
+
+  if (module.abi) {
+    return module.abi.structs.find((struct) => struct.name === structName);
+  }
+
+  return undefined;
+}
+
 /**
  * Fetches the ABI for an entry function from the module
  *
@@ -160,6 +176,30 @@ export async function fetchViewFunctionAbi(
   };
 }
 
+export async function fetchStructFieldsAbi(
+  moduleAddress: string,
+  moduleName: string,
+  structName: string,
+  aptosConfig: AptosConfig,
+) {
+  const structAbi = await fetchStructAbi(moduleAddress, moduleName, structName, aptosConfig);
+
+  // If there's no ABI, then the function is invalid
+  if (!structAbi) {
+    throw new Error(`Could not find Struct ABI for '${moduleAddress}::${moduleName}::${structName}'`);
+  }
+
+  const params: TypeTag[] = [];
+  for (let i = 0; i < structAbi.fields.length; i += 1) {
+    params.push(parseTypeTag(structAbi.fields[i].type, { allowGenerics: true }));
+  }
+
+  return {
+    typeParameters: structAbi.generic_type_params,
+    parameters: params,
+  };
+}
+
 /**
  * Converts a non-BCS encoded argument into BCS encoded, if necessary
  * @param functionName

tests/e2e/transaction/signTransaction.test.ts

@@ -6,6 +6,8 @@ import {
   AccountAuthenticator,
   AccountAuthenticatorEd25519,
   AccountAuthenticatorSingleKey,
+  MoveVector,
+  U8,
 } from "../../../src";
 import { longTestTimeout } from "../../unit/helper";
 import { getAptosClient } from "../helper";
@@ -216,3 +218,46 @@ describe("sign transaction", () => {
     });
   });
 });
+
+test.only("test", async () => {
+  const fromAccount = Account.generate();
+  const newAccount = Account.generate();
+
+  await aptos.fundAccount({ accountAddress: fromAccount.accountAddress, amount: 1_000_000_000 });
+  await aptos.fundAccount({ accountAddress: newAccount.accountAddress, amount: 1_000_000_000 });
+
+  const accountInfo = await aptos.getAccountInfo({
+    accountAddress: fromAccount.accountAddress,
+  });
+
+  const challenge = await aptos.createProofChallenge({
+    struct: "0x1::account::RotationProofChallenge",
+    data: [
+      BigInt(accountInfo.sequence_number),
+      fromAccount.accountAddress,
+      accountInfo.authentication_key,
+      newAccount.publicKey.toUint8Array(),
+    ],
+  });
+
+  const proofSignedByCurrentPrivateKey = aptos.signProofChallenge({ challenge, signer: fromAccount });
+  const proofSignedByNewPrivateKey = aptos.signProofChallenge({ challenge, signer: newAccount });
+
+  const transaction = await aptos.transaction.build.simple({
+    sender: fromAccount.accountAddress,
+    data: {
+      function: "0x1::account::rotate_authentication_key",
+      functionArguments: [
+        new U8(fromAccount.signingScheme), // from scheme
+        MoveVector.U8(fromAccount.publicKey.toUint8Array()),
+        new U8(newAccount.signingScheme), // to scheme
+        MoveVector.U8(newAccount.publicKey.toUint8Array()),
+        MoveVector.U8(proofSignedByCurrentPrivateKey.toUint8Array()),
+        MoveVector.U8(proofSignedByNewPrivateKey.toUint8Array()),
+      ],
+    },
+  });
+
+  const response = await aptos.signAndSubmitTransaction({ signer: fromAccount, transaction });
+  console.log("response", response);
+});