@aptos-labs/ts-sdk 1.32.0 → 1.33.0-zeta.0

package/dist/esm/version.d.mts

@@ -3,6 +3,6 @@
  *
  * hardcoded for now, we would want to have it injected dynamically
  */
-declare const VERSION = "1.32.0";
+declare const VERSION = "1.33.0";
 
 export { VERSION };

package/dist/esm/version.mjs

@@ -1,2 +1,2 @@
-import{a}from"./chunk-AMCJQIOT.mjs";import"./chunk-KDMSOCZY.mjs";export{a as VERSION};
+import{a}from"./chunk-YQHOQJRQ.mjs";import"./chunk-KDMSOCZY.mjs";export{a as VERSION};
 //# sourceMappingURL=version.mjs.map

package/package.json

@@ -56,7 +56,6 @@
     "@noble/hashes": "^1.4.0",
     "@scure/bip32": "^1.4.0",
     "@scure/bip39": "^1.3.0",
-    "@wgb5445/aptos-intent-npm": "^0.1.13",
     "eventemitter3": "^5.0.1",
     "form-data": "^4.0.0",
     "js-base64": "^3.7.7",
@@ -97,5 +96,5 @@
     "typedoc-plugin-missing-exports": "^3.0.0",
     "typescript": "^5.6.2"
   },
-  "version": "1.32.0"
-}
+  "version": "1.33.0-zeta.0"
+}

package/src/account/AbstractKeylessAccount.ts

@@ -441,7 +441,8 @@ export abstract class AbstractKeylessAccount extends Serializable implements Key
     if (jwksForIssuer === undefined) {
       throw KeylessError.fromErrorType({
         type: KeylessErrorType.INVALID_JWT_ISS_NOT_RECOGNIZED,
-        details: `JWKs for issuer ${iss} not found.`,
+        // eslint-disable-next-line max-len
+        details: `JWKs for issuer ${iss} not found at address ${jwkAddr ? `${jwkAddr}. Make sure the JWK set for the issuer is registered at this address.` : "0x1. This issuer is not supported for use with Keyless."}`,
       });
     }
 

package/src/api/transactionSubmission/build.ts

@@ -3,17 +3,10 @@
 
 import { AccountAddressInput } from "../../core";
 import { generateTransaction } from "../../internal/transactionSubmission";
-import {
-  InputGenerateTransactionPayloadData,
-  InputGenerateTransactionOptions,
-  AptosScriptComposer,
-  TransactionPayloadScript,
-  generateRawTransaction,
-} from "../../transactions";
+import { InputGenerateTransactionPayloadData, InputGenerateTransactionOptions } from "../../transactions";
 import { MultiAgentTransaction } from "../../transactions/instances/multiAgentTransaction";
 import { SimpleTransaction } from "../../transactions/instances/simpleTransaction";
 import { AptosConfig } from "../aptosConfig";
