@aptos-labs/ts-sdk 1.12.2 → 1.13.0-zeta.0

package/src/core/crypto/poseidon.ts

@@ -0,0 +1,134 @@
+/* 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 an ASCII string to a field element
+export function hashASCIIStrToField(str: string, maxSizeBytes: number) {
+  const textEncoder = new TextEncoder();
+  const strBytes = textEncoder.encode(str);
+  return hashBytesWithLen(strBytes, maxSizeBytes);
+}
+
+function hashBytesWithLen(bytes: Uint8Array, maxSizeBytes: number) {
+  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;
+}
+
+// From chatGPT
+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;
+}
+
+export function poseidonHash(inputs: (number | bigint | string)[]): bigint {
+  const poseidonFixedHash = numInputsToPoseidonFunc[inputs.length - 1];
+
+  if (poseidonFixedHash) {
+    return poseidonFixedHash(inputs);
+  }
+  throw new Error(`Unable to hash input of length ${inputs.length}`);
+}

package/src/core/crypto/secp256k1.ts

@@ -41,7 +41,11 @@ export class Secp256k1PublicKey extends PublicKey {
   }
 
   // region PublicKey
-
+  /**
+   * Verifies a Secp256k1 signature against the public key
+   *
+   * Note signatures are validated to be canonical as a malleability check
+   */
   verifySignature(args: VerifySignatureArgs): boolean {
     const { message, signature } = args;
     if (!(signature instanceof Secp256k1Signature)) {
@@ -51,7 +55,7 @@ export class Secp256k1PublicKey extends PublicKey {
     const messageBytes = Hex.fromHexInput(messageToVerify).toUint8Array();
     const messageSha3Bytes = sha3_256(messageBytes);
     const signatureBytes = signature.toUint8Array();
-    return secp256k1.verify(signatureBytes, messageSha3Bytes, this.key.toUint8Array());
+    return secp256k1.verify(signatureBytes, messageSha3Bytes, this.key.toUint8Array(), { lowS: true });
   }
 
   toUint8Array(): Uint8Array {
@@ -166,6 +170,8 @@ export class Secp256k1PrivateKey extends Serializable implements PrivateKey {
   /**
    * Sign the given message with the private key.
    *
+   * Note: signatures are canonical, and non-malleable
+   *
    * @param message a message as a string or Uint8Array
    * @returns Signature
    */
@@ -173,7 +179,7 @@ export class Secp256k1PrivateKey extends Serializable implements PrivateKey {
     const messageToSign = convertSigningMessage(message);
     const messageBytes = Hex.fromHexInput(messageToSign);
     const messageHashBytes = sha3_256(messageBytes.toUint8Array());
-    const signature = secp256k1.sign(messageHashBytes, this.key.toUint8Array());
+    const signature = secp256k1.sign(messageHashBytes, this.key.toUint8Array(), { lowS: true });
     return new Secp256k1Signature(signature.toCompactRawBytes());
   }
 

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/core/index.ts

@@ -1,7 +1,6 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-export * from "./account";
 export * from "./accountAddress";
 export * from "./authenticationKey";
 export * from "./common";

package/src/index.ts

@@ -1,6 +1,7 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
+export * from "./account";
 export * from "./api";
 export * from "./bcs";
 export * from "./client";

package/src/internal/account.ts

@@ -11,7 +11,7 @@
 import { AptosConfig } from "../api/aptosConfig";
 import { AptosApiError, getAptosFullNode, paginateWithCursor } from "../client";
 import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
-import { Account } from "../core/account";
+import { Account } from "../account";
 import { AnyPublicKey, Ed25519PublicKey, PrivateKey } from "../core/crypto";
 import { getTableItem, queryIndexer } from "./general";
 import {
@@ -27,7 +27,6 @@ import {
   MoveStructId,
   OrderByArg,
   PaginationArgs,
-  SigningScheme,
   TokenStandardArg,
   TransactionResponse,
   WhereArg,
@@ -528,16 +527,15 @@ export async function deriveAccountFromPrivateKey(args: {
 
   if (privateKey instanceof Secp256k1PrivateKey) {
     // private key is secp256k1, therefore we know it for sure uses a single signer key
-    const authKey = AuthenticationKey.fromPublicKeyAndScheme({ publicKey, scheme: SigningScheme.SingleKey });
+    const authKey = AuthenticationKey.fromPublicKey({ publicKey });
     const address = authKey.derivedAddress();
-    return Account.fromPrivateKeyAndAddress({ privateKey, address });
+    return Account.fromPrivateKey({ privateKey, address });
   }
 
   if (privateKey instanceof Ed25519PrivateKey) {
     // lookup single sender ed25519
-    const singleSenderTransactionAuthenticatorAuthKey = AuthenticationKey.fromPublicKeyAndScheme({
+    const singleSenderTransactionAuthenticatorAuthKey = AuthenticationKey.fromPublicKey({
       publicKey,
-      scheme: SigningScheme.SingleKey,
     });
     const isSingleSenderTransactionAuthenticator = await isAccountExist({
       authKey: singleSenderTransactionAuthenticatorAuthKey,
@@ -545,17 +543,16 @@ export async function deriveAccountFromPrivateKey(args: {
     });
     if (isSingleSenderTransactionAuthenticator) {
       const address = singleSenderTransactionAuthenticatorAuthKey.derivedAddress();
-      return Account.fromPrivateKeyAndAddress({ privateKey, address, legacy: false });
+      return Account.fromPrivateKey({ privateKey, address, legacy: false });
     }
     // lookup legacy ed25519
-    const legacyAuthKey = AuthenticationKey.fromPublicKeyAndScheme({
+    const legacyAuthKey = AuthenticationKey.fromPublicKey({
       publicKey: publicKey.publicKey as Ed25519PublicKey,
-      scheme: SigningScheme.Ed25519,
     });
     const isLegacyEd25519 = await isAccountExist({ authKey: legacyAuthKey, aptosConfig });
     if (isLegacyEd25519) {
       const address = legacyAuthKey.derivedAddress();
-      return Account.fromPrivateKeyAndAddress({ privateKey, address, legacy: true });
+      return Account.fromPrivateKey({ privateKey, address, legacy: true });
     }
   }
   // if we are here, it means we couldn't find an address with an

package/src/internal/ans.ts

@@ -8,8 +8,9 @@
  * name namespace and without having a dependency cycle error.
  */
 
+import { Account } from "../account";
 import { AptosConfig } from "../api/aptosConfig";
-import { Account, AccountAddress, AccountAddressInput } from "../core";
+import { AccountAddress, AccountAddressInput } from "../core";
 import { InputGenerateTransactionOptions } from "../transactions/types";
 import { GetANSNameResponse, MoveAddressType, OrderByArg, PaginationArgs, WhereArg } from "../types";
 import { GetNamesQuery } from "../types/generated/operations";

package/src/internal/digitalAsset.ts

@@ -10,7 +10,7 @@
 
 import { AptosConfig } from "../api/aptosConfig";
 import { Bool, MoveString, MoveVector, U64 } from "../bcs";
-import { Account, AccountAddress, AccountAddressInput } from "../core";
+import { AccountAddress, AccountAddressInput } from "../core";
 import { EntryFunctionABI, InputGenerateTransactionOptions } from "../transactions/types";
 import {
   AnyNumber,
@@ -53,6 +53,7 @@ import {
   TypeTagU64,
   TypeTagVector,
 } from "../transactions";
+import { Account } from "../account";
 import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
 
 // A property type map for the user input and what Move expects
@@ -447,7 +448,7 @@ export async function mintSoulBoundTransaction(args: {
   description: string;
   name: string;
   uri: string;
-  recipient: AccountAddress;
+  recipient: AccountAddressInput;
   propertyKeys?: Array<string>;
   propertyTypes?: Array<PropertyType>;
   propertyValues?: Array<PropertyValue>;

package/src/internal/fungibleAsset.ts

@@ -33,7 +33,7 @@ import {
   FungibleAssetActivitiesBoolExp,
   FungibleAssetMetadataBoolExp,
 } from "../types/generated/types";
-import { Account, AccountAddress } from "../core";
+import { AccountAddressInput } from "../core";
 import {
   EntryFunctionABI,
   InputGenerateTransactionOptions,
@@ -42,6 +42,7 @@ import {
   TypeTagU64,
 } from "../transactions";
 import { generateTransaction } from "./transactionSubmission";
+import { Account } from "../account";
 import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
 
 export async function getFungibleAssetMetadata(args: {
@@ -124,8 +125,8 @@ const faTransferAbi: EntryFunctionABI = {
 export async function transferFungibleAsset(args: {
   aptosConfig: AptosConfig;
   sender: Account;
-  fungibleAssetMetadataAddress: AccountAddress;
-  recipient: AccountAddress;
+  fungibleAssetMetadataAddress: AccountAddressInput;
+  recipient: AccountAddressInput;
   amount: AnyNumber;
   options?: InputGenerateTransactionOptions;
 }): Promise<SimpleTransaction> {

package/src/internal/keyless.ts

@@ -0,0 +1,205 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * This file contains the underlying implementations for exposed API surface in
+ * the {@link api/oidb}. By moving the methods out into a separate file,
+ * other namespaces and processes can access these methods without depending on the entire
+ * faucet namespace and without having a dependency cycle error.
+ */
+import { jwtDecode } from "jwt-decode";
+import { bls12_381 as bls } from "@noble/curves/bls12-381";
+import { ProjPointType } from "@noble/curves/abstract/weierstrass";
+import { AptosConfig } from "../api/aptosConfig";
+import { getAptosPepperService, postAptosPepperService, postAptosProvingService } from "../client";
+import {
+  APTOS_BIP44_DEFAULT_DERIVATION_PATH,
+  EPK_HORIZON_SECS,
+  EphemeralSignature,
+  Groth16Zkp,
+  Hex,
+  MultiKey,
+  SignedGroth16Signature,
+} from "../core";
+import { HexInput } from "../types";
+import { Serializer } from "../bcs";
+import { EphemeralKeyPair, KeylessAccount, MultiKeyAccount } from "../account";
+import { PepperFetchResponse, ProverResponse } from "../types/keyless";
+
+const APTOS_KEYLESS_PEPPER_PINKAS_VUF_DST = "APTOS_KEYLESS_PEPPER_PINKAS_VUF_DST";
+
+function stringToUint8Array(str: string): Uint8Array {
+  const encoder = new TextEncoder();
+  return encoder.encode(str);
+}
+
+const PINKAS_VUF_SECRET_KEY_BASE_AFFINE = bls.G2.hashToCurve(
+  stringToUint8Array("APTOS_KEYLESS_PEPPER_PINKAS_VUF_SECRET_KEY_BASE"),
+  { DST: APTOS_KEYLESS_PEPPER_PINKAS_VUF_DST },
+).toAffine();
+
+function getPepperInput(args: { jwt: string; uidKey?: string }): ProjPointType<bigint> {
+  const { jwt, uidKey } = args;
+  const jwtPayload = jwtDecode<{ [key: string]: string }>(jwt);
+  const serializer = new Serializer();
+  serializer.serializeStr(jwtPayload.iss);
+  serializer.serializeStr(jwtPayload.aud);
+  serializer.serializeStr(jwtPayload[uidKey || "sub"]);
+  serializer.serializeStr(uidKey || "sub");
+  const serial = serializer.toUint8Array();
+  const msg = bls.G1.hashToCurve(serial, { DST: "APTOS_PEPPER_SERVICE_BLS12381_VUF_DST" }).toAffine();
+  const pp = bls.G1.ProjectivePoint.fromAffine(msg);
+  return pp;
+}
+
+async function verifyPepperBase(args: {
+  aptosConfig: AptosConfig;
+  pepperInput: ProjPointType<bigint>;
+  pepperBase: Uint8Array;
+}): Promise<boolean> {
+  const { aptosConfig, pepperInput, pepperBase } = args;
+  const { data: pubKeyResponse } = await getAptosPepperService<any, { vrf_public_key_hex_string: string }>({
+    aptosConfig,
+    path: "vrf-pub-key",
+    originMethod: "getPepper",
+  });
+  const publicKeyFromService = bls.G2.ProjectivePoint.fromHex(pubKeyResponse.vrf_public_key_hex_string);
+  return bls.verifyShortSignature(pepperBase, pepperInput, publicKeyFromService);
+}
+
+export async function getPepper(args: {
+  aptosConfig: AptosConfig;
+  jwt: string;
+  ephemeralKeyPair: EphemeralKeyPair;
+  uidKey?: string;
+  derivationPath?: string;
+  verify?: boolean;
+}): Promise<Uint8Array> {
+  const { aptosConfig, jwt, ephemeralKeyPair, uidKey, verify } = args;
+  let { derivationPath } = args;
+
+  const body = {
+    jwt_b64: jwt,
+    epk: ephemeralKeyPair.publicKey.bcsToHex().toStringWithoutPrefix(),
+    exp_date_secs: Number(ephemeralKeyPair.expiryDateSecs),
+    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),
+    uid_key: uidKey,
+  };
+  // console.log(JSON.stringify(body));
+  const { data } = await postAptosPepperService<any, PepperFetchResponse>({
+    aptosConfig,
+    path: "fetch",
+    body,
+    originMethod: "getPepper",
+    overrides: { WITH_CREDENTIALS: false },
+  });
+  const pepperBase = Hex.fromHexInput(data.signature).toUint8Array();
+
+  if (verify) {
+    const pepperVerified = verifyPepperBase({ aptosConfig, pepperBase, pepperInput: getPepperInput(args) });
+    if (!pepperVerified) {
+      throw new Error("Unable to verify");
+    }
+  }
+  // This takes the BLS VUF H(m)^sk and transforms it into a Pinkas VUF e(H(m), g_3^sk), where g_3 is the base of the secret key (computed pseudo-randomly via hash-to-curve).
+  // This gives us the freedom of either decentralizing the pepper service as a BLS-based MPC or on top of the validators, by reusing the Pinkas WVUF-based randomness infrastructure.
+  const newPepperBase = bls.pairing(
+    bls.G1.ProjectivePoint.fromHex(pepperBase),
+    bls.G2.ProjectivePoint.fromAffine(PINKAS_VUF_SECRET_KEY_BASE_AFFINE),
+  );
+
+  if (derivationPath === undefined) {
+    derivationPath = APTOS_BIP44_DEFAULT_DERIVATION_PATH;
+  }
+  const pepper = KeylessAccount.fromDerivationPath(derivationPath, bls.fields.Fp12.toBytes(newPepperBase));
+  return pepper.slice(0, 31);
+}
+
+export async function getProof(args: {
+  aptosConfig: AptosConfig;
+  jwt: string;
+  ephemeralKeyPair: EphemeralKeyPair;
+  pepper: HexInput;
+  uidKey?: string;
+  extraFieldKey?: string;
+}): Promise<SignedGroth16Signature> {
+  const { aptosConfig, jwt, ephemeralKeyPair, pepper, uidKey, extraFieldKey } = args;
+  const jwtPayload = jwtDecode<{ [key: string]: string }>(jwt);
+  let extraField;
+  if (extraFieldKey) {
+    const extraFieldVal = jwtPayload[extraFieldKey];
+    extraField = `"${extraFieldKey}":"${extraFieldVal}",`;
+  }
+  const json = {
+    jwt_b64: jwt,
+    epk: ephemeralKeyPair.publicKey.bcsToHex().toStringWithoutPrefix(),
+    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),
+    exp_date_secs: Number(ephemeralKeyPair.expiryDateSecs),
+    exp_horizon_secs: EPK_HORIZON_SECS,
+    pepper: Hex.fromHexInput(pepper).toStringWithoutPrefix(),
+    extra_field: extraFieldKey,
+    uid_key: uidKey || "sub",
+  };
+
+  const { data } = await postAptosProvingService<any, ProverResponse>({
+    aptosConfig,
+    path: "prove",
+    body: json,
+    originMethod: "getProof",
+    overrides: { WITH_CREDENTIALS: false },
+  });
+
+  const proofPoints = data.proof;
+  const proof = new Groth16Zkp({
+    a: proofPoints.a,
+    b: proofPoints.b,
+    c: proofPoints.c,
+  });
+
+  const signedProof = new SignedGroth16Signature({
+    proof,
+    extraField,
+    trainingWheelsSignature: EphemeralSignature.fromHex(data.training_wheels_signature),
+  });
+  return signedProof;
+}
+
+export async function deriveKeylessAccount(args: {
+  aptosConfig: AptosConfig;
+  jwt: string;
+  ephemeralKeyPair: EphemeralKeyPair;
+  uidKey?: string;
+  pepper?: HexInput;
+  extraFieldKey?: string;
+  disableConnect?: boolean;
+  fetchProofAsync?: boolean;
+}): Promise<KeylessAccount | MultiKeyAccount> {
+  const { fetchProofAsync } = args;
+  let { pepper, disableConnect } = args;
+
+  if (pepper || disableConnect) {
+    disableConnect = true;
+  }
+  if (pepper === undefined) {
+    pepper = await getPepper(args);
+  } else if (Hex.fromHexInput(pepper).toUint8Array().length !== 31) {
+    throw new Error("Pepper needs to be 31 bytes");
+  }
+
+  const proofPromise = getProof({ ...args, pepper });
+  const proof = fetchProofAsync ? proofPromise : await proofPromise;
+
+  const keylessAccount = KeylessAccount.fromJWTAndProof({ ...args, proofFetcherOrData: proof, pepper });
+
+  if (disableConnect === true) {
+    return keylessAccount;
+  }
+
+  const aptosConnectPublicKey = keylessAccount.deriveAptosConnectPublicKey();
+
+  const multiKey = new MultiKey({
+    publicKeys: [keylessAccount.publicKey, aptosConnectPublicKey],
+    signaturesRequired: 1,
+  });
+  return new MultiKeyAccount({ multiKey, signers: [keylessAccount] });
+}

package/src/internal/transaction.ts

@@ -97,6 +97,19 @@ export async function isTransactionPending(args: {
   }
 }
 
+export async function longWaitForTransaction(args: {
+  aptosConfig: AptosConfig;
+  transactionHash: HexInput;
+}): Promise<TransactionResponse> {
+  const { aptosConfig, transactionHash } = args;
+  const { data } = await getAptosFullNode<{}, TransactionResponse>({
+    aptosConfig,
+    path: `transactions/wait_by_hash/${transactionHash}`,
+    originMethod: "longWaitForTransaction",
+  });
+  return data;
+}
+
 export async function waitForTransaction(args: {
   aptosConfig: AptosConfig;
   transactionHash: HexInput;
@@ -113,6 +126,40 @@ export async function waitForTransaction(args: {
   let backoffIntervalMs = 200;
   const backoffMultiplier = 1.5;
 
+  function handleAPIError(e: any) {
+    // In short, this means we will retry if it was an AptosApiError and the code was 404 or 5xx.
+    const isAptosApiError = e instanceof AptosApiError;
+    if (!isAptosApiError) {
+      throw e; // This would be unexpected
+    }
+    lastError = e;
+    const isRequestError = e.status !== 404 && e.status >= 400 && e.status < 500;
+    if (isRequestError) {
+      throw e;
+    }
+  }
+
+  // check to see if the txn is already on the blockchain
+  try {
+    lastTxn = await getTransactionByHash({ aptosConfig, transactionHash });
+    isPending = lastTxn.type === TransactionResponseType.Pending;
+  } catch (e) {
+    handleAPIError(e);
+  }
+
+  // If the transaction is pending, we do a long wait once to avoid polling
+  if (isPending) {
+    const startTime = Date.now();
+    try {
+      lastTxn = await longWaitForTransaction({ aptosConfig, transactionHash });
+      isPending = lastTxn.type === TransactionResponseType.Pending;
+    } catch (e) {
+      handleAPIError(e);
+    }
+    timeElapsed = (Date.now() - startTime) / 1000;
+  }
+
+  // Now we do polling to see if the transaction is still pending
   while (isPending) {
     if (timeElapsed >= timeoutSecs) {
       break;
@@ -127,16 +174,7 @@ export async function waitForTransaction(args: {
         break;
       }
     } catch (e) {
-      // In short, this means we will retry if it was an AptosApiError and the code was 404 or 5xx.
-      const isAptosApiError = e instanceof AptosApiError;
-      if (!isAptosApiError) {
-        throw e; // This would be unexpected
-      }
-      lastError = e;
-      const isRequestError = e.status !== 404 && e.status >= 400 && e.status < 500;
-      if (isRequestError) {
-        throw e;
-      }
+      handleAPIError(e);
     }
     // eslint-disable-next-line no-await-in-loop
     await sleep(backoffIntervalMs);