@aptos-labs/ts-sdk 0.0.2 → 0.0.4

package/src/transactions/instances/rotationProofChallenge.ts

@@ -0,0 +1,58 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { Serializer, Serializable } from "../../bcs/serializer";
+import { AccountAddress } from "../../core/accountAddress";
+import { AnyNumber } from "../../types";
+import { PublicKey } from "../../core/crypto/asymmetricCrypto";
+import { MoveString, MoveVector, U64, U8 } from "../../bcs";
+
+/**
+ * Representation of the challenge which is needed to sign by owner of the account
+ * to rotate the authentication key.
+ */
+export class RotationProofChallenge extends Serializable {
+  // Resource account address
+  public readonly accountAddress: AccountAddress = AccountAddress.ONE;
+
+  // Module name, i.e: 0x1::account
+  public readonly moduleName: MoveString = new MoveString("account");
+
+  // The rotation proof challenge struct name that live under the module
+  public readonly structName: MoveString = new MoveString("RotationProofChallenge");
+
+  // Signer's address
+  public readonly originator: AccountAddress;
+
+  // Signer's current authentication key
+  public readonly currentAuthKey: AccountAddress;
+
+  // New public key to rotate to
+  public readonly newPublicKey: MoveVector<U8>;
+
+  // Sequence number of the account
+  public readonly sequenceNumber: U64;
+
+  constructor(args: {
+    sequenceNumber: AnyNumber;
+    originator: AccountAddress;
+    currentAuthKey: AccountAddress;
+    newPublicKey: PublicKey;
+  }) {
+    super();
+    this.sequenceNumber = new U64(args.sequenceNumber);
+    this.originator = args.originator;
+    this.currentAuthKey = args.currentAuthKey;
+    this.newPublicKey = MoveVector.U8(args.newPublicKey.toUint8Array());
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serialize(this.accountAddress);
+    serializer.serialize(this.moduleName);
+    serializer.serialize(this.structName);
+    serializer.serialize(this.sequenceNumber);
+    serializer.serialize(this.originator);
+    serializer.serialize(this.currentAuthKey);
+    serializer.serialize(this.newPublicKey);
+  }
+}

package/src/transactions/instances/transactionPayload.ts

@@ -13,7 +13,7 @@ import { Identifier } from "./identifier";
 import { ModuleId } from "./moduleId";
 import type { EntryFunctionArgument, ScriptFunctionArgument, TransactionArgument } from "./transactionArgument";
 import { MoveModuleId, ScriptTransactionArgumentVariants, TransactionPayloadVariants } from "../../types";
-import { TypeTag } from "../typeTag/typeTag";
+import { TypeTag } from "../typeTag";
 
 /**
  * Deserialize a Script Transaction Argument
@@ -334,7 +334,7 @@ export class Script {
 export class MultiSig {
   public readonly multisig_address: AccountAddress;
 
-  public readonly transaction_payload?: MultiSigTransactionPayload;
+  public readonly transaction_payload?: MultisigTransactionPayload;
 
   /**
    * Contains the payload to run a multi-sig account transaction.
@@ -344,7 +344,7 @@ export class MultiSig {
    * @param transaction_payload The payload of the multi-sig transaction. This is optional when executing a multi-sig
    *  transaction whose payload is already stored on chain.
    */
-  constructor(multisig_address: AccountAddress, transaction_payload?: MultiSigTransactionPayload) {
+  constructor(multisig_address: AccountAddress, transaction_payload?: MultisigTransactionPayload) {
     this.multisig_address = multisig_address;
     this.transaction_payload = transaction_payload;
   }
@@ -366,16 +366,21 @@ export class MultiSig {
     const payloadPresent = deserializer.deserializeBool();
     let transaction_payload;
     if (payloadPresent) {
-      transaction_payload = MultiSigTransactionPayload.deserialize(deserializer);
+      transaction_payload = MultisigTransactionPayload.deserialize(deserializer);
     }
     return new MultiSig(multisig_address, transaction_payload);
   }
 }
 
 /**
- * Representation of a MultiSig Transaction Payload that can serialized and deserialized
+ * Representation of a MultiSig Transaction Payload from `multisig_account.move`
+ * that can be serialized and deserialized
+
+ * This class exists right now to represent an extensible transaction payload class for
+ * transactions used in `multisig_account.move`. Eventually, this class will be able to
+ * support script payloads when the `multisig_account.move` module supports them.
  */