-import { Deserializer } from "../../bcs";
 
 /**
  * A class to handle all `Build` transaction operations.
@@ -100,80 +93,6 @@ export class Build {
     return generateTransaction({ aptosConfig: this.config, ...args });
   }
 
-  /**
-   * Build a transaction from a series of Move calls.
-   *
-   * This function allows you to create a transaction with a list of Move calls.
-   *
-   * Right now we only tested this logic with single signer and we will add support
-   * for mutli agent transactions if needed.
-   *
-   * @param args.sender - The sender account address.
-   * @param args.builder - The closure to construct the list of calls.
-   * @param args.options - Optional transaction configurations.
-   * @param args.withFeePayer - Whether there is a fee payer for the transaction.
-   *
-   * @returns SimpleTransaction
-   *
-   * @example
-   * ```typescript
-   * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-   *
-   * const config = new AptosConfig({ network: Network.TESTNET });
-   * const aptos = new Aptos(config);
-   *
-   * async function runExample() {
-   *   // Build a transaction from a chained series of Move calls.
-   *   const transaction = await aptos.transaction.script_composer({
-   *     sender: "0x1", // replace with a real sender account address
-   *     builder: builder: async (builder) => {
-   *       const coin = await builder.addBatchedCalls({
-   *          function: "0x1::coin::withdraw",
-   *          functionArguments: [CallArgument.new_signer(0), 1],
-   *          typeArguments: ["0x1::aptos_coin::AptosCoin"],
-   *        });
-   *
-   *        // Pass the returned value from the first function call to the second call
-   *        const fungibleAsset = await builder.addBatchedCalls({
-   *          function: "0x1::coin::coin_to_fungible_asset",
-   *          functionArguments: [coin[0]],
-   *          typeArguments: ["0x1::aptos_coin::AptosCoin"],
-   *        });
-   *
-   *        await builder.addBatchedCalls({
-   *          function: "0x1::primary_fungible_store::deposit",
-   *          functionArguments: [singleSignerED25519SenderAccount.accountAddress, fungibleAsset[0]],
-   *          typeArguments: [],
-   *        });
-   *        return builder;
-   *     },
-   *     options: {
-   *       gasUnitPrice: 100, // specify your own gas unit price if needed
-   *       maxGasAmount: 1000, // specify your own max gas amount if needed
-   *     },
-   *   });
-   *
-   *   console.log(transaction);
-   * }
-   * runExample().catch(console.error);
-   * ```
-   */
-  async scriptComposer(args: {
-    sender: AccountAddressInput;
-    builder: (builder: AptosScriptComposer) => Promise<AptosScriptComposer>;
-    options?: InputGenerateTransactionOptions;
-    withFeePayer?: boolean;
-  }): Promise<SimpleTransaction> {
-    const builder = await args.builder(new AptosScriptComposer(this.config));
-    const bytes = builder.build();
-    const rawTxn = await generateRawTransaction({
-      aptosConfig: this.config,
-      payload: TransactionPayloadScript.load(new Deserializer(bytes)),
-      ...args,
-    });
-    return new SimpleTransaction(rawTxn);
-  }
-
   /**
    * Build a multi-agent transaction that allows multiple signers to authorize a transaction.
    *

package/src/api/transactionSubmission/helpers.ts

@@ -97,12 +97,6 @@ export function ValidateFeePayerDataOnSimulation(target: unknown, propertyKey: s
   const originalMethod = descriptor.value;
   /* eslint-disable-next-line func-names, no-param-reassign */
   descriptor.value = async function (...args: any[]) {
-    const [methodArgs] = args;
-
-    if (methodArgs.transaction.feePayerAddress && !methodArgs.feePayerPublicKey) {
-      throw new Error("You are simulating a Fee Payer transaction but missing the feePayerPublicKey");
-    }
-
     return originalMethod.apply(this, args);
   };
 

package/src/api/transactionSubmission/simulate.ts

