@aptos-labs/ts-sdk 1.16.0 → 1.17.0-zeta.1

package/src/core/crypto/poseidon.ts

@@ -0,0 +1,144 @@
+/* eslint-disable no-bitwise */
+import {
+  poseidon1,
+  poseidon2,
+  poseidon3,
+  poseidon4,
+  poseidon5,
+  poseidon6,
+  poseidon7,
+  poseidon8,
+  poseidon9,
+  poseidon10,
+  poseidon11,
+  poseidon12,
+  poseidon13,
+  poseidon14,
+  poseidon15,
+  poseidon16,
+} from "poseidon-lite";
+
+const numInputsToPoseidonFunc = [
+  poseidon1,
+  poseidon2,
+  poseidon3,
+  poseidon4,
+  poseidon5,
+  poseidon6,
+  poseidon7,
+  poseidon8,
+  poseidon9,
+  poseidon10,
+  poseidon11,
+  poseidon12,
+  poseidon13,
+  poseidon14,
+  poseidon15,
+  poseidon16,
+];
+
+const BYTES_PACKED_PER_SCALAR = 31;
+const MAX_NUM_INPUT_SCALARS = 16;
+const MAX_NUM_INPUT_BYTES = (MAX_NUM_INPUT_SCALARS - 1) * BYTES_PACKED_PER_SCALAR;
+
+/**
+ * Hashes a string to a field element via poseidon
+ *
+ * @returns bigint result of the hash
+ */
+export function hashStrToField(str: string, maxSizeBytes: number): bigint {
+  const textEncoder = new TextEncoder();
+  const strBytes = textEncoder.encode(str);
+  return hashBytesWithLen(strBytes, maxSizeBytes);
+}
+
+function hashBytesWithLen(bytes: Uint8Array, maxSizeBytes: number): bigint {
+  if (bytes.length > maxSizeBytes) {
+    throw new Error(`Inputted bytes of length ${bytes} is longer than ${maxSizeBytes}`);
+  }
+  const packed = padAndPackBytesWithLen(bytes, maxSizeBytes);
+  return poseidonHash(packed);
+}
+
+function padAndPackBytesNoLen(bytes: Uint8Array, maxSizeBytes: number): bigint[] {
+  if (bytes.length > maxSizeBytes) {
+    throw new Error(`Input bytes of length ${bytes} is longer than ${maxSizeBytes}`);
+  }
+  const paddedStrBytes = padUint8ArrayWithZeros(bytes, maxSizeBytes);
+  return packBytes(paddedStrBytes);
+}
+
+export function padAndPackBytesWithLen(bytes: Uint8Array, maxSizeBytes: number): bigint[] {
+  if (bytes.length > maxSizeBytes) {
+    throw new Error(`Input bytes of length ${bytes} is longer than ${maxSizeBytes}`);
+  }
+  return padAndPackBytesNoLen(bytes, maxSizeBytes).concat([BigInt(bytes.length)]);
+}
+
+function packBytes(bytes: Uint8Array): bigint[] {
+  if (bytes.length > MAX_NUM_INPUT_BYTES) {
+    throw new Error(`Can't pack more than ${MAX_NUM_INPUT_BYTES}.  Was given ${bytes.length} bytes`);
+  }
+  return chunkUint8Array(bytes, BYTES_PACKED_PER_SCALAR).map((chunk) => bytesToBigIntLE(chunk));
+}
+
+function chunkUint8Array(array: Uint8Array, chunkSize: number): Uint8Array[] {
+  const result: Uint8Array[] = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    result.push(array.subarray(i, i + chunkSize));
+  }
+  return result;
+}
+
+export function bytesToBigIntLE(bytes: Uint8Array): bigint {
+  let result = BigInt(0);
+  for (let i = bytes.length - 1; i >= 0; i -= 1) {
+    result = (result << BigInt(8)) | BigInt(bytes[i]);
+  }
+  return result;
+}
+
+export function bigIntToBytesLE(value: bigint, length: number): Uint8Array {
+  const bytes = new Uint8Array(length);
+  for (let i = 0; i < length; i += 1) {
+    bytes[i] = Number(value & BigInt(0xff));
+    // eslint-disable-next-line no-param-reassign
+    value >>= BigInt(8);
+  }
+  return bytes;
+}
+
+function padUint8ArrayWithZeros(inputArray: Uint8Array, paddedSize: number): Uint8Array {
+  if (paddedSize < inputArray.length) {
+    throw new Error("Padded size must be greater than or equal to the input array size.");
+  }
+
+  // Create a new Uint8Array with the padded size
+  const paddedArray = new Uint8Array(paddedSize);
+
+  // Copy the content of the input array to the new array
+  paddedArray.set(inputArray);
+
+  // Fill the remaining space with zeros
+  for (let i = inputArray.length; i < paddedSize; i += 1) {
+    paddedArray[i] = 0;
+  }
+
+  return paddedArray;
+}
+
+/**
+ * Hashes up to 16 scalar elements via the poseidon hashing algorithm.
+ *
+ * Each element must be scalar fields of the BN254 elliptic curve group.
+ *
+ * @returns bigint result of the hash
+ */
+export function poseidonHash(inputs: (number | bigint | string)[]): bigint {
+  if (inputs.length > numInputsToPoseidonFunc.length) {
+    throw new Error(
+      `Unable to hash input of length ${inputs.length}.  Max input length is ${numInputsToPoseidonFunc.length}`,
+    );
+  }
+  return numInputsToPoseidonFunc[inputs.length - 1](inputs);
+}

