@aptos-labs/ts-sdk 1.22.2 → 1.24.0

package/dist/esm/types/index.d.mts

@@ -298,16 +298,18 @@ declare enum TransactionResponseType {
     Genesis = "genesis_transaction",
     BlockMetadata = "block_metadata_transaction",
     StateCheckpoint = "state_checkpoint_transaction",
-    Validator = "validator_transaction"
+    Validator = "validator_transaction",
+    BlockEpilogue = "block_epilogue_transaction"
 }
 type TransactionResponse = PendingTransactionResponse | CommittedTransactionResponse;
-type CommittedTransactionResponse = UserTransactionResponse | GenesisTransactionResponse | BlockMetadataTransactionResponse | StateCheckpointTransactionResponse | ValidatorTransactionResponse;
+type CommittedTransactionResponse = UserTransactionResponse | GenesisTransactionResponse | BlockMetadataTransactionResponse | StateCheckpointTransactionResponse | ValidatorTransactionResponse | BlockEpilogueTransactionResponse;
 declare function isPendingTransactionResponse(response: TransactionResponse): response is PendingTransactionResponse;
 declare function isUserTransactionResponse(response: TransactionResponse): response is UserTransactionResponse;
 declare function isGenesisTransactionResponse(response: TransactionResponse): response is GenesisTransactionResponse;
 declare function isBlockMetadataTransactionResponse(response: TransactionResponse): response is BlockMetadataTransactionResponse;
 declare function isStateCheckpointTransactionResponse(response: TransactionResponse): response is StateCheckpointTransactionResponse;
 declare function isValidatorTransactionResponse(response: TransactionResponse): response is ValidatorTransactionResponse;
