@aptos-labs/ts-sdk 1.22.1 → 1.23.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-DZXM2MQY.mjs";import"../chunk-Q6LFIZ3L.mjs";import"../chunk-4WPQQPUF.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-P5V7OZNN.mjs";import"../chunk-H6YNXJNF.mjs";import"../chunk-KMJ6TF6Y.mjs";import"../chunk-YPHH6CAO.mjs";import"../chunk-DZXM2MQY.mjs";import"../chunk-2BJ23DXY.mjs";import"../chunk-4WPQQPUF.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-DZXM2MQY.mjs";import"../chunk-Q6LFIZ3L.mjs";import"../chunk-4WPQQPUF.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-P5V7OZNN.mjs";import"../chunk-H6YNXJNF.mjs";import"../chunk-KMJ6TF6Y.mjs";import"../chunk-YPHH6CAO.mjs";import"../chunk-DZXM2MQY.mjs";import"../chunk-2BJ23DXY.mjs";import"../chunk-4WPQQPUF.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.20.0";
+declare const VERSION = "1.23.0";
 
 export { VERSION };

package/dist/esm/version.mjs

@@ -1,2 +1,2 @@
-import{a}from"./chunk-4KYQ7N3N.mjs";import"./chunk-FVA2OPG4.mjs";export{a as VERSION};
+import{a}from"./chunk-2M45ESQN.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.1"
+  "version": "1.23.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/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.
    *

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/internal/account.ts

@@ -52,9 +52,10 @@ import {
   GetAccountTransactionsCount,
 } from "../types/generated/queries";
 import { memoizeAsync } from "../utils/memoize";
-import { Secp256k1PrivateKey, AuthenticationKey, Ed25519PrivateKey } from "../core";
+import { Secp256k1PrivateKey, AuthenticationKey, Ed25519PrivateKey, createObjectAddress } from "../core";
 import { CurrentFungibleAssetBalancesBoolExp } from "../types/generated/types";
 import { getTableItem } from "./table";