package/src/core/crypto/proof.ts

@@ -0,0 +1,16 @@
+import { Serializable } from "../../bcs";
+import { Hex } from "../hex";
+
+/**
+ * An abstract representation of a crypto proof.
+ * associated to a specific zero knowledge proof schemes e.g. Groth16, PLONK
+ */
+export abstract class Proof extends Serializable {
+  /**
+   * Get the proof as a hex string with a 0x prefix e.g. 0x123456...
+   */
+  toString(): string {
+    const bytes = this.bcsToBytes();
+    return Hex.fromHexInput(bytes).toString();
+  }
+}

package/src/core/crypto/singleKey.ts

@@ -4,6 +4,7 @@ import { AuthenticationKey } from "../authenticationKey";
 import { Ed25519PublicKey, Ed25519Signature } from "./ed25519";
 import { AccountPublicKey, PublicKey, VerifySignatureArgs } from "./publicKey";
 import { Secp256k1PublicKey, Secp256k1Signature } from "./secp256k1";
+import { KeylessPublicKey, KeylessSignature } from "./keyless";
 import { Signature } from "./signature";
 
 /**
@@ -34,6 +35,8 @@ export class AnyPublicKey extends AccountPublicKey {
       this.variant = AnyPublicKeyVariant.Ed25519;
     } else if (publicKey instanceof Secp256k1PublicKey) {
       this.variant = AnyPublicKeyVariant.Secp256k1;
+    } else if (publicKey instanceof KeylessPublicKey) {
+      this.variant = AnyPublicKeyVariant.Keyless;
     } else {
       throw new Error("Unsupported public key type");
     }
@@ -85,6 +88,9 @@ export class AnyPublicKey extends AccountPublicKey {
       case AnyPublicKeyVariant.Secp256k1:
         publicKey = Secp256k1PublicKey.deserialize(deserializer);
         break;
+      case AnyPublicKeyVariant.Keyless:
+        publicKey = KeylessPublicKey.deserialize(deserializer);
+        break;
       default:
         throw new Error(`Unknown variant index for AnyPublicKey: ${variantIndex}`);
     }
@@ -138,6 +144,8 @@ export class AnySignature extends Signature {
       this.variant = AnySignatureVariant.Ed25519;
     } else if (signature instanceof Secp256k1Signature) {
       this.variant = AnySignatureVariant.Secp256k1;
+    } else if (signature instanceof KeylessSignature) {
+      this.variant = AnySignatureVariant.Keyless;
     } else {
       throw new Error("Unsupported signature type");
     }
@@ -170,6 +178,9 @@ export class AnySignature extends Signature {
       case AnySignatureVariant.Secp256k1:
         signature = Secp256k1Signature.deserialize(deserializer);
         break;
+      case AnySignatureVariant.Keyless:
+        signature = KeylessSignature.deserialize(deserializer);
+        break;
       default:
         throw new Error(`Unknown variant index for AnySignature: ${variantIndex}`);
     }

package/src/internal/general.ts

@@ -10,14 +10,7 @@
 
 import { AptosConfig } from "../api/aptosConfig";
 import { getAptosFullNode, postAptosIndexer } from "../client";
-import {
-  AnyNumber,
-  Block,
-  GetChainTopUserTransactionsResponse,
-  GetProcessorStatusResponse,
-  GraphqlQuery,
-  LedgerInfo,
-} from "../types";
+import { GetChainTopUserTransactionsResponse, GetProcessorStatusResponse, GraphqlQuery, LedgerInfo } from "../types";
 import { GetChainTopUserTransactionsQuery, GetProcessorStatusQuery } from "../types/generated/operations";
 import { GetChainTopUserTransactions, GetProcessorStatus } from "../types/generated/queries";
 import { ProcessorType } from "../utils/const";
@@ -32,36 +25,6 @@ export async function getLedgerInfo(args: { aptosConfig: AptosConfig }): Promise
   return data;
 }
 
-export async function getBlockByVersion(args: {
-  aptosConfig: AptosConfig;
-  ledgerVersion: AnyNumber;
-  options?: { withTransactions?: boolean };
-}): Promise<Block> {
-  const { aptosConfig, ledgerVersion, options } = args;
-  const { data } = await getAptosFullNode<{}, Block>({
-    aptosConfig,
-    originMethod: "getBlockByVersion",
-    path: `blocks/by_version/${ledgerVersion}`,
-    params: { with_transactions: options?.withTransactions },
-  });
-  return data;
-}
-
-export async function getBlockByHeight(args: {
-  aptosConfig: AptosConfig;
-  blockHeight: AnyNumber;
-  options?: { withTransactions?: boolean };
-}): Promise<Block> {
-  const { aptosConfig, blockHeight, options } = args;
-  const { data } = await getAptosFullNode<{}, Block>({
-    aptosConfig,
-    originMethod: "getBlockByHeight",
-    path: `blocks/by_height/${blockHeight}`,
-    params: { with_transactions: options?.withTransactions },
-  });
-  return data;
-}
-
 export async function getChainTopUserTransactions(args: {
   aptosConfig: AptosConfig;
   limit: number;

package/src/internal/keyless.ts

@@ -0,0 +1,121 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * This file contains the underlying implementations for exposed API surface in
+ * the {@link api/keyless}. By moving the methods out into a separate file,
+ * other namespaces and processes can access these methods without depending on the entire
+ * keyless namespace and without having a dependency cycle error.
+ */
+import { AptosConfig } from "../api/aptosConfig";
+import { postAptosPepperService, postAptosProvingService } from "../client";
+import { EphemeralSignature, Groth16Zkp, Hex, ZeroKnowledgeSig, ZkProof, getKeylessConfig } from "../core";
+import { HexInput, ZkpVariant } from "../types";
+import { EphemeralKeyPair, KeylessAccount, ProofFetchCallback } from "../account";
+import { PepperFetchRequest, PepperFetchResponse, ProverRequest, ProverResponse } from "../types/keyless";
+import { nowInSeconds } from "../utils/helpers";
+
+export async function getPepper(args: {
+  aptosConfig: AptosConfig;
+  jwt: string;
+  ephemeralKeyPair: EphemeralKeyPair;
+  uidKey?: string;
+  derivationPath?: string;
+}): Promise<Uint8Array> {
+  const { aptosConfig, jwt, ephemeralKeyPair, uidKey = "sub", derivationPath } = args;
+
+  const body = {
+    jwt_b64: jwt,
+    epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),
+    exp_date_secs: ephemeralKeyPair.expiryDateSecs,
+    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),
+    uid_key: uidKey,
+    derivation_path: derivationPath,
+  };
+  const { data } = await postAptosPepperService<PepperFetchRequest, PepperFetchResponse>({
+    aptosConfig,
+    path: "fetch",
+    body,
+    originMethod: "getPepper",
+    overrides: { WITH_CREDENTIALS: false },
+  });
+  return Hex.fromHexInput(data.pepper).toUint8Array();
+}
+
+export async function getProof(args: {
+  aptosConfig: AptosConfig;
+  jwt: string;
+  ephemeralKeyPair: EphemeralKeyPair;
+  pepper: HexInput;
+  uidKey?: string;
+}): Promise<ZeroKnowledgeSig> {
+  const { aptosConfig, jwt, ephemeralKeyPair, pepper, uidKey = "sub" } = args;
+  const { maxExpHorizonSecs } = await getKeylessConfig({ aptosConfig });
+  if (maxExpHorizonSecs < ephemeralKeyPair.expiryDateSecs - nowInSeconds()) {
+    throw Error(`The EphemeralKeyPair is too long lived.  It's lifespan must be less than ${maxExpHorizonSecs}`);
+  }
+  const json = {
+    jwt_b64: jwt,
+    epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),
+    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),
+    exp_date_secs: ephemeralKeyPair.expiryDateSecs,
+    exp_horizon_secs: maxExpHorizonSecs,
+    pepper: Hex.fromHexInput(pepper).toStringWithoutPrefix(),
+    uid_key: uidKey,
+  };
+
+  const { data } = await postAptosProvingService<ProverRequest, ProverResponse>({
+    aptosConfig,
+    path: "prove",
+    body: json,
+    originMethod: "getProof",
+    overrides: { WITH_CREDENTIALS: false },
+  });
+
+  const proofPoints = data.proof;
+  const groth16Zkp = new Groth16Zkp({
+    a: proofPoints.a,
+    b: proofPoints.b,
+    c: proofPoints.c,
+  });
+
+  const signedProof = new ZeroKnowledgeSig({
+    proof: new ZkProof(groth16Zkp, ZkpVariant.Groth16),
+    trainingWheelsSignature: EphemeralSignature.fromHex(data.training_wheels_signature),
+    expHorizonSecs: maxExpHorizonSecs,
+  });
+  return signedProof;
+}
+
+export async function deriveKeylessAccount(args: {
+  aptosConfig: AptosConfig;
+  jwt: string;
+  ephemeralKeyPair: EphemeralKeyPair;
+  uidKey?: string;
+  pepper?: HexInput;
+  proofFetchCallback?: ProofFetchCallback;
+}): Promise<KeylessAccount> {
+  const { proofFetchCallback } = args;
+  let { pepper } = args;
+  if (pepper === undefined) {
+    pepper = await getPepper(args);
+  } else {
+    pepper = Hex.fromHexInput(pepper).toUint8Array();
+  }
+
+  if (pepper.length !== KeylessAccount.PEPPER_LENGTH) {
+    throw new Error(`Pepper needs to be ${KeylessAccount.PEPPER_LENGTH} bytes`);
+  }
+
+  const proofPromise = getProof({ ...args, pepper });
+  // If a callback is provided, pass in the proof as a promise to KeylessAccount.create.  This will make the proof be fetched in the
+  // background and the callback will handle the outcome of the fetch.  This allows the developer to not have to block on the proof fetch
+  // allowing for faster rendering of UX.
+  //
+  // If no callback is provided, the just await the proof fetch and continue syncronously.
+  const proof = proofFetchCallback ? proofPromise : await proofPromise;
+
+  const keylessAccount = KeylessAccount.create({ ...args, proof, pepper, proofFetchCallback });
+
+  return keylessAccount;
+}