+declare function isBlockEpilogueTransactionResponse(response: TransactionResponse): response is BlockEpilogueTransactionResponse;
 type PendingTransactionResponse = {
     type: TransactionResponseType.Pending;
     hash: string;
@@ -469,6 +471,43 @@ type ValidatorTransactionResponse = {
     events: Array<Event>;
     timestamp: string;
 };
+/**
+ * BlockEndInfo describes the gas state of the block
+ */
+type BlockEndInfo = {
+    block_gas_limit_reached: boolean;
+    block_output_limit_reached: boolean;
+    block_effective_block_gas_units: number;
+    block_approx_output_size: number;
+};
+/**
+ * BlockEpilogueTransactionResponse is a transaction that is executed at the end of a block keeping track of data from
+ * the whole block
+ */
+type BlockEpilogueTransactionResponse = {
+    type: TransactionResponseType.BlockEpilogue;
+    version: string;
+    hash: string;
+    state_change_hash: string;
+    event_root_hash: string;
+    state_checkpoint_hash: string | null;
+    gas_used: string;
+    /**
+     * Whether the transaction was successful
+     */
+    success: boolean;
+    /**
+     * The VM status of the transaction, can tell useful information in a failure
+     */
+    vm_status: string;
+    accumulator_root_hash: string;
+    /**
+     * Final state of resources changed by the transaction
+     */
+    changes: Array<WriteSetChange>;
+    timestamp: string;
+    block_end_info: BlockEndInfo | null;
+};
 /**
  * WRITESET CHANGE TYPES
  */
@@ -951,4 +990,4 @@ type GenerateAccountWithSingleSignerSecp256k1Key = {
 };
 type GenerateAccount = GenerateAccountWithEd25519 | GenerateAccountWithSingleSignerSecp256k1Key;
 
-export { AccountAuthenticatorVariant, type AccountData, type AccountSignature, type AnyNumber, AnyPublicKeyVariant, AnySignatureVariant, type AptosRequest, type AptosSettings, type AuthenticationKeyScheme, type Block, type BlockMetadataTransactionResponse, type Client, type ClientConfig, type ClientHeadersType, type ClientRequest, type ClientResponse, type CommittedTransactionResponse, type DecodedTableData, type DeletedTableData, DeriveScheme, type DirectWriteSet, type EntryFunctionPayloadResponse, EphemeralCertificateVariant, EphemeralPublicKeyVariant, EphemeralSignatureVariant, type Event, type EventGuid, type FaucetConfig, type FullNodeConfig, type GasEstimation, type GenerateAccount, type GenerateAccountWithEd25519, type GenerateAccountWithSingleSignerSecp256k1Key, type GenesisPayload, type GenesisTransactionResponse, type HexInput, type IndexerConfig, type LedgerInfo, type LedgerVersionArg, MimeType, MoveAbility, type MoveAddressType, type MoveFunction, type MoveFunctionGenericTypeParam, type MoveFunctionId, MoveFunctionVisibility, type MoveModule, type MoveModuleBytecode, type MoveModuleId, type MoveObjectType, type MoveOptionType, type MoveResource, type MoveScriptBytecode, type MoveStruct, type MoveStructField, type MoveStructId, type MoveStructType, type MoveType, type MoveUint128Type, type MoveUint16Type, type MoveUint256Type, type MoveUint32Type, type MoveUint64Type, type MoveUint8Type, type MoveValue, type MultisigPayloadResponse, OrderBy, type OrderByArg, type PaginationArgs, type PendingTransactionResponse, RoleType, type ScriptPayloadResponse, ScriptTransactionArgumentVariants, type ScriptWriteSet, SigningScheme, SigningSchemeInput, type StateCheckpointTransactionResponse, type TableItemRequest, TokenStandard, type TokenStandardArg, TransactionAuthenticatorVariant, type TransactionEd25519Signature, type TransactionFeePayerSignature, type TransactionMultiAgentSignature, type TransactionMultiEd25519Signature, type TransactionPayloadResponse, TransactionPayloadVariants, type TransactionResponse, TransactionResponseType, type TransactionSecp256k1Signature, type TransactionSignature, TransactionVariants, TypeTagVariants, type Uint128, type Uint16, type Uint256, type Uint32, type Uint64, type Uint8, type UserTransactionResponse, type ValidatorTransactionResponse, type WaitForTransactionOptions, type WhereArg, type WriteSet, type WriteSetChange, type WriteSetChangeDeleteModule, type WriteSetChangeDeleteResource, type WriteSetChangeDeleteTableItem, type WriteSetChangeWriteModule, type WriteSetChangeWriteResource, type WriteSetChangeWriteTableItem, ZkpVariant, isBlockMetadataTransactionResponse, isEd25519Signature, isFeePayerSignature, isGenesisTransactionResponse, isMultiAgentSignature, isMultiEd25519Signature, isPendingTransactionResponse, isSecp256k1Signature, isStateCheckpointTransactionResponse, isUserTransactionResponse, isValidatorTransactionResponse };
+export { AccountAuthenticatorVariant, type AccountData, type AccountSignature, type AnyNumber, AnyPublicKeyVariant, AnySignatureVariant, type AptosRequest, type AptosSettings, type AuthenticationKeyScheme, type Block, type BlockEndInfo, type BlockEpilogueTransactionResponse, type BlockMetadataTransactionResponse, type Client, type ClientConfig, type ClientHeadersType, type ClientRequest, type ClientResponse, type CommittedTransactionResponse, type DecodedTableData, type DeletedTableData, DeriveScheme, type DirectWriteSet, type EntryFunctionPayloadResponse, EphemeralCertificateVariant, EphemeralPublicKeyVariant, EphemeralSignatureVariant, type Event, type EventGuid, type FaucetConfig, type FullNodeConfig, type GasEstimation, type GenerateAccount, type GenerateAccountWithEd25519, type GenerateAccountWithSingleSignerSecp256k1Key, type GenesisPayload, type GenesisTransactionResponse, type HexInput, type IndexerConfig, type LedgerInfo, type LedgerVersionArg, MimeType, MoveAbility, type MoveAddressType, type MoveFunction, type MoveFunctionGenericTypeParam, type MoveFunctionId, MoveFunctionVisibility, type MoveModule, type MoveModuleBytecode, type MoveModuleId, type MoveObjectType, type MoveOptionType, type MoveResource, type MoveScriptBytecode, type MoveStruct, type MoveStructField, type MoveStructId, type MoveStructType, type MoveType, type MoveUint128Type, type MoveUint16Type, type MoveUint256Type, type MoveUint32Type, type MoveUint64Type, type MoveUint8Type, type MoveValue, type MultisigPayloadResponse, OrderBy, type OrderByArg, type PaginationArgs, type PendingTransactionResponse, RoleType, type ScriptPayloadResponse, ScriptTransactionArgumentVariants, type ScriptWriteSet, SigningScheme, SigningSchemeInput, type StateCheckpointTransactionResponse, type TableItemRequest, TokenStandard, type TokenStandardArg, TransactionAuthenticatorVariant, type TransactionEd25519Signature, type TransactionFeePayerSignature, type TransactionMultiAgentSignature, type TransactionMultiEd25519Signature, type TransactionPayloadResponse, TransactionPayloadVariants, type TransactionResponse, TransactionResponseType, type TransactionSecp256k1Signature, type TransactionSignature, TransactionVariants, TypeTagVariants, type Uint128, type Uint16, type Uint256, type Uint32, type Uint64, type Uint8, type UserTransactionResponse, type ValidatorTransactionResponse, type WaitForTransactionOptions, type WhereArg, type WriteSet, type WriteSetChange, type WriteSetChangeDeleteModule, type WriteSetChangeDeleteResource, type WriteSetChangeDeleteTableItem, type WriteSetChangeWriteModule, type WriteSetChangeWriteResource, type WriteSetChangeWriteTableItem, ZkpVariant, isBlockEpilogueTransactionResponse, isBlockMetadataTransactionResponse, isEd25519Signature, isFeePayerSignature, isGenesisTransactionResponse, isMultiAgentSignature, isMultiEd25519Signature, isPendingTransactionResponse, isSecp256k1Signature, isStateCheckpointTransactionResponse, isUserTransactionResponse, isValidatorTransactionResponse };

package/dist/esm/types/index.mjs

@@ -1,2 +1,2 @@
-import{A,B,C,D,E,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z}from"../chunk-Q6LFIZ3L.mjs";import"../chunk-4WPQQPUF.mjs";import"../chunk-FVA2OPG4.mjs";export{g as AccountAuthenticatorVariant,h as AnyPublicKeyVariant,i as AnySignatureVariant,E as DeriveScheme,l as EphemeralCertificateVariant,j as EphemeralPublicKeyVariant,k as EphemeralSignatureVariant,a as MimeType,A as MoveAbility,z as MoveFunctionVisibility,B as RoleType,c as ScriptTransactionArgumentVariants,C as SigningScheme,D as SigningSchemeInput,f as TransactionAuthenticatorVariant,d as TransactionPayloadVariants,n as TransactionResponseType,e as TransactionVariants,b as TypeTagVariants,m as ZkpVariant,r as isBlockMetadataTransactionResponse,u as isEd25519Signature,x as isFeePayerSignature,q as isGenesisTransactionResponse,w as isMultiAgentSignature,y as isMultiEd25519Signature,o as isPendingTransactionResponse,v as isSecp256k1Signature,s as isStateCheckpointTransactionResponse,p as isUserTransactionResponse,t as isValidatorTransactionResponse};
+import{A,B,C,D,E,F,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z}from"../chunk-2BJ23DXY.mjs";import"../chunk-4WPQQPUF.mjs";import"../chunk-FVA2OPG4.mjs";export{g as AccountAuthenticatorVariant,h as AnyPublicKeyVariant,i as AnySignatureVariant,F as DeriveScheme,l as EphemeralCertificateVariant,j as EphemeralPublicKeyVariant,k as EphemeralSignatureVariant,a as MimeType,B as MoveAbility,A as MoveFunctionVisibility,C as RoleType,c as ScriptTransactionArgumentVariants,D as SigningScheme,E as SigningSchemeInput,f as TransactionAuthenticatorVariant,d as TransactionPayloadVariants,n as TransactionResponseType,e as TransactionVariants,b as TypeTagVariants,m as ZkpVariant,u as isBlockEpilogueTransactionResponse,r as isBlockMetadataTransactionResponse,v as isEd25519Signature,y as isFeePayerSignature,q as isGenesisTransactionResponse,x as isMultiAgentSignature,z as isMultiEd25519Signature,o as isPendingTransactionResponse,w as isSecp256k1Signature,s as isStateCheckpointTransactionResponse,p as isUserTransactionResponse,t as isValidatorTransactionResponse};
 //# sourceMappingURL=index.mjs.map

package/dist/esm/utils/index.mjs

@@ -1,2 +1,2 @@
-import"../chunk-GED6IT3S.mjs";import{a as q}from"../chunk-WV5AD4IE.mjs";import"../chunk-FZY4PMEE.mjs";import"../chunk-P5V7OZNN.mjs";import"../chunk-H6YNXJNF.mjs";import"../chunk-KMJ6TF6Y.mjs";import"../chunk-YPHH6CAO.mjs";import"../chunk-Q6LFIZ3L.mjs";import"../chunk-4WPQQPUF.mjs";import"../chunk-DZXM2MQY.mjs";import"../chunk-A63SMUOU.mjs";import"../chunk-BCUSI3N6.mjs";import"../chunk-LG7RJQ57.mjs";import"../chunk-56CNRT2K.mjs";import{a as i,b as j,c as k,d as l,e as m,f as n,g as o,h as p}from"../chunk-L36ZHC7J.mjs";import{a,b,c,d,e,f,g,h}from"../chunk-SCHZ67F3.mjs";import"../chunk-FVA2OPG4.mjs";export{m as APTOS_COIN,i as AptosApiType,j as DEFAULT_MAX_GAS_AMOUNT,k as DEFAULT_TXN_EXP_SEC_FROM_NOW,l as DEFAULT_TXN_TIMEOUT_SEC,f as Network,g as NetworkToChainId,c as NetworkToFaucetAPI,a as NetworkToIndexerAPI,h as NetworkToNetworkName,b as NetworkToNodeAPI,d as NetworkToPepperAPI,e as NetworkToProverAPI,p as ProcessorType,n as RAW_TRANSACTION_SALT,o as RAW_TRANSACTION_WITH_DATA_SALT,q as normalizeBundle};
+import"../chunk-GED6IT3S.mjs";import{a as q}from"../chunk-WV5AD4IE.mjs";import"../chunk-FZY4PMEE.mjs";import"../chunk-KMJ6TF6Y.mjs";import"../chunk-P5V7OZNN.mjs";import"../chunk-H6YNXJNF.mjs";import"../chunk-YPHH6CAO.mjs";import"../chunk-2BJ23DXY.mjs";import"../chunk-4WPQQPUF.mjs";import"../chunk-DZXM2MQY.mjs";import"../chunk-A63SMUOU.mjs";import"../chunk-BCUSI3N6.mjs";import"../chunk-LG7RJQ57.mjs";import"../chunk-56CNRT2K.mjs";import{a as i,b as j,c as k,d as l,e as m,f as n,g as o,h as p}from"../chunk-SCHZ67F3.mjs";import{a,b,c,d,e,f,g,h}from"../chunk-L36ZHC7J.mjs";import"../chunk-FVA2OPG4.mjs";export{e as APTOS_COIN,a as AptosApiType,b as DEFAULT_MAX_GAS_AMOUNT,c as DEFAULT_TXN_EXP_SEC_FROM_NOW,d as DEFAULT_TXN_TIMEOUT_SEC,n as Network,o as NetworkToChainId,k as NetworkToFaucetAPI,i as NetworkToIndexerAPI,p as NetworkToNetworkName,j as NetworkToNodeAPI,l as NetworkToPepperAPI,m as NetworkToProverAPI,h as ProcessorType,f as RAW_TRANSACTION_SALT,g as RAW_TRANSACTION_WITH_DATA_SALT,q as normalizeBundle};
 //# sourceMappingURL=index.mjs.map

package/dist/esm/utils/normalizeBundle.mjs

@@ -1,2 +1,2 @@
-import{a}from"../chunk-WV5AD4IE.mjs";import"../chunk-FZY4PMEE.mjs";import"../chunk-P5V7OZNN.mjs";import"../chunk-H6YNXJNF.mjs";import"../chunk-KMJ6TF6Y.mjs";import"../chunk-YPHH6CAO.mjs";import"../chunk-Q6LFIZ3L.mjs";import"../chunk-4WPQQPUF.mjs";import"../chunk-DZXM2MQY.mjs";import"../chunk-A63SMUOU.mjs";import"../chunk-BCUSI3N6.mjs";import"../chunk-LG7RJQ57.mjs";import"../chunk-56CNRT2K.mjs";import"../chunk-FVA2OPG4.mjs";export{a as normalizeBundle};
+import{a}from"../chunk-WV5AD4IE.mjs";import"../chunk-FZY4PMEE.mjs";import"../chunk-KMJ6TF6Y.mjs";import"../chunk-P5V7OZNN.mjs";import"../chunk-H6YNXJNF.mjs";import"../chunk-YPHH6CAO.mjs";import"../chunk-2BJ23DXY.mjs";import"../chunk-4WPQQPUF.mjs";import"../chunk-DZXM2MQY.mjs";import"../chunk-A63SMUOU.mjs";import"../chunk-BCUSI3N6.mjs";import"../chunk-LG7RJQ57.mjs";import"../chunk-56CNRT2K.mjs";import"../chunk-FVA2OPG4.mjs";export{a as normalizeBundle};
 //# sourceMappingURL=normalizeBundle.mjs.map

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.22.2";
+declare const VERSION = "1.24.0";
 
 export { VERSION };

package/dist/esm/version.mjs

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

package/package.json

@@ -35,6 +35,7 @@
   "scripts": {
     "build:clean": "rm -rf dist",
     "build": "pnpm build:clean && tsup",
+    "prepublishOnly": "pnpm run build",
     "_fmt": "prettier 'src/**/*.ts' 'tests/**/*.ts' 'examples/**/*.js' 'examples/**/*.ts' '.eslintrc.js'",
     "fmt": "pnpm _fmt --write",
     "lint": "eslint 'src/**/*.ts' 'tests/**/*.ts' 'examples/**/*.ts'",
@@ -91,5 +92,5 @@
     "typedoc": "^0.25.4",
     "typescript": "^5.3.3"
   },
-  "version": "1.22.2"
+  "version": "1.24.0"
 }