+import { APTOS_COIN } from "../utils";
 
 export async function getInfo(args: {
   aptosConfig: AptosConfig;
@@ -404,16 +405,46 @@ export async function getAccountTransactionsCount(args: {
 export async function getAccountCoinAmount(args: {
   aptosConfig: AptosConfig;
   accountAddress: AccountAddressInput;
-  coinType: MoveStructId;
+  coinType?: MoveStructId;
+  faMetadataAddress?: AccountAddressInput;
 }): Promise<number> {
-  const { aptosConfig, accountAddress, coinType } = args;
+  const { aptosConfig, accountAddress, coinType, faMetadataAddress } = args;
+  let coinAssetType: string | undefined;
+  let faAddress: string;
+
+  if (coinType !== undefined && faMetadataAddress !== undefined) {
+    faAddress = AccountAddress.from(faMetadataAddress).toStringLong();
+  } else if (coinType !== undefined && faMetadataAddress === undefined) {
+    coinAssetType = coinType;
+    // TODO Move to a separate function as defined in the AIP for coin migration
+    if (args.coinType === APTOS_COIN) {
+      faAddress = AccountAddress.A.toStringLong();
+    } else {
+      faAddress = createObjectAddress(AccountAddress.A, coinType).toStringLong();
+    }
+  } else if (coinType === undefined && faMetadataAddress !== undefined) {
+    // TODO: add a view function lookup for non-APT migrated coins
+    const addr = AccountAddress.from(faMetadataAddress);
+    faAddress = addr.toStringLong();
+    if (addr === AccountAddress.A) {
+      coinAssetType = APTOS_COIN;
+    }
+  } else {
+    throw new Error("Either coinType, fungibleAssetAddress, or both must be provided");
+  }
   const address = AccountAddress.from(accountAddress).toStringLong();
 
+  // Search by fungible asset address, unless it has a coin it migrated from
+  let where: any = { asset_type: { _eq: faAddress } };
+  if (coinType !== undefined) {
+    where = { asset_type: { _in: [coinAssetType, faAddress] } };
+  }
+
   const data = await getAccountCoinsData({
     aptosConfig,
     accountAddress: address,
     options: {
-      where: { asset_type: { _eq: coinType } },
+      where,
     },
   });
 

package/src/internal/ans.ts

@@ -68,6 +68,40 @@ export function isValidANSName(name: string): { domainName: string; subdomainNam
   };
 }
 
+export enum SubdomainExpirationPolicy {
+  Independent = 0,
+  FollowsDomain = 1,
+}
+
+/**
+ * A helper function to determine if a given ANS name is considered active or
+ * not. Domains are considered active if their expiration date is in the
+ * future. Subdomains have two policies which modify their behavior. They can
+ * follow their parent's expiration (1) in which they ignore their own
+ * expiration timestamp or they can expire independently (0) in which they can
+ * expire before their parent but not afterwards.
+ *
+ * @param name - An ANS name returned from one of the functions of the SDK
+ * @returns A boolean representing if the contract considers the name active or not
+ */
+export function isActiveANSName(name: GetANSNameResponse[0]): boolean {
+  if (!name) return false;
+
+  const isTLDExpired = new Date(name.domain_expiration_timestamp).getTime() < Date.now();
+  const isExpired = new Date(name.expiration_timestamp).getTime() < Date.now();
+
+  // If we are a subdomain, if our parent is expired we are always expired
+  if (name.subdomain && isTLDExpired) return false;
+
+  // If we are a subdomain and our expiration policy is to follow the domain, we
+  // are active (since we know our parent is not expired by this point)
+  if (name.subdomain && name.subdomain_expiration_policy === SubdomainExpirationPolicy.FollowsDomain) return true;
+
+  // At this point, we are either a TLD or a subdomain with an independent
+  // expiration policy, we are active as long as we the expiration timestamp
+  return !isExpired;
+}
+
 export const LOCAL_ANS_ACCOUNT_PK =
   process.env.ANS_TEST_ACCOUNT_PRIVATE_KEY ?? "0x37368b46ce665362562c6d1d4ec01a08c8644c488690df5a17e13ba163e20221";
 export const LOCAL_ANS_ACCOUNT_ADDRESS =
@@ -344,7 +378,6 @@ export async function getName(args: {
   const where: CurrentAptosNamesBoolExp = {
     domain: { _eq: domainName },
     subdomain: { _eq: subdomainName },
-    is_active: { _eq: true },
   };
 
   const data = await queryIndexer<GetNamesQuery>({
@@ -365,7 +398,7 @@ export async function getName(args: {
     res = sanitizeANSName(res);
   }
 
-  return res;
+  return isActiveANSName(res) ? res : undefined;
 }
 
 interface QueryNamesOptions {
@@ -492,13 +525,12 @@ export async function getDomainSubdomains(
           ...(args.options?.where ?? {}),
           domain: { _eq: domain },
           subdomain: { _neq: "" },
-          is_active: { _eq: true },
         },
       },
     },
   });
 
-  return data.current_aptos_names.map(sanitizeANSName);
+  return data.current_aptos_names.map(sanitizeANSName).filter(isActiveANSName);
 }
 
 /**

package/src/internal/queries/ansTokenFragment.graphql

@@ -6,4 +6,6 @@ fragment AnsTokenFragment on current_aptos_names {
   token_standard
   is_primary
   owner_address
+  subdomain_expiration_policy
+  domain_expiration_timestamp
 }

package/src/types/generated/operations.ts

@@ -26,6 +26,8 @@ export type AnsTokenFragmentFragment = {
   token_standard?: string | null;
   is_primary?: boolean | null;
   owner_address?: string | null;
+  subdomain_expiration_policy?: any | null;
+  domain_expiration_timestamp?: any | null;
 };
 
 export type CurrentTokenOwnershipFieldsFragment = {
@@ -94,15 +96,15 @@ export type GetAccountCoinsDataQueryVariables = Types.Exact<{
 
 export type GetAccountCoinsDataQuery = {
   current_fungible_asset_balances: Array<{
-    amount: any;
-    asset_type: string;
+    amount?: any | null;
+    asset_type?: string | null;
     is_frozen: boolean;
-    is_primary: boolean;
-    last_transaction_timestamp: any;
-    last_transaction_version: any;
+    is_primary?: boolean | null;
+    last_transaction_timestamp?: any | null;
+    last_transaction_version?: any | null;
     owner_address: string;
     storage_id: string;
-    token_standard: string;
+    token_standard?: string | null;
     metadata?: {
       token_standard: string;
       symbol: string;
@@ -392,15 +394,15 @@ export type GetCurrentFungibleAssetBalancesQueryVariables = Types.Exact<{
 
 export type GetCurrentFungibleAssetBalancesQuery = {
   current_fungible_asset_balances: Array<{
-    amount: any;
-    asset_type: string;
+    amount?: any | null;
+    asset_type?: string | null;
     is_frozen: boolean;
-    is_primary: boolean;
-    last_transaction_timestamp: any;
-    last_transaction_version: any;
+    is_primary?: boolean | null;
+    last_transaction_timestamp?: any | null;
+    last_transaction_version?: any | null;
     owner_address: string;
     storage_id: string;
-    token_standard: string;
+    token_standard?: string | null;
   }>;
 };
 
@@ -509,6 +511,8 @@ export type GetNamesQuery = {
     token_standard?: string | null;
     is_primary?: boolean | null;
     owner_address?: string | null;
+    subdomain_expiration_policy?: any | null;
+    domain_expiration_timestamp?: any | null;
   }>;
 };
 

package/src/types/generated/queries.ts

@@ -30,6 +30,8 @@ export const AnsTokenFragmentFragmentDoc = `
   token_standard
   is_primary
   owner_address
+  subdomain_expiration_policy
+  domain_expiration_timestamp
 }
     `;
 export const CurrentTokenOwnershipFieldsFragmentDoc = `