package/src/internal/transaction.ts

@@ -19,6 +19,7 @@ import {
   type TransactionResponse,
   WaitForTransactionOptions,
   CommittedTransactionResponse,
+  Block,
 } from "../types";
 import { DEFAULT_TXN_TIMEOUT_SEC, ProcessorType } from "../utils/const";
 import { sleep } from "../utils/helpers";
@@ -279,3 +280,94 @@ export class FailedTransactionError extends Error {
     this.transaction = transaction;
   }
 }
+
+export async function getBlockByVersion(args: {
+  aptosConfig: AptosConfig;
+  ledgerVersion: AnyNumber;
+  options?: { withTransactions?: boolean };
+}): Promise<Block> {
+  const { aptosConfig, ledgerVersion, options } = args;
+  const { data: block } = await getAptosFullNode<{}, Block>({
+    aptosConfig,
+    originMethod: "getBlockByVersion",
+    path: `blocks/by_version/${ledgerVersion}`,
+    params: { with_transactions: options?.withTransactions },
+  });
+
+  return fillBlockTransactions({ block, ...args });
+}
+
+export async function getBlockByHeight(args: {
+  aptosConfig: AptosConfig;
+  blockHeight: AnyNumber;
+  options?: { withTransactions?: boolean };
+}): Promise<Block> {
+  const { aptosConfig, blockHeight, options } = args;
+  const { data: block } = await getAptosFullNode<{}, Block>({
+    aptosConfig,
+    originMethod: "getBlockByHeight",
+    path: `blocks/by_height/${blockHeight}`,
+    params: { with_transactions: options?.withTransactions },
+  });
+  return fillBlockTransactions({ block, ...args });
+}
+
+/**
+ * Fills in the block with transactions if not enough were returned
+ * @param args
+ */
+async function fillBlockTransactions(args: {
+  aptosConfig: AptosConfig;
+  block: Block;
+  options?: { withTransactions?: boolean };
+}) {
+  const { aptosConfig, block, options } = args;
+  if (options?.withTransactions) {
+    // Transactions should be filled, but this ensures it
+    block.transactions = block.transactions ?? [];
+
+    const lastTxn = block.transactions[block.transactions.length - 1];
+    const firstVersion = BigInt(block.first_version);
+    const lastVersion = BigInt(block.last_version);
+
+    // Convert the transaction to the type
+    const curVersion: string | undefined = (lastTxn as any)?.version;
+    let latestVersion;
+
+    // This time, if we don't have any transactions, we will try once with the start of the block
+    if (curVersion === undefined) {
+      latestVersion = firstVersion - 1n;
+    } else {
+      latestVersion = BigInt(curVersion);
+    }
+
+    // If we have all the transactions in the block, we can skip out, otherwise we need to fill the transactions
+    if (latestVersion === lastVersion) {
+      return block;
+    }
+
+    // For now, we will grab all the transactions in groups of 100, but we can make this more efficient by trying larger
+    // amounts
+    const fetchFutures = [];
+    const pageSize = 100n;
+    for (let i = latestVersion + 1n; i < lastVersion; i += BigInt(100)) {
+      fetchFutures.push(
+        getTransactions({
+          aptosConfig,
+          options: {
+            offset: i,
+            limit: Math.min(Number(pageSize), Number(lastVersion - i + 1n)),
+          },
+        }),
+      );
+    }
+
+    // Combine all the futures
+    const responses = await Promise.all(fetchFutures);
+    for (const txns of responses) {
+      block.transactions.push(...txns);
+    }
+  }
+
+  return block;
+}