-export class MultiSigTransactionPayload {
+export class MultisigTransactionPayload {
   public readonly transaction_payload: EntryFunction;
 
   /**
@@ -399,9 +404,9 @@ export class MultiSigTransactionPayload {
     this.transaction_payload.serialize(serializer);
   }
 
-  static deserialize(deserializer: Deserializer): MultiSigTransactionPayload {
+  static deserialize(deserializer: Deserializer): MultisigTransactionPayload {
     // This is the enum value indicating which type of payload the multi-sig transaction contains.
     deserializer.deserializeUleb128AsU32();
-    return new MultiSigTransactionPayload(EntryFunction.deserialize(deserializer));
+    return new MultisigTransactionPayload(EntryFunction.deserialize(deserializer));
   }
 }

package/src/transactions/transactionBuilder/helpers.ts

@@ -0,0 +1,103 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import {
+  EntryFunctionArgumentTypes,
+  InputGenerateTransactionPayloadData,
+  InputGenerateTransactionPayloadDataWithRemoteABI,
+  InputScriptData,
+  SimpleEntryFunctionArgumentTypes,
+} from "../types";
+import { Bool, FixedBytes, MoveString, U128, U16, U256, U32, U64, U8 } from "../../bcs";
+import { AccountAddress } from "../../core";
+import { MoveFunction, MoveStructType } from "../../types";
+
+export function isBool(arg: SimpleEntryFunctionArgumentTypes): arg is boolean {
+  return typeof arg === "boolean";
+}
+
+export function isString(arg: any): arg is string {
+  return typeof arg === "string";
+}
+
+export function isNumber(arg: SimpleEntryFunctionArgumentTypes): arg is number {
+  return typeof arg === "number";
+}
+
+export function isLargeNumber(arg: SimpleEntryFunctionArgumentTypes): arg is number | bigint | string {
+  return typeof arg === "number" || typeof arg === "bigint" || typeof arg === "string";
+}
+
+export function isNull(arg: SimpleEntryFunctionArgumentTypes): arg is null | undefined {
+  return arg === null || arg === undefined;
+}
+
+export function isBcsBool(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is Bool {
+  return arg instanceof Bool;
+}
+export function isBcsAddress(
+  arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes,
+): arg is AccountAddress {
+  return arg instanceof AccountAddress;
+}
+export function isBcsString(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is MoveString {
+  return arg instanceof MoveString;
+}
+export function isBcsFixedBytes(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is FixedBytes {
+  return arg instanceof FixedBytes;
+}
+
+export function isBcsU8(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U8 {
+  return arg instanceof U8;
+}
+export function isBcsU16(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U16 {
+  return arg instanceof U16;
+}
+export function isBcsU32(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U32 {
+  return arg instanceof U32;
+}
+export function isBcsU64(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U64 {
+  return arg instanceof U64;
+}
+export function isBcsU128(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U128 {
+  return arg instanceof U128;
+}
+export function isBcsU256(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U256 {
+  return arg instanceof U256;
+}
+
+export function isScriptDataInput(
+  arg: InputGenerateTransactionPayloadDataWithRemoteABI | InputGenerateTransactionPayloadData,
+): arg is InputScriptData {
+  return "bytecode" in arg;
+}
+
+export function throwTypeMismatch(expectedType: string, position: number) {
+  throw new Error(`Type mismatch for argument ${position}, expected '${expectedType}'`);
+}
+
+/**
+ * Finds first non-signer arg.
+ *
+ * A function is often defined with a `signer` or `&signer` arguments at the start, which are filled in
+ * by signatures, and not by the caller.
+ * @param functionAbi
+ */
+export function findFirstNonSignerArg(functionAbi: MoveFunction): number {
+  const index = functionAbi.params.findIndex((param) => param !== "signer" && param !== "&signer");
+  if (index < 0) {
+    return functionAbi.params.length;
+  }
+  return index;
+}
+
+export function getFunctionParts(functionArg: MoveStructType) {
+  const funcNameParts = functionArg.split("::");
+  if (funcNameParts.length !== 3) {
+    throw new Error(`Invalid function ${functionArg}`);
+  }
+  const moduleAddress = funcNameParts[0];
+  const moduleName = funcNameParts[1];
+  const functionName = funcNameParts[2];
+  return { moduleAddress, moduleName, functionName };
+}

package/src/transactions/transactionBuilder/index.ts

@@ -0,0 +1,6 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+export * from "./helpers";
+export * from "./transactionBuilder";
+export * from "./remoteAbi";

package/src/transactions/transactionBuilder/remoteAbi.ts

@@ -0,0 +1,339 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { parseTypeTag } from "../typeTag/parser";
+import { TypeTag, TypeTagStruct } from "../typeTag";
+import { AptosConfig } from "../../api/aptosConfig";
+import { EntryFunctionArgumentTypes, SimpleEntryFunctionArgumentTypes, EntryFunctionABI } from "../types";
+import { Bool, MoveOption, MoveString, MoveVector, U128, U16, U256, U32, U64, U8 } from "../../bcs";
+import { AccountAddress, Hex } from "../../core";
+import { getModule } from "../../internal/account";
+import {
+  findFirstNonSignerArg,
+  isBcsAddress,
+  isBcsBool,
+  isBcsFixedBytes,
+  isBcsString,
+  isBcsU128,
+  isBcsU16,
+  isBcsU256,
+  isBcsU32,
+  isBcsU64,
+  isBcsU8,
+  isBool,
+  isLargeNumber,
+  isNull,
+  isNumber,
+  isString,
+  throwTypeMismatch,
+} from "./helpers";
+
+/**
+ * Convert type arguments to only type tags, allowing for string representations of type tags
+ */
+export function standardizeTypeTags(typeArguments?: Array<TypeTag | string>): Array<TypeTag> {
+  return (
+    typeArguments?.map((typeArg: string | TypeTag): TypeTag => {
+      // Convert to TypeTag if it's a string representation
+      if (isString(typeArg)) {
+        return parseTypeTag(typeArg);
+      }
+      return typeArg;
+    }) ?? []
+  );
+}
+
+/**
+ * Fetches the ABI for an entry function from the module
+ *
+ * @param moduleAddress
+ * @param moduleName
+ * @param functionName
+ * @param aptosConfig
+ */
+export async function fetchEntryFunctionAbi(
+  moduleAddress: string,
+  moduleName: string,
+  functionName: string,
+  aptosConfig: AptosConfig,
+): Promise<EntryFunctionABI> {
+  // This fetch from the API is currently cached
+  const module = await getModule({ aptosConfig, accountAddress: moduleAddress, moduleName });
+
+  const functionAbi = module.abi?.exposed_functions.find((func) => func.name === functionName);
+
+  // If there's no ABI, then the function is invalid
+  if (!functionAbi) {
+    throw new Error(`Could not find entry function ABI for '${moduleAddress}::${moduleName}::${functionName}'`);
+  }
+
+  // Non-entry functions also can't be used
+  if (!functionAbi.is_entry) {
+    throw new Error(`'${moduleAddress}::${moduleName}::${functionName}' is not an entry function`);
+  }
+
+  // Remove the signer arguments
+  const first = findFirstNonSignerArg(functionAbi);
+  const params = [];
+  for (let i = first; i < functionAbi.params.length; i += 1) {
+    params.push(parseTypeTag(functionAbi.params[i], { allowGenerics: true }));
+  }
+
+  return {
+    typeParameters: functionAbi.generic_type_params,
+    parameters: params,
+  };
+}
+
+/**
+ * Converts a non-BCS encoded argument into BCS encoded, if necessary
+ * @param functionName
+ * @param functionAbi
+ * @param arg
+ * @param position
+ */
+export function convertArgument(
+  functionName: string,
+  functionAbi: EntryFunctionABI,
+  arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes,
+  position: number,
+  genericTypeParams: Array<TypeTag>,
+) {
+  // Ensure not too many arguments
+  if (position >= functionAbi.parameters.length) {
+    throw new Error(`Too many arguments for '${functionName}', expected ${functionAbi.parameters.length}`);
+  }
+
+  // If the argument is bcs encoded, we can just use it directly
+  if (
+    isBcsBool(arg) ||
+    isBcsU8(arg) ||
+    isBcsU16(arg) ||
+    isBcsU32(arg) ||
+    isBcsU64(arg) ||
+    isBcsU128(arg) ||
+    isBcsU256(arg) ||
+    isBcsAddress(arg) ||
+    isBcsString(arg) ||
+    isBcsFixedBytes(arg) ||
+    arg instanceof MoveVector ||
+    arg instanceof MoveOption
+  ) {
+    // Ensure the type matches the ABI
+    checkType(functionAbi, arg, position);
+    return arg;
+  }
+
+  // If it is not BCS encoded, we will need to convert it with the ABI
+  return parseArg(arg, functionAbi.parameters[position], position, genericTypeParams);
+}
+
+/**
+ * Parses a non-BCS encoded argument into a BCS encoded argument recursively
+ * @param arg
+ * @param param
+ * @param position
+ * @param genericTypeParams
+ */
+function parseArg(
+  arg: SimpleEntryFunctionArgumentTypes,
+  param: TypeTag,
+  position: number,
+  genericTypeParams: Array<TypeTag>,
+): EntryFunctionArgumentTypes {
+  if (param.isBool()) {
+    if (isBool(arg)) {
+      return new Bool(arg);
+    }
+    throwTypeMismatch("boolean", position);
+  }
+  // TODO: support uint8array?
+  if (param.isAddress()) {
+    if (isString(arg)) {
+      return AccountAddress.fromStringRelaxed(arg);
+    }
+    throwTypeMismatch("string", position);
+  }
+  if (param.isU8()) {
+    if (isNumber(arg)) {
+      return new U8(arg);
+    }
+    throwTypeMismatch("number", position);
+  }
+  if (param.isU16()) {
+    if (isNumber(arg)) {
+      return new U16(arg);
+    }
+    throwTypeMismatch("number", position);
+  }
+  if (param.isU32()) {
+    if (isNumber(arg)) {
+      return new U32(arg);
+    }
+    throwTypeMismatch("number", position);
+  }
+  if (param.isU64()) {
+    if (isLargeNumber(arg)) {
+      return new U64(BigInt(arg));
+    }
+    throwTypeMismatch("bigint | number | string", position);
+  }
+  if (param.isU128()) {
+    if (isLargeNumber(arg)) {
+      return new U128(BigInt(arg));
+    }
+    throwTypeMismatch("bigint | number | string", position);
+  }
+  if (param.isU256()) {
+    if (isLargeNumber(arg)) {
+      return new U256(BigInt(arg));
+    }
+    throwTypeMismatch("bigint | number | string", position);
+  }
+
+  // Generic needs to use the sub-type
+  if (param.isGeneric()) {
+    const genericIndex = param.value;
+    if (genericIndex < 0 || genericIndex >= genericTypeParams.length) {
+      throw new Error(`Generic argument ${param.toString()} is invalid for argument ${position}`);
+    }
+
+    parseArg(arg, genericTypeParams[genericIndex], position, genericTypeParams);
+  }
+
+  // We have to special case some vectors for Vector<u8>
+  if (param.isVector()) {
+    // Check special case for Vector<u8>
+    if (param.value.isU8() && isString(arg)) {
+      // TODO: Improve message when hex is invalid
+      return MoveVector.U8(Hex.fromHexInput(arg).toUint8Array());
+    }
+
+    if (Array.isArray(arg)) {
+      return new MoveVector(arg.map((item) => parseArg(item, param.value, position, genericTypeParams)));
+    }
+
+    throw new Error(`Type mismatch for argument ${position}, type '${param.toString()}'`);
+  }
+
+  // Handle structs as they're more complex
+  if (param.isStruct()) {
+    if (param.isString()) {
+      if (isString(arg)) {
+        return new MoveString(arg);
+      }
+      throwTypeMismatch("string", position);
+    }
+    if (param.isObject()) {
+      // The inner type of Object doesn't matter, since it's just syntactic sugar
+      if (isString(arg)) {
+        return AccountAddress.fromStringRelaxed(arg);
+      }
+      throwTypeMismatch("string", position);
+    }
+
+    if (param.isOption()) {
+      // Empty option must be handled specially
+      if (isNull(arg)) {
+        // Note: This is a placeholder U8 type, and does not match the actual type, as that can't be dynamically grabbed
+        return new MoveOption<U8>(null);
+      }
+
+      return new MoveOption(parseArg(arg, param.value.typeArgs[0], position, genericTypeParams));
+    }
+
+    throw new Error(`Unsupported struct input type for argument ${position}, type '${param.toString()}'`);
+  }
+
+  throw new Error(`Type mismatch for argument ${position}, type '${param.toString()}'`);
+}
+
+/**
+ * Checks that the type of an already BCS encoded argument matches the ABI
+ * @param functionAbi
+ * @param arg
+ * @param position
+ */
+function checkType(functionAbi: EntryFunctionABI, arg: EntryFunctionArgumentTypes, position: number) {
+  const param = functionAbi.parameters[position];
+  if (param.isBool()) {
+    if (isBcsBool(arg)) {
+      return;
+    }
+    throwTypeMismatch("Bool", position);
+  }
+  if (param.isAddress()) {
+    if (isBcsAddress(arg)) {
+      return;
+    }
+    throwTypeMismatch("AccountAddress", position);
+  }
+  if (param.isU8()) {
+    if (isBcsU8(arg)) {
+      return;
+    }
+    throwTypeMismatch("U8", position);
+  }
+  if (param.isU16()) {
+    if (isBcsU16(arg)) {
+      return;
+    }
+    throwTypeMismatch("U16", position);
+  }
+  if (param.isU32()) {
+    if (isBcsU32(arg)) {
+      return;
+    }
+    throwTypeMismatch("U32", position);
+  }
+  if (param.isU64()) {
+    if (isBcsU64(arg)) {
+      return;
+    }
+    throwTypeMismatch("U64", position);
+  }
+  if (param.isU128()) {
+    if (isBcsU128(arg)) {
+      return;
+    }
+    throwTypeMismatch("U128", position);
+  }
+  if (param.isU256()) {
+    if (isBcsU256(arg)) {
+      return;
+    }
+    throwTypeMismatch("U256", position);
+  }
+  if (param.isVector()) {
+    if (arg instanceof MoveVector) {
+      // TODO: More introspection to verify the type
+      return;
+    }
+    throwTypeMismatch("MoveVector", position);
+  }
+
+  // Handle structs as they're more complex
+  if (param instanceof TypeTagStruct) {
+    if (param.isString()) {
+      if (isBcsString(arg)) {
+        return;
+      }
+      throwTypeMismatch("MoveString", position);
+    }
+    if (param.isObject()) {
+      if (isBcsAddress(arg)) {
+        return;
+      }
+      throwTypeMismatch("AccountAddress", position);
+    }
+    if (param.isOption()) {
+      if (arg instanceof MoveOption) {
+        // TODO: more introspection for the type
+        return;
+      }
+      throwTypeMismatch("MoveOption", position);
+    }
+  }
+
+  throw new Error(`Type mismatch for argument ${position}, expected '${param.toString()}'`);
+}