package/src/account/KeylessAccount.ts

@@ -11,7 +11,6 @@ import {
   KeylessPublicKey,
   KeylessSignature,
   EphemeralCertificate,
-  Signature,
   ZeroKnowledgeSig,
   ZkProof,
 } from "../core/crypto";
@@ -269,9 +268,26 @@ export class KeylessAccount extends Serializable implements Account {
     return this.sign(signMess);
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this
-  verifySignature(args: { message: HexInput; signature: Signature }): boolean {
-    throw new Error("Not implemented");
+  /**
+   * Note - This function is currently incomplete and should only be used to verify ownership of the KeylessAccount
+   *
+   * Verifies a signature given the message.
+   *
+   * TODO: Groth16 proof verification
+   *
+   * @param args.message the message that was signed.
+   * @param args.signature the KeylessSignature to verify
+   * @returns boolean
+   */
+  verifySignature(args: { message: HexInput; signature: KeylessSignature }): boolean {
+    const { message, signature } = args;
+    if (this.isExpired()) {
+      return false;
+    }
+    if (!this.ephemeralKeyPair.getPublicKey().verifySignature({ message, signature: signature.ephemeralSignature })) {
+      return false;
+    }
+    return true;
   }
 
   static fromBytes(bytes: Uint8Array): KeylessAccount {

package/src/api/account.ts

@@ -439,12 +439,15 @@ export class Account {
    *
    * @param args.accountAddress The account address we want to get the total count for
    * @param args.coinType The coin type to query
+   * @param args.faMetadataAddress The fungible asset metadata address to query.
+   *        Note: coinType will automatically fill this in if not provided when migrated to fungible assets
    * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    * @returns Current amount of account's coin
    */
   async getAccountCoinAmount(args: {
     accountAddress: AccountAddressInput;
-    coinType: MoveStructId;
+    coinType?: MoveStructId;
+    faMetadataAddress?: AccountAddressInput;
     minimumLedgerVersion?: AnyNumber;
   }): Promise<number> {
     await waitForIndexerOnVersion({

package/src/api/faucet.ts

@@ -6,6 +6,7 @@ import { UserTransactionResponse, WaitForTransactionOptions } from "../types";
 import { AccountAddressInput } from "../core";
 import { AptosConfig } from "./aptosConfig";
 import { waitForIndexer } from "../internal/transaction";
+import { ProcessorType } from "../utils";
 
 /**
  * A class to query all `Faucet` related queries on Aptos.
@@ -33,7 +34,11 @@ export class Faucet {
     const fundTxn = await fundAccount({ aptosConfig: this.config, ...args });
 
     if (args.options?.waitForIndexer !== false) {
-      await waitForIndexer({ aptosConfig: this.config, minimumLedgerVersion: BigInt(fundTxn.version) });
+      await waitForIndexer({
+        aptosConfig: this.config,
+        minimumLedgerVersion: BigInt(fundTxn.version),
+        processorType: ProcessorType.FUNGIBLE_ASSET_PROCESSOR,
+      });
     }
 
     return fundTxn;

package/src/client/core.ts

@@ -7,20 +7,6 @@ import { VERSION } from "../version";
 import { AnyNumber, AptosRequest, Client, ClientRequest, ClientResponse, MimeType } from "../types";
 import { AptosApiType } from "../utils";
 
-/**
- * Meaningful errors map
- */
-const errors: Record<number, string> = {
-  400: "Bad Request",
-  401: "Unauthorized",
-  403: "Forbidden",
-  404: "Not Found",
-  429: "Too Many Requests",
-  500: "Internal Server Error",
-  502: "Bad Gateway",
-  503: "Service Unavailable",
-};
-
 /**
  * Given a url and method, sends the request with axios and
  * returns the response.
@@ -58,71 +44,58 @@ export async function request<Req, Res>(options: ClientRequest<Req>, client: Cli
 /**
  * The main function to use when doing an API request.
  *
- * @param options AptosRequest
+ * @param aptosRequestOpts AptosRequest
  * @param aptosConfig The config information for the SDK client instance
  * @returns the response or AptosApiError
  */
 export async function aptosRequest<Req extends {}, Res extends {}>(
-  options: AptosRequest,
+  aptosRequestOpts: AptosRequest,
   aptosConfig: AptosConfig,
   apiType: AptosApiType,
 ): Promise<AptosResponse<Req, Res>> {
-  const { url, path } = options;
+  const { url, path } = aptosRequestOpts;
   const fullUrl = path ? `${url}/${path}` : url;
-  const response = await request<Req, Res>({ ...options, url: fullUrl }, aptosConfig.client);
+  const clientResponse = await request<Req, Res>({ ...aptosRequestOpts, url: fullUrl }, aptosConfig.client);
 
-  const result: AptosResponse<Req, Res> = {
-    status: response.status,
-    statusText: response.statusText!,
-    data: response.data,
-    headers: response.headers,
-    config: response.config,
-    request: response.request,
+  const aptosResponse: AptosResponse<Req, Res> = {
+    status: clientResponse.status,
+    statusText: clientResponse.statusText!,
+    data: clientResponse.data,
+    headers: clientResponse.headers,
+    config: clientResponse.config,
+    request: clientResponse.request,
     url: fullUrl,
   };
 
   // Handle case for `Unauthorized` error (i.e API_KEY error)
-  if (result.status === 401) {
-    throw new AptosApiError(options, result, `Error: ${result.data}`);
+  if (aptosResponse.status === 401) {
+    throw new AptosApiError({ apiType, aptosRequest: aptosRequestOpts, aptosResponse });
   }
 
   // to support both fullnode and indexer responses,
   // check if it is an indexer query, and adjust response.data
   if (apiType === AptosApiType.INDEXER) {
-    const indexerResponse = result.data as any;
+    const indexerResponse = aptosResponse.data as any;
     // Handle Indexer general errors
     if (indexerResponse.errors) {
-      throw new AptosApiError(
-        options,
-        result,
-        `Indexer error: ${indexerResponse.errors[0].message}` ??
-          `Indexer unhandled Error ${response.status} : ${response.statusText}`,
-      );
+      throw new AptosApiError({
+        apiType,
+        aptosRequest: aptosRequestOpts,
+        aptosResponse,
+      });
     }
-    result.data = indexerResponse.data as Res;
+    aptosResponse.data = indexerResponse.data as Res;
   } else if (apiType === AptosApiType.PEPPER || apiType === AptosApiType.PROVER) {
-    if (result.status >= 400) {
-      throw new AptosApiError(options, result, `${response.data}`);
+    if (aptosResponse.status >= 400) {
+      throw new AptosApiError({ apiType, aptosRequest: aptosRequestOpts, aptosResponse });
     }
   }
 
-  if (result.status >= 200 && result.status < 300) {
-    return result;
-  }
-
-  let errorMessage: string;
-
-  if (result && result.data && "message" in result.data && "error_code" in result.data) {
-    errorMessage = JSON.stringify(result.data);
-  } else if (result.status in errors) {
-    // If it's not an API type, it must come form infra, these are prehandled
-    errorMessage = errors[result.status];
-  } else {
-    // Everything else is unhandled
-    errorMessage = `Unhandled Error ${result.status} : ${result.statusText}`;
+  if (aptosResponse.status >= 200 && aptosResponse.status < 300) {
+    return aptosResponse;
   }
 
   // We have to explicitly check for all request types, because if the error is a non-indexer error, but
   // comes from an indexer request (e.g. 404), we'll need to mention it appropriately
-  throw new AptosApiError(options, result, `${apiType} error: ${errorMessage}`);
+  throw new AptosApiError({ apiType, aptosRequest: aptosRequestOpts, aptosResponse });
 }

package/src/client/types.ts

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { AptosRequest } from "../types";
+import { AptosApiType } from "../utils/const.js";
 
 /**
  * The API response type
@@ -24,6 +25,12 @@ export interface AptosResponse<Req, Res> {
   request?: Req;
 }
 
+type AptosApiErrorOpts = {
+  apiType: AptosApiType;
+  aptosRequest: AptosRequest;
+  aptosResponse: AptosResponse<any, any>;
+};
+
 /**
  * The type returned from an API error
  *
@@ -45,14 +52,60 @@ export class AptosApiError extends Error {
 
   readonly request: AptosRequest;
 
-  constructor(request: AptosRequest, response: AptosResponse<any, any>, message: string) {
-    super(message);
+  /** @internal this constructor is for sdk internal use - do not instantiate outside of the SDK codebase */
+  constructor({ apiType, aptosRequest, aptosResponse }: AptosApiErrorOpts) {
+    super(deriveErrorMessage({ apiType, aptosRequest, aptosResponse }));
 
     this.name = "AptosApiError";
-    this.url = response.url;
-    this.status = response.status;
-    this.statusText = response.statusText;
-    this.data = response.data;
-    this.request = request;
+    this.url = aptosResponse.url;
+    this.status = aptosResponse.status;
+    this.statusText = aptosResponse.statusText;
+    this.data = aptosResponse.data;
+    this.request = aptosRequest;
+  }
+}
+
+function deriveErrorMessage({ apiType, aptosRequest, aptosResponse }: AptosApiErrorOpts): string {
+  // extract the W3C trace_id from the response headers if it exists. Some services set this in the response and it's useful for debugging.
+  // See https://www.w3.org/TR/trace-context/#relationship-between-the-headers .
+  const traceId = aptosResponse.headers?.traceparent?.split("-")[1];
+  const traceIdString = traceId ? `(trace_id:${traceId}) ` : "";
+
+  const errorPrelude: string = `Request to [${apiType}]: ${aptosRequest.method} ${
+    aptosResponse.url ?? aptosRequest.url
+  } ${traceIdString}failed with`;
+
+  // handle graphql responses from indexer api and extract the error message of the first error
+  if (apiType === AptosApiType.INDEXER && aptosResponse.data?.errors?.[0]?.message != null) {
+    return `${errorPrelude}: ${aptosResponse.data.errors[0].message}`;
+  }
+
+  // Received well-known structured error response body - simply serialize and return it.
+  // We don't need http status codes etc. in this case.
+  if (aptosResponse.data?.message != null && aptosResponse.data?.error_code != null) {
+    return `${errorPrelude}: ${JSON.stringify(aptosResponse.data)}`;
+  }
+
+  // This is the generic/catch-all case. We received some response from the API but it doesn't appear to be a well-known structure.
+  // We print http status codes and the response body (after some trimming),
+  // in the hope that this gives enough context what went wrong without printing overly huge messages.
+  return `${errorPrelude} status: ${aptosResponse.statusText}(code:${
+    aptosResponse.status
+  }) and response body: ${serializeAnyPayloadForErrorMessage(aptosResponse.data)}`;
+}
+
+const SERIALIZED_PAYLOAD_TRIM_TO_MAX_LENGTH = 400;
+
+// this function accepts a payload of any type (probably an object) and serializes it to a string
+// Since we don't know the type or size of the payload and we don't want to add a huge object in full to the error message
+// we limit the to the first 200 and last 200 characters of the serialized payload and put a "..." in the middle.
+function serializeAnyPayloadForErrorMessage(payload: any): string {
+  const serializedPayload = JSON.stringify(payload);
+  if (serializedPayload.length <= SERIALIZED_PAYLOAD_TRIM_TO_MAX_LENGTH) {
+    return serializedPayload;
   }
+  return `truncated(original_size:${serializedPayload.length}): ${serializedPayload.slice(
+    0,
+    SERIALIZED_PAYLOAD_TRIM_TO_MAX_LENGTH / 2,
+  )}...${serializedPayload.slice(-SERIALIZED_PAYLOAD_TRIM_TO_MAX_LENGTH / 2)}`;
 }

package/src/core/accountAddress.ts

@@ -65,6 +65,8 @@ export class AccountAddress extends Serializable implements TransactionArgument
 
   static FOUR: AccountAddress = AccountAddress.from("0x4");
 
+  static A: AccountAddress = AccountAddress.from("0xA");
+
   /**
    * Creates an instance of AccountAddress from a Uint8Array.
    *
@@ -342,13 +344,13 @@ export class AccountAddress extends Serializable implements TransactionArgument
    * @param input
    */
   static from(input: AccountAddressInput): AccountAddress {
-    if (input instanceof AccountAddress) {
-      return input;
+    if (typeof input === "string") {
+      return AccountAddress.fromString(input);
     }
     if (input instanceof Uint8Array) {
       return new AccountAddress(input);
     }
-    return AccountAddress.fromString(input);
+    return input;
   }
 
   /**
@@ -358,13 +360,13 @@ export class AccountAddress extends Serializable implements TransactionArgument
    * @param input
    */
   static fromStrict(input: AccountAddressInput): AccountAddress {
-    if (input instanceof AccountAddress) {
-      return input;
+    if (typeof input === "string") {
+      return AccountAddress.fromStringStrict(input);
     }
     if (input instanceof Uint8Array) {
       return new AccountAddress(input);
     }
-    return AccountAddress.fromStringStrict(input);
+    return input;
   }
 
   // ===

package/src/core/crypto/ed25519.ts

@@ -9,7 +9,7 @@ import { Hex } from "../hex";
 import { HexInput, SigningScheme as AuthenticationKeyScheme } from "../../types";
 import { CKDPriv, deriveKey, HARDENED_OFFSET, isValidHardenedPath, mnemonicToSeed, splitPath } from "./hdKey";
 import { PrivateKey } from "./privateKey";
-import { AccountPublicKey, VerifySignatureArgs } from "./publicKey";
+import { AccountPublicKey, PublicKey, VerifySignatureArgs } from "./publicKey";
 import { Signature } from "./signature";
 import { convertSigningMessage } from "./utils";
 
@@ -21,6 +21,26 @@ const L: number[] = [
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
 ];
 
+/**
+ * Checks if an ED25519 signature is non-canonical.
+ *
+ * Comes from Aptos Core
+ * https://github.com/aptos-labs/aptos-core/blob/main/crates/aptos-crypto/src/ed25519/ed25519_sigs.rs#L47-L85
+ */
+export function isCanonicalEd25519Signature(signature: Signature): boolean {
+  const s = signature.toUint8Array().slice(32);
+  for (let i = L.length - 1; i >= 0; i -= 1) {
+    if (s[i] < L[i]) {
+      return true;
+    }
+    if (s[i] > L[i]) {
+      return false;
+    }
+  }
+  // As this stage S == L which implies a non-canonical S.
+  return false;
+}
+
 /**
  * Represents the public key of an Ed25519 key pair.
  *
@@ -66,18 +86,15 @@ export class Ed25519PublicKey extends AccountPublicKey {
    */
   verifySignature(args: VerifySignatureArgs): boolean {
     const { message, signature } = args;
-    if (!(signature instanceof Ed25519Signature)) {
+    // Verify malleability
+    if (!isCanonicalEd25519Signature(signature)) {
       return false;
     }
+
     const messageToVerify = convertSigningMessage(message);
     const messageBytes = Hex.fromHexInput(messageToVerify).toUint8Array();
     const signatureBytes = signature.toUint8Array();
     const publicKeyBytes = this.key.toUint8Array();
-    // Also verify malleability
-    if (!signature.isCanonicalSignature()) {
-      return false;
-    }
-
     return ed25519.verify(signatureBytes, messageBytes, publicKeyBytes);
   }
 
@@ -118,6 +135,10 @@ export class Ed25519PublicKey extends AccountPublicKey {
   static isPublicKey(publicKey: AccountPublicKey): publicKey is Ed25519PublicKey {
     return publicKey instanceof Ed25519PublicKey;
   }
+
+  static isInstance(publicKey: PublicKey): publicKey is Ed25519PublicKey {
+    return "key" in publicKey && (publicKey.key as any)?.data?.length === Ed25519PublicKey.LENGTH;
+  }
 }
 
 /**
@@ -325,26 +346,5 @@ export class Ed25519Signature extends Signature {
     return new Ed25519Signature(bytes);
   }
 
-  /**
-   * Checks if an ED25519 signature is non-canonical.
-   *
-   * Comes from Aptos Core
-   * https://github.com/aptos-labs/aptos-core/blob/main/crates/aptos-crypto/src/ed25519/ed25519_sigs.rs#L47-L85
-   */
-  isCanonicalSignature(): boolean {
-    const s = this.toUint8Array().slice(32);
-
-    for (let i = s.length - 1; i >= 0; i -= 1) {
-      if (s[i] < L[i]) {
-        return true;
-      }
-      if (s[i] > L[i]) {
-        return false;
-      }
-    }
-    // As this stage S == L which implies a non-canonical S.
-    return false;
-  }
-
   // endregion
 }

package/src/core/crypto/ephemeral.ts

@@ -52,7 +52,7 @@ export class EphemeralPublicKey extends PublicKey {
    */
   verifySignature(args: { message: HexInput; signature: EphemeralSignature }): boolean {
     const { message, signature } = args;
-    return this.publicKey.verifySignature({ message, signature });
+    return this.publicKey.verifySignature({ message, signature: signature.signature });
   }
 
   serialize(serializer: Serializer): void {

package/src/core/crypto/keyless.ts

@@ -166,6 +166,15 @@ export class KeylessPublicKey extends AccountPublicKey {
     const uidVal = jwtPayload[uidKey];
     return KeylessPublicKey.create({ iss, uidKey, uidVal, aud, pepper });
   }
+
+  static isInstance(publicKey: PublicKey) {
+    return (
+      "iss" in publicKey &&
+      typeof publicKey.iss === "string" &&
+      "idCommitment" in publicKey &&
+      publicKey.idCommitment instanceof Uint8Array
+    );
+  }
 }
 
 function computeIdCommitment(args: { uidKey: string; uidVal: string; aud: string; pepper: HexInput }): Uint8Array {

package/src/core/crypto/secp256k1.ts

@@ -48,9 +48,6 @@ export class Secp256k1PublicKey extends PublicKey {
    */
   verifySignature(args: VerifySignatureArgs): boolean {
     const { message, signature } = args;
-    if (!(signature instanceof Secp256k1Signature)) {
-      return false;
-    }
     const messageToVerify = convertSigningMessage(message);
     const messageBytes = Hex.fromHexInput(messageToVerify).toUint8Array();
     const messageSha3Bytes = sha3_256(messageBytes);
@@ -84,6 +81,10 @@ export class Secp256k1PublicKey extends PublicKey {
   static isPublicKey(publicKey: PublicKey): publicKey is Secp256k1PublicKey {
     return publicKey instanceof Secp256k1PublicKey;
   }
+
+  static isInstance(publicKey: PublicKey): publicKey is Secp256k1PublicKey {
+    return "key" in publicKey && (publicKey.key as any)?.data?.length === Secp256k1PublicKey.LENGTH;
+  }
 }
 
 /**

package/src/core/crypto/singleKey.ts

@@ -48,7 +48,7 @@ export class AnyPublicKey extends AccountPublicKey {
 
   verifySignature(args: VerifySignatureArgs): boolean {
     const { message, signature } = args;
-    if (!(signature instanceof AnySignature)) {
+    if (!AnySignature.isInstance(signature)) {
       return false;
     }
 
@@ -119,6 +119,10 @@ export class AnyPublicKey extends AccountPublicKey {
   isSecp256k1PublicKey(): boolean {
     return this.publicKey instanceof Secp256k1PublicKey;
   }
+
+  static isInstance(publicKey: PublicKey): publicKey is AnyPublicKey {
+    return "publicKey" in publicKey && "variant" in publicKey;
+  }
 }
 
 /**
@@ -156,6 +160,12 @@ export class AnySignature extends Signature {
   // region AccountSignature
 
   toUint8Array() {
+    // TODO: keep this warning around for a bit, and eventually change this to return `this.signature.toUint8Array()`.
+    // eslint-disable-next-line no-console
+    console.warn(
+      "[Aptos SDK] Calls to AnySignature.toUint8Array() will soon return the underlying signature bytes. " +
+        "Use AnySignature.bcsToBytes() instead.",
+    );
     return this.bcsToBytes();
   }
 
@@ -188,4 +198,13 @@ export class AnySignature extends Signature {
   }
 
   // endregion
+
+  static isInstance(signature: Signature): signature is AnySignature {
+    return (
+      "signature" in signature &&
+      typeof signature.signature === "object" &&
+      signature.signature !== null &&
+      "toUint8Array" in signature.signature
+    );
+  }
 }