package/src/internal/transactionSubmission.ts

@@ -8,7 +8,7 @@
 import { AptosConfig } from "../api/aptosConfig";
 import { MoveVector, U8 } from "../bcs";
 import { postAptosFullNode } from "../client";
-import { Account } from "../account";
+import { Account, KeylessAccount, MultiKeyAccount } from "../account";
 import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
 import { PrivateKey } from "../core/crypto";
 import { AccountAuthenticator } from "../transactions/authenticator/account";
@@ -275,6 +275,11 @@ export async function signAndSubmitTransaction(args: {
   transaction: AnyRawTransaction;
 }): Promise<PendingTransactionResponse> {
   const { aptosConfig, signer, transaction } = args;
+  // If the signer contains a KeylessAccount, await proof fetching in case the proof
+  // was fetched asyncronously.
+  if (signer instanceof KeylessAccount || signer instanceof MultiKeyAccount) {
+    await signer.waitForProofFetch();
+  }
   const authenticator = signTransaction({ signer, transaction });
   return submitTransaction({
     aptosConfig,

package/src/transactions/management/accountSequenceNumber.ts

@@ -26,10 +26,7 @@
 import { AptosConfig } from "../../api/aptosConfig";
 import { Account } from "../../account";
 import { getInfo } from "../../internal/account";
-import { sleep } from "../../utils/helpers";
-
-// returns `now` time in seconds
-const now = () => Math.floor(Date.now() / 1000);
+import { nowInSeconds, sleep } from "../../utils/helpers";
 
 export class AccountSequenceNumber {
   readonly aptosConfig: AptosConfig;
@@ -96,10 +93,10 @@ export class AccountSequenceNumber {
       if (this.currentNumber! - this.lastUncommintedNumber! >= this.maximumInFlight) {
         await this.update();
 
-        const startTime = now();
+        const startTime = nowInSeconds();
         while (this.currentNumber! - this.lastUncommintedNumber! >= this.maximumInFlight) {
           await sleep(this.sleepTime);
-          if (now() - startTime > this.maxWaitTime) {
+          if (nowInSeconds() - startTime > this.maxWaitTime) {
             /* eslint-disable no-console */
             console.warn(
               `Waited over 30 seconds for a transaction to commit, resyncing ${this.account.accountAddress.toString()}`,
@@ -164,9 +161,9 @@ export class AccountSequenceNumber {
 
     try {
       await this.update();
-      const startTime = now();
+      const startTime = nowInSeconds();
       while (this.lastUncommintedNumber !== this.currentNumber) {
-        if (now() - startTime > this.maxWaitTime) {
+        if (nowInSeconds() - startTime > this.maxWaitTime) {
           /* eslint-disable no-console */
           console.warn(
             `Waited over 30 seconds for a transaction to commit, resyncing ${this.account.accountAddress.toString()}`,

package/src/transactions/transactionBuilder/remoteAbi.ts

@@ -10,6 +10,7 @@ import {
   EntryFunctionABI,
   ViewFunctionABI,
   FunctionABI,
+  TypeArgument,
 } from "../types";
 import { Bool, MoveOption, MoveString, MoveVector, U128, U16, U256, U32, U64, U8 } from "../../bcs";
 import { AccountAddress } from "../../core";
@@ -40,9 +41,9 @@ const TEXT_ENCODER = new TextEncoder();
 /**
  * Convert type arguments to only type tags, allowing for string representations of type tags
  */
-export function standardizeTypeTags(typeArguments?: Array<TypeTag | string>): Array<TypeTag> {
+export function standardizeTypeTags(typeArguments?: Array<TypeArgument>): Array<TypeTag> {
   return (
-    typeArguments?.map((typeArg: string | TypeTag): TypeTag => {
+    typeArguments?.map((typeArg: TypeArgument): TypeTag => {
       // Convert to TypeTag if it's a string representation
       if (isString(typeArg)) {
         return parseTypeTag(typeArg);

package/src/transactions/transactionBuilder/signingMessage.ts

@@ -8,7 +8,7 @@ import { sha3_256 as sha3Hash } from "@noble/hashes/sha3";
 import { RAW_TRANSACTION_SALT, RAW_TRANSACTION_WITH_DATA_SALT } from "../../utils/const";
 import { FeePayerRawTransaction, MultiAgentRawTransaction } from "../instances";
 import { AnyRawTransaction, AnyRawTransactionInstance } from "../types";
-import { Serializable } from "../../bcs";
+import { Serializable } from "../../bcs/serializer";
 
 /**
  * Derive the raw transaction type - FeePayerRawTransaction or MultiAgentRawTransaction or RawTransaction
@@ -61,6 +61,9 @@ export function generateSigningMessage(bytes: Uint8Array, domainSeparator: strin
 }
 
 /**
+ * @deprected
+ * Use CryptoHashable instead by having your class implement it and call hash() to get the signing message.
+ *
  * Generates the 'signing message' form of a serilizable value. It bcs serializes the value and uses the name of
  * its constructor as the domain separator.
  *

package/src/transactions/transactionBuilder/transactionBuilder.ts

@@ -9,7 +9,13 @@
 import { sha3_256 as sha3Hash } from "@noble/hashes/sha3";
 import { AptosConfig } from "../../api/aptosConfig";
 import { AccountAddress, AccountAddressInput, Hex, PublicKey } from "../../core";
-import { AnyPublicKey, AnySignature, Secp256k1PublicKey, Secp256k1Signature } from "../../core/crypto";
+import {
+  AnyPublicKey,
+  AnySignature,
+  KeylessPublicKey,
+  Secp256k1PublicKey,
+  Secp256k1Signature,
+} from "../../core/crypto";
 import { Ed25519PublicKey, Ed25519Signature } from "../../core/crypto/ed25519";
 import { getInfo } from "../../internal/account";
 import { getLedgerInfo } from "../../internal/general";
@@ -216,7 +222,11 @@ export function generateViewFunctionPayloadWithABI(args: InputViewFunctionDataWi
 
 function generateTransactionPayloadScript(args: InputScriptData) {
   return new TransactionPayloadScript(
-    new Script(Hex.fromHexInput(args.bytecode).toUint8Array(), args.typeArguments ?? [], args.functionArguments),
+    new Script(
+      Hex.fromHexInput(args.bytecode).toUint8Array(),
+      standardizeTypeTags(args.typeArguments),
+      args.functionArguments,
+    ),
   );
 }
 
@@ -441,6 +451,11 @@ export function generateSignedTransactionForSimulation(args: InputSimulateTransa
 }
 
 export function getAuthenticatorForSimulation(publicKey: PublicKey) {
+  if (publicKey instanceof KeylessPublicKey || publicKey instanceof Secp256k1PublicKey) {
+    // eslint-disable-next-line no-param-reassign
+    publicKey = new AnyPublicKey(publicKey);
+  }
+
   // TODO add support for AnyMultiKey
   if (publicKey instanceof AnyPublicKey) {
     if (publicKey.publicKey instanceof Ed25519PublicKey) {
@@ -449,6 +464,11 @@ export function getAuthenticatorForSimulation(publicKey: PublicKey) {
     if (publicKey.publicKey instanceof Secp256k1PublicKey) {
       return new AccountAuthenticatorSingleKey(publicKey, new AnySignature(new Secp256k1Signature(new Uint8Array(64))));
     }
+    if (publicKey.publicKey instanceof KeylessPublicKey) {
+      // TODO: Replace with the line below one simulation works properly for Keyless
+      // return new AccountAuthenticatorSingleKey(publicKey, new AnySignature(KeylessSignature.getSimulationSignature()));
+      return new AccountAuthenticatorSingleKey(publicKey, new AnySignature(new Ed25519Signature(new Uint8Array(64))));
+    }
   }
 
   // legacy code