@@ -47,7 +47,7 @@ export class Simulate {
    * This function helps you understand the outcome of a transaction before executing it on the blockchain.
    *
    * @param args - The parameters for simulating the transaction.
-   * @param args.signerPublicKey - The public key of the signer for the transaction.
+   * @param args.signerPublicKey - The public key of the signer for the transaction (optional).
    * @param args.transaction - The raw transaction data to simulate.
    * @param args.feePayerPublicKey - The public key of the fee payer (optional).
    * @param args.options - Additional options for simulating the transaction (optional).
@@ -100,7 +100,7 @@ export class Simulate {
    */
   @ValidateFeePayerDataOnSimulation
   async simple(args: {
-    signerPublicKey: PublicKey;
+    signerPublicKey?: PublicKey;
     transaction: AnyRawTransaction;
     feePayerPublicKey?: PublicKey;
     options?: InputSimulateTransactionOptions;
@@ -113,11 +113,12 @@ export class Simulate {
    * This function helps in understanding the outcome of a transaction involving multiple signers before it is executed.
    *
    * @param args - The parameters for simulating the transaction.
-   * @param args.signerPublicKey - The public key of the primary signer.
+   * @param args.signerPublicKey - The public key of the primary signer (optional).
    * @param args.transaction - The raw transaction to be simulated.
-   * @param args.secondarySignersPublicKeys - An array of public keys for secondary signers.
-   * @param args.feePayerPublicKey - (Optional) The public key of the fee payer.
-   * @param args.options - (Optional) Options for simulating the transaction.
+   * @param args.secondarySignersPublicKeys - An array of public keys for secondary signers (optional).
+   *        Each element of the array can be optional, allowing the corresponding key check to be skipped.
+   * @param args.feePayerPublicKey - The public key of the fee payer (optional).
+   * @param args.options - Options for simulating the transaction (optional).
    *
    * @example
    * ```typescript
@@ -176,9 +177,9 @@ export class Simulate {
    */
   @ValidateFeePayerDataOnSimulation
   async multiAgent(args: {
-    signerPublicKey: PublicKey;
+    signerPublicKey?: PublicKey;
     transaction: AnyRawTransaction;
-    secondarySignersPublicKeys: Array<PublicKey>;
+    secondarySignersPublicKeys?: Array<PublicKey | undefined>;
     feePayerPublicKey?: PublicKey;
     options?: InputSimulateTransactionOptions;
   }): Promise<Array<UserTransactionResponse>> {

package/src/core/crypto/keyless.ts

@@ -44,6 +44,62 @@ export const MAX_EXTRA_FIELD_BYTES = 350;
 export const MAX_JWT_HEADER_B64_BYTES = 300;
 export const MAX_COMMITED_EPK_BYTES = 93;
 
+function b64DecodeUnicode(str: string) {
+  return decodeURIComponent(
+    atob(str).replace(/(.)/g, (m, p) => {
+      let code = (p as string).charCodeAt(0).toString(16).toUpperCase();
+      if (code.length < 2) {
+        code = `0${  code}`;
+      }
+      return `%${  code}`;
+    }),
+  );
+}
+
+function base64UrlDecode(str: string) {
+  let output = str.replace(/-/g, "+").replace(/_/g, "/");
+  switch (output.length % 4) {
+    case 0:
+      break;
+    case 2:
+      output += "==";
+      break;
+    case 3:
+      output += "=";
+      break;
+    default:
+      throw new Error("base64 string is not of the correct length");
+  }
+
+  try {
+    return b64DecodeUnicode(output);
+  } catch (err) {
+    return atob(output);
+  }
+}
+
+function getClaim(jwt: string, claim: string): string {
+  const parts = jwt.split(".");
+  const payload = parts[1];
+  const payloadStr = base64UrlDecode(payload);
+  const claimIdx = payloadStr.indexOf(`"${claim}"`) + claim.length + 2;
+  let claimVal = "";
+  let foundStart = false;
+  for (let i = claimIdx; i < payloadStr.length; i += 1) {
+    if (payloadStr[i] === "\"") {
+      if (foundStart) {
+        break;
+      }
+      foundStart = true;
+      continue;
+    }
+    if (foundStart) {
+      claimVal += payloadStr[i];
+    }
+  }
+  return claimVal;
+}
+
 /**
  * Represents a Keyless Public Key used for authentication.
  *
@@ -206,15 +262,9 @@ export class KeylessPublicKey extends AccountPublicKey {
    */
   static fromJwtAndPepper(args: { jwt: string; pepper: HexInput; uidKey?: string }): KeylessPublicKey {
     const { jwt, pepper, uidKey = "sub" } = args;
-    const jwtPayload = jwtDecode<JwtPayload & { [key: string]: string }>(jwt);
-    if (typeof jwtPayload.iss !== "string") {
-      throw new Error("iss was not found");
-    }
-    if (typeof jwtPayload.aud !== "string") {
-      throw new Error("aud was not found or an array of values");
-    }
-    const uidVal = jwtPayload[uidKey];
-    return KeylessPublicKey.create({ iss: jwtPayload.iss, uidKey, uidVal, aud: jwtPayload.aud, pepper });
+
+    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });
+    return KeylessPublicKey.create({ iss, uidKey, uidVal, aud, pepper });
   }
 
   /**
@@ -798,8 +848,7 @@ export function getIssAudAndUidVal(args: { jwt: string; uidKey?: string }): {
       details: "JWT is missing 'aud' in the payload or 'aud' is an array of values.",
     });
   }
-  const uidVal = jwtPayload[uidKey];
-  return { iss: jwtPayload.iss, aud: jwtPayload.aud, uidVal };
+  return { iss: getClaim(jwt, "iss"), aud: getClaim(jwt, "aud"), uidVal: getClaim(jwt, uidKey) };
 }
 
 /**

package/src/internal/keyless.ts

@@ -31,6 +31,7 @@ import { MoveVector } from "../bcs";
 import { generateTransaction } from "./transactionSubmission";
 import { InputGenerateTransactionOptions, SimpleTransaction } from "../transactions";
 import { KeylessError, KeylessErrorType } from "../errors";
+import { FIREBASE_AUTH_ISS_PATTERN } from "../utils/const";
 
 /**
  * Retrieves a pepper value based on the provided configuration and authentication details.
@@ -232,7 +233,16 @@ export async function updateFederatedKeylessJwkSetTransaction(args: {
   options?: InputGenerateTransactionOptions;
 }): Promise<SimpleTransaction> {
   const { aptosConfig, sender, iss, options } = args;
-  const jwksUrl = args.jwksUrl ?? (iss.endsWith("/") ? `${iss}.well-known/jwks.json` : `${iss}/.well-known/jwks.json`);
+
+  let { jwksUrl } = args;
+
+  if (jwksUrl === undefined) {
+    if (FIREBASE_AUTH_ISS_PATTERN.test(iss)) {
+      jwksUrl = "https://www.googleapis.com/service_accounts/v1/jwk/securetoken@system.gserviceaccount.com";
+    } else {
+      jwksUrl = iss.endsWith("/") ? `${iss}.well-known/jwks.json` : `${iss}/.well-known/jwks.json`;
+    }
+  }
 
   let response: Response;
 

package/src/internal/move/jwks/build/jwk/BuildInfo.yaml

@@ -0,0 +1,56 @@
+---
+compiled_package_info:
+  package_name: jwk
+  address_alias_instantiation:
+    Extensions: "0000000000000000000000000000000000000000000000000000000000000001"
+    aptos_framework: "0000000000000000000000000000000000000000000000000000000000000001"
+    aptos_fungible_asset: 000000000000000000000000000000000000000000000000000000000000000a
+    aptos_std: "0000000000000000000000000000000000000000000000000000000000000001"
+    aptos_token: "0000000000000000000000000000000000000000000000000000000000000003"
+    core_resources: 000000000000000000000000000000000000000000000000000000000a550c18
+    std: "0000000000000000000000000000000000000000000000000000000000000001"
+    vm: "0000000000000000000000000000000000000000000000000000000000000000"
+    vm_reserved: "0000000000000000000000000000000000000000000000000000000000000000"
+  source_digest: 3437D4FB002907781F0FE5D46FC4E668C8B8F0420AA77751774AD63B0C2730BF
+  build_flags:
+    dev_mode: false
+    test_mode: false
+    override_std: ~
+    generate_docs: false
+    generate_abis: false
+    generate_move_model: true
+    full_model_generation: false
+    install_dir: ~
+    force_recompilation: false
+    additional_named_addresses: {}
+    architecture: ~
+    fetch_deps_only: false
+    skip_fetch_latest_git_deps: false
+    compiler_config:
+      bytecode_version: 6
+      known_attributes:
+        - bytecode_instruction
+        - deprecated
+        - event
+        - expected_failure
+        - "fmt::skip"
+        - legacy_entry_fun
+        - "lint::allow_unsafe_randomness"
+        - "lint::skip"
+        - native_interface
+        - randomness
+        - resource_group
+        - resource_group_member
+        - test
+        - test_only
+        - verify_only
+        - view
+      skip_attribute_checks: false
+      compiler_version: ~
+      language_version: ~
+      experiments:
+        - optimize=on
+dependencies:
+  - AptosFramework
+  - AptosStdlib
+  - MoveStdlib