@aptos-labs/ts-sdk 0.0.6 → 0.0.8

package/src/client/core.ts

@@ -38,6 +38,9 @@ export async function request<Req, Res>(options: ClientRequest<Req>, client: Cli
   if (overrides?.AUTH_TOKEN && url.includes("faucet")) {
     headers.Authorization = `Bearer ${overrides?.AUTH_TOKEN}`;
   }
+  if (overrides?.API_KEY && !url.includes("faucet")) {
+    headers.Authorization = `Bearer ${overrides?.API_KEY}`;
+  }
 
   /*
    * make a call using the @aptos-labs/aptos-client package
@@ -99,15 +102,14 @@ export async function aptosRequest<Req extends {}, Res extends {}>(
 
   let errorMessage: string;
 
-  // If it is the shape of an AptosApiError, convert it properly
-  if ("message" in response.data && "error_code" in response.data) {
-    errorMessage = JSON.stringify(response.data);
+  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 ${response.status} : ${response.statusText}`;
+    errorMessage = `Unhandled Error ${result.status} : ${result.statusText}`;
   }
 
   throw new AptosApiError(options, result, errorMessage);

package/src/client/get.ts

@@ -78,17 +78,18 @@ export async function getAptosFullNode<Req extends {}, Res extends {}>(
 }
 
 /// This function is a helper for paginating using a function wrapping an API
-export async function paginateWithCursor<Req extends Record<string, any>, Res extends any[]>(
+export async function paginateWithCursor<Req extends Record<string, any>, Res extends Array<{}>>(
   options: GetAptosRequestOptions,
 ): Promise<Res> {
-  const out = [];
+  const out: any[] = [];
   let cursor: string | undefined;
-  const requestParams = options.params as Req & { start?: string; limit?: number };
+  const requestParams = options.params as { start?: string; limit?: number };
   // eslint-disable-next-line no-constant-condition
   while (true) {
     requestParams.start = cursor;
     // eslint-disable-next-line no-await-in-loop
-    const response = await getAptosFullNode<Req, Res>({
+    const response = await get<Req, Res>({
+      type: AptosApiType.FULLNODE,
       aptosConfig: options.aptosConfig,
       originMethod: options.originMethod,
       path: options.path,
@@ -103,11 +104,11 @@ export async function paginateWithCursor<Req extends Record<string, any>, Res ex
     cursor = response.headers["x-aptos-cursor"];
     // Now that we have the cursor (if any), we remove the headers before
     // adding these to the output of this function.
-    delete (response as any).headers;
+    delete response.headers;
     out.push(...response.data);
     if (cursor === null || cursor === undefined) {
       break;
     }
   }
-  return out as any;
+  return out as Res;
 }

package/src/core/accountAddress.ts

@@ -218,7 +218,7 @@ export class AccountAddress extends Serializable implements TransactionArgument
 
   /**
    * NOTE: This function has strict parsing behavior. For relaxed behavior, please use
-   * the `fromStringRelaxed` function.
+   * the `fromString` function.
    *
    * Creates an instance of AccountAddress from a hex string.
    *
@@ -243,20 +243,20 @@ export class AccountAddress extends Serializable implements TransactionArgument
    *
    * @returns An instance of AccountAddress.
    */
-  static fromString(input: string): AccountAddress {
+  static fromStringStrict(input: string): AccountAddress {
     // Assert the string starts with 0x.
     if (!input.startsWith("0x")) {
       throw new ParsingError("Hex string must start with a leading 0x.", AddressInvalidReason.LEADING_ZERO_X_REQUIRED);
     }
 
-    const address = AccountAddress.fromStringRelaxed(input);
+    const address = AccountAddress.fromString(input);
 
     // Check if the address is in LONG form. If it is not, this is only allowed for
     // special addresses, in which case we check it is in proper SHORT form.
     if (input.length !== AccountAddress.LONG_STRING_LENGTH + 2) {
       if (!address.isSpecial()) {
         throw new ParsingError(
-          `The given hex string ${address} is not a special address, it must be represented as 0x + 64 chars.`,
+          `The given hex string ${input} is not a special address, it must be represented as 0x + 64 chars.`,
           AddressInvalidReason.LONG_FORM_REQUIRED_UNLESS_SPECIAL,
         );
       } else if (input.length !== 3) {
@@ -274,8 +274,8 @@ export class AccountAddress extends Serializable implements TransactionArgument
 
   /**
    * NOTE: This function has relaxed parsing behavior. For strict behavior, please use
-   * the `fromString` function. Where possible use `fromString` rather than this
-   * function, `fromStringRelaxed` is only provided for backwards compatibility.
+   * the `fromStringStrict` function. Where possible use `fromStringStrict` rather than this
+   * function, `fromString` is only provided for backwards compatibility.
    *
    * Creates an instance of AccountAddress from a hex string.
    *
@@ -297,7 +297,7 @@ export class AccountAddress extends Serializable implements TransactionArgument
    *
    * @returns An instance of AccountAddress.
    */
-  static fromStringRelaxed(input: string): AccountAddress {
+  static fromString(input: string): AccountAddress {
     let parsedInput = input;
     // Remove leading 0x for parsing.
     if (input.startsWith("0x")) {
@@ -326,11 +326,10 @@ export class AccountAddress extends Serializable implements TransactionArgument
       // the hex string to bytes. Every two characters in a hex string constitutes a
       // single byte. So a 64 length hex string becomes a 32 byte array.
       addressBytes = hexToBytes(parsedInput.padStart(64, "0"));
-    } catch (e) {
-      const error = e as Error;
+    } catch (error: any) {
       // At this point the only way this can fail is if the hex string contains
       // invalid characters.
-      throw new ParsingError(`Hex characters are invalid: ${error.message}`, AddressInvalidReason.INVALID_HEX_CHARS);
+      throw new ParsingError(`Hex characters are invalid: ${error?.message}`, AddressInvalidReason.INVALID_HEX_CHARS);
     }
 
     return new AccountAddress(addressBytes);
@@ -342,14 +341,14 @@ export class AccountAddress extends Serializable implements TransactionArgument
    * This handles, Uint8array, string, and AccountAddress itself
    * @param input
    */
-  static fromRelaxed(input: AccountAddressInput): AccountAddress {
+  static from(input: AccountAddressInput): AccountAddress {
     if (input instanceof AccountAddress) {
       return input;
     }
     if (input instanceof Uint8Array) {
       return new AccountAddress(input);
     }
-    return AccountAddress.fromStringRelaxed(input);
+    return AccountAddress.fromString(input);
   }
 
   /**
@@ -358,14 +357,14 @@ export class AccountAddress extends Serializable implements TransactionArgument
    * This handles, Uint8array, string, and AccountAddress itself
    * @param input
    */
-  static from(input: AccountAddressInput): AccountAddress {
+  static fromStrict(input: AccountAddressInput): AccountAddress {
     if (input instanceof AccountAddress) {
       return input;
     }
     if (input instanceof Uint8Array) {
       return new AccountAddress(input);
     }
-    return AccountAddress.fromString(input);
+    return AccountAddress.fromStringStrict(input);
   }
 
   // ===
@@ -376,25 +375,24 @@ export class AccountAddress extends Serializable implements TransactionArgument
    * Check if the string is a valid AccountAddress.
    *
    * @param args.input A hex string representing an account address.
-   * @param args.relaxed If true, use relaxed parsing behavior. If false, use strict parsing behavior.
+   * @param args.strict If true, use strict parsing behavior. If false, use relaxed parsing behavior.
    *
    * @returns valid = true if the string is valid, valid = false if not. If the string
    * is not valid, invalidReason will be set explaining why it is invalid.
    */
-  static isValid(args: { input: AccountAddressInput; relaxed?: boolean }): ParsingResult<AddressInvalidReason> {
+  static isValid(args: { input: AccountAddressInput; strict?: boolean }): ParsingResult<AddressInvalidReason> {
     try {
-      if (args.relaxed) {
-        AccountAddress.fromRelaxed(args.input);
+      if (args.strict) {
+        AccountAddress.fromStrict(args.input);
       } else {
         AccountAddress.from(args.input);
       }
       return { valid: true };
-    } catch (e) {
-      const error = e as ParsingError<AddressInvalidReason>;
+    } catch (error: any) {
       return {
         valid: false,
-        invalidReason: error.invalidReason,
-        invalidReasonMessage: error.message,
+        invalidReason: error?.invalidReason,
+        invalidReasonMessage: error?.message,
       };
     }
   }

package/src/core/crypto/anyPublicKey.ts

@@ -77,4 +77,16 @@ export class AnyPublicKey extends PublicKey {
         throw new Error(`Unknown variant index for AnyPublicKey: ${index}`);
     }
   }
+
+  static isPublicKey(publicKey: PublicKey): publicKey is AnyPublicKey {
+    return publicKey instanceof AnyPublicKey;
+  }
+
+  isEd25519(): this is Ed25519PublicKey {
+    return this.publicKey instanceof Ed25519PublicKey;
+  }
+
+  isSecp256k1PublicKey(): this is Secp256k1PublicKey {
+    return this.publicKey instanceof Secp256k1PublicKey;
+  }
 }

package/src/core/crypto/ed25519.ts

@@ -88,6 +88,11 @@ export class Ed25519PublicKey extends PublicKey {
     const bytes = deserializer.deserializeBytes();
     return new Ed25519PublicKey(bytes);
   }
+
+  // TODO(greg): Currently, we can't put this on the abstract type, because of a circular dependency
+  static isPublicKey(publicKey: PublicKey): publicKey is Ed25519PublicKey {
+    return publicKey instanceof Ed25519PublicKey;
+  }
 }
 
 /**
@@ -226,6 +231,10 @@ export class Ed25519PrivateKey extends PrivateKey {
     });
     return new Ed25519PrivateKey(privateKey);
   }
+
+  static isPrivateKey(privateKey: PrivateKey): privateKey is Ed25519PrivateKey {
+    return privateKey instanceof Ed25519PrivateKey;
+  }
 }
 
 /**
@@ -284,4 +293,8 @@ export class Ed25519Signature extends Signature {
     const bytes = deserializer.deserializeBytes();
     return new Ed25519Signature(bytes);
   }
+
+  static isSignature(signature: Signature): signature is Ed25519Signature {
+    return signature instanceof Ed25519Signature;
+  }
 }

package/src/core/crypto/index.ts

@@ -7,3 +7,5 @@ export * from "./multiEd25519";
 export * from "./secp256k1";
 export * from "./multiKey";
 export * from "./hdKey";
+export * from "./anyPublicKey";
+export * from "./anySignature";

package/src/core/crypto/secp256k1.ts

@@ -83,6 +83,10 @@ export class Secp256k1PublicKey extends PublicKey {
     const bytes = deserializer.deserializeBytes();
     return new Secp256k1PublicKey(bytes);
   }
+
+  static isPublicKey(publicKey: PublicKey): publicKey is Secp256k1PublicKey {
+    return publicKey instanceof Secp256k1PublicKey;
+  }
 }
 
 /**
@@ -209,6 +213,10 @@ export class Secp256k1PrivateKey extends PrivateKey {
 
     return new Secp256k1PrivateKey(privateKey);
   }
+
+  static isPrivateKey(privateKey: PrivateKey): privateKey is Secp256k1PrivateKey {
+    return privateKey instanceof Secp256k1PrivateKey;
+  }
 }
 
 /**
@@ -272,4 +280,8 @@ export class Secp256k1Signature extends Signature {
     const bytes = deserializer.deserializeBytes();
     return new Secp256k1Signature(bytes);
   }
+
+  static isSignature(signature: Signature): signature is Secp256k1Signature {
+    return signature instanceof Secp256k1Signature;
+  }
 }

package/src/core/hex.ts

@@ -115,10 +115,9 @@ export class Hex {
 
     try {
       return new Hex(hexToBytes(input));
-    } catch (e) {
-      const error = e as Error;
+    } catch (error: any) {
       throw new ParsingError(
-        `Hex string contains invalid hex characters: ${error.message}`,
+        `Hex string contains invalid hex characters: ${error?.message}`,
         HexInvalidReason.INVALID_HEX_CHARS,
       );
     }
@@ -153,12 +152,11 @@ export class Hex {
     try {
       Hex.fromString(str);
       return { valid: true };
-    } catch (e) {
-      const error = e as ParsingError<HexInvalidReason>;
+    } catch (error: any) {
       return {
         valid: false,
-        invalidReason: error.invalidReason,
-        invalidReasonMessage: error.message,
+        invalidReason: error?.invalidReason,
+        invalidReasonMessage: error?.message,
       };
     }
   }

package/src/index.ts

@@ -6,5 +6,6 @@ export * from "./bcs";
 export * from "./client";
 export * from "./core";
 export * from "./transactions";
+export * from "./transactions/management";
 export * from "./types";
 export * from "./utils";

package/src/internal/account.ts

@@ -21,15 +21,16 @@ import {
   GetAccountOwnedObjectsResponse,
   GetAccountOwnedTokensFromCollectionResponse,
   GetAccountOwnedTokensQueryResponse,
-  LedgerVersion,
+  LedgerVersionArg,
   MoveModuleBytecode,
   MoveResource,
   MoveStructId,
-  OrderBy,
+  OrderByArg,
   PaginationArgs,
   SigningScheme,
-  TokenStandard,
+  TokenStandardArg,
   TransactionResponse,
+  WhereArg,
 } from "../types";
 import {
   GetAccountCoinsCountQuery,
@@ -54,6 +55,7 @@ import {
 import { memoizeAsync } from "../utils/memoize";
 import { Secp256k1PrivateKey, AuthenticationKey, Ed25519PrivateKey } from "../core";
 import { AnyPublicKey } from "../core/crypto/anyPublicKey";
+import { CurrentFungibleAssetBalancesBoolExp } from "../types/generated/types";
 
 export async function getInfo(args: {
   aptosConfig: AptosConfig;
@@ -71,7 +73,7 @@ export async function getInfo(args: {
 export async function getModules(args: {
   aptosConfig: AptosConfig;
   accountAddress: AccountAddressInput;
-  options?: PaginationArgs & LedgerVersion;
+  options?: PaginationArgs & LedgerVersionArg;
 }): Promise<MoveModuleBytecode[]> {
   const { aptosConfig, accountAddress, options } = args;
   return paginateWithCursor<{}, MoveModuleBytecode[]>({
@@ -98,7 +100,7 @@ export async function getModule(args: {
   aptosConfig: AptosConfig;
   accountAddress: AccountAddressInput;
   moduleName: string;
-  options?: LedgerVersion;
+  options?: LedgerVersionArg;
 }): Promise<MoveModuleBytecode> {
   // We don't memoize the account module by ledger version, as it's not a common use case, this would be handled
   // by the developer directly
@@ -117,7 +119,7 @@ async function getModuleInner(args: {
   aptosConfig: AptosConfig;
   accountAddress: AccountAddressInput;
   moduleName: string;
-  options?: LedgerVersion;
+  options?: LedgerVersionArg;
 }): Promise<MoveModuleBytecode> {
   const { aptosConfig, accountAddress, moduleName, options } = args;
 
@@ -147,7 +149,7 @@ export async function getTransactions(args: {
 export async function getResources(args: {
   aptosConfig: AptosConfig;
   accountAddress: AccountAddressInput;
-  options?: PaginationArgs & LedgerVersion;
+  options?: PaginationArgs & LedgerVersionArg;
 }): Promise<MoveResource[]> {
   const { aptosConfig, accountAddress, options } = args;
   return paginateWithCursor<{}, MoveResource[]>({
@@ -166,7 +168,7 @@ export async function getResource<T extends {}>(args: {
   aptosConfig: AptosConfig;
   accountAddress: AccountAddressInput;
   resourceType: MoveStructId;
-  options?: LedgerVersion;
+  options?: LedgerVersionArg;
 }): Promise<T> {
   const { aptosConfig, accountAddress, resourceType, options } = args;
   const { data } = await getAptosFullNode<{}, MoveResource>({
@@ -181,7 +183,7 @@ export async function getResource<T extends {}>(args: {
 export async function lookupOriginalAccountAddress(args: {
   aptosConfig: AptosConfig;
   authenticationKey: AccountAddressInput;
-  options?: LedgerVersion;
+  options?: LedgerVersionArg;
 }): Promise<AccountAddress> {
   const { aptosConfig, authenticationKey, options } = args;
   type OriginatingAddress = {
@@ -247,20 +249,18 @@ export async function getAccountTokensCount(args: {
     query: graphqlQuery,
     originMethod: "getAccountTokensCount",
   });
-  if (!data.current_token_ownerships_v2_aggregate.aggregate) {
-    throw Error("Failed to get the count of account tokens");
-  }
-  return data.current_token_ownerships_v2_aggregate.aggregate.count;
+
+  // commonjs (aka cjs) doesnt handle Nullish Coalescing for some reason
+  // might be because of how ts infer the graphql generated scheme type
+  return data.current_token_ownerships_v2_aggregate.aggregate
+    ? data.current_token_ownerships_v2_aggregate.aggregate.count
+    : 0;
 }
 
 export async function getAccountOwnedTokens(args: {
   aptosConfig: AptosConfig;
   accountAddress: AccountAddressInput;
-  options?: {
-    tokenStandard?: TokenStandard;
-    pagination?: PaginationArgs;
-    orderBy?: OrderBy<GetAccountOwnedTokensQueryResponse[0]>;
-  };
+  options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensQueryResponse[0]>;
 }): Promise<GetAccountOwnedTokensQueryResponse> {
   const { aptosConfig, accountAddress, options } = args;
   const address = AccountAddress.from(accountAddress).toStringLong();
@@ -279,8 +279,8 @@ export async function getAccountOwnedTokens(args: {
     query: GetAccountOwnedTokens,
     variables: {
       where_condition: whereCondition,
-      offset: options?.pagination?.offset,
-      limit: options?.pagination?.limit,
+      offset: options?.offset,
+      limit: options?.limit,
       order_by: options?.orderBy,
     },
   };
@@ -298,11 +298,7 @@ export async function getAccountOwnedTokensFromCollectionAddress(args: {
   aptosConfig: AptosConfig;
   accountAddress: AccountAddressInput;
   collectionAddress: AccountAddressInput;
-  options?: {
-    tokenStandard?: TokenStandard;
-    pagination?: PaginationArgs;
-    orderBy?: OrderBy<GetAccountOwnedTokensFromCollectionResponse[0]>;
-  };
+  options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensFromCollectionResponse[0]>;
 }): Promise<GetAccountOwnedTokensFromCollectionResponse> {
   const { aptosConfig, accountAddress, collectionAddress, options } = args;
   const ownerAddress = AccountAddress.from(accountAddress).toStringLong();
@@ -327,8 +323,8 @@ export async function getAccountOwnedTokensFromCollectionAddress(args: {
     query: GetAccountOwnedTokensFromCollection,
     variables: {
       where_condition: whereCondition,
-      offset: options?.pagination?.offset,
-      limit: options?.pagination?.limit,
+      offset: options?.offset,
+      limit: options?.limit,
       order_by: options?.orderBy,
     },
   };
@@ -345,11 +341,7 @@ export async function getAccountOwnedTokensFromCollectionAddress(args: {
 export async function getAccountCollectionsWithOwnedTokens(args: {
   aptosConfig: AptosConfig;
   accountAddress: AccountAddressInput;
-  options?: {
-    tokenStandard?: TokenStandard;
-    pagination?: PaginationArgs;
-    orderBy?: OrderBy<GetAccountCollectionsWithOwnedTokenResponse[0]>;
-  };
+  options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountCollectionsWithOwnedTokenResponse[0]>;
 }): Promise<GetAccountCollectionsWithOwnedTokenResponse> {
   const { aptosConfig, accountAddress, options } = args;
   const address = AccountAddress.from(accountAddress).toStringLong();
@@ -373,8 +365,8 @@ export async function getAccountCollectionsWithOwnedTokens(args: {
     query: GetAccountCollectionsWithOwnedTokens,
     variables: {
       where_condition: whereCondition,
-      offset: options?.pagination?.offset,
-      limit: options?.pagination?.limit,
+      offset: options?.offset,
+      limit: options?.limit,
       order_by: options?.orderBy,
     },
   };
@@ -407,25 +399,42 @@ export async function getAccountTransactionsCount(args: {
     originMethod: "getAccountTransactionsCount",
   });
 
-  if (!data.account_transactions_aggregate.aggregate) {
-    throw Error("Failed to get the count of account transactions");
-  }
+  // commonjs (aka cjs) doesnt handle Nullish Coalescing for some reason
+  // might be because of how ts infer the graphql generated scheme type
+  return data.account_transactions_aggregate.aggregate ? data.account_transactions_aggregate.aggregate.count : 0;
+}
+
+export async function getAccountCoinAmount(args: {
+  aptosConfig: AptosConfig;
+  accountAddress: AccountAddressInput;
+  coinType: MoveStructId;
+}): Promise<number> {
+  const { aptosConfig, accountAddress, coinType } = args;
+  const address = AccountAddress.from(accountAddress).toStringLong();
 
-  return data.account_transactions_aggregate.aggregate.count;
+  const data = await getAccountCoinsData({
+    aptosConfig,
+    accountAddress: address,
+    options: {
+      where: { asset_type: { _eq: coinType } },
+    },
+  });
+
+  // commonjs (aka cjs) doesnt handle Nullish Coalescing for some reason
+  // might be because of how ts infer the graphql generated scheme type
+  return data[0] ? data[0].amount : 0;
 }
 
 export async function getAccountCoinsData(args: {
   aptosConfig: AptosConfig;
   accountAddress: AccountAddressInput;
-  options?: {
-    pagination?: PaginationArgs;
-    orderBy?: OrderBy<GetAccountCoinsDataResponse[0]>;
-  };
+  options?: PaginationArgs & OrderByArg<GetAccountCoinsDataResponse[0]> & WhereArg<CurrentFungibleAssetBalancesBoolExp>;
 }): Promise<GetAccountCoinsDataResponse> {
   const { aptosConfig, accountAddress, options } = args;
   const address = AccountAddress.from(accountAddress).toStringLong();
 
   const whereCondition: { owner_address: { _eq: string } } = {
+    ...options?.where,
     owner_address: { _eq: address },
   };
 
@@ -433,8 +442,8 @@ export async function getAccountCoinsData(args: {
     query: GetAccountCoinsData,
     variables: {
       where_condition: whereCondition,
-      offset: options?.pagination?.offset,
-      limit: options?.pagination?.limit,
+      offset: options?.offset,
+      limit: options?.limit,
       order_by: options?.orderBy,
     },
   };
@@ -476,10 +485,7 @@ export async function getAccountCoinsCount(args: {
 export async function getAccountOwnedObjects(args: {
   aptosConfig: AptosConfig;
   accountAddress: AccountAddressInput;
-  options?: {
-    pagination?: PaginationArgs;
-    orderBy?: OrderBy<GetAccountOwnedObjectsResponse[0]>;
-  };
+  options?: PaginationArgs & OrderByArg<GetAccountOwnedObjectsResponse[0]>;
 }): Promise<GetAccountOwnedObjectsResponse> {
   const { aptosConfig, accountAddress, options } = args;
   const address = AccountAddress.from(accountAddress).toStringLong();
@@ -491,8 +497,8 @@ export async function getAccountOwnedObjects(args: {
     query: GetAccountOwnedObjects,
     variables: {
       where_condition: whereCondition,
-      offset: options?.pagination?.offset,
-      limit: options?.pagination?.limit,
+      offset: options?.offset,
+      limit: options?.limit,
       order_by: options?.orderBy,
     },
   };