@aptos-labs/ts-sdk 1.22.2 → 1.24.0

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/transactions/transactionBuilder/transactionBuilder.ts

@@ -9,14 +9,7 @@
 import { sha3_256 as sha3Hash } from "@noble/hashes/sha3";
 import { AptosConfig } from "../../api/aptosConfig";
 import { AccountAddress, AccountAddressInput, Hex, PublicKey } from "../../core";
-import {
-  AnyPublicKey,
-  AnySignature,
-  KeylessPublicKey,
-  KeylessSignature,
-  Secp256k1PublicKey,
-  Secp256k1Signature,
-} from "../../core/crypto";
+import { AnyPublicKey, AnySignature, KeylessPublicKey, Secp256k1PublicKey } from "../../core/crypto";
 import { Ed25519PublicKey, Ed25519Signature } from "../../core/crypto/ed25519";
 import { getInfo } from "../../internal/account";
 import { getLedgerInfo } from "../../internal/general";
@@ -452,29 +445,26 @@ export function generateSignedTransactionForSimulation(args: InputSimulateTransa
 }
 
 export function getAuthenticatorForSimulation(publicKey: PublicKey) {
-  if (publicKey instanceof KeylessPublicKey || publicKey instanceof Secp256k1PublicKey) {
-    // eslint-disable-next-line no-param-reassign
-    publicKey = new AnyPublicKey(publicKey);
+  // No need to for the signature to be matching in scheme. All that matters for simulations is that it's not valid
+  const invalidSignature = new Ed25519Signature(new Uint8Array(64));
+
+  if (Ed25519PublicKey.isInstance(publicKey)) {
+    return new AccountAuthenticatorEd25519(publicKey, invalidSignature);
   }
 
-  // TODO add support for AnyMultiKey
-  if (publicKey instanceof AnyPublicKey) {
-    if (publicKey.publicKey instanceof Ed25519PublicKey) {
-      return new AccountAuthenticatorSingleKey(publicKey, new AnySignature(new Ed25519Signature(new Uint8Array(64))));
-    }
-    if (publicKey.publicKey instanceof Secp256k1PublicKey) {
-      return new AccountAuthenticatorSingleKey(publicKey, new AnySignature(new Secp256k1Signature(new Uint8Array(64))));
-    }
-    if (publicKey.publicKey instanceof KeylessPublicKey) {
-      return new AccountAuthenticatorSingleKey(publicKey, new AnySignature(KeylessSignature.getSimulationSignature()));
-    }
+  if (AnyPublicKey.isInstance(publicKey)) {
+    return new AccountAuthenticatorSingleKey(publicKey, new AnySignature(invalidSignature));
   }
 
-  // legacy code
-  return new AccountAuthenticatorEd25519(
-    new Ed25519PublicKey(publicKey.toUint8Array()),
-    new Ed25519Signature(new Uint8Array(64)),
-  );
+  // TODO: remove this, non-account public keys should never make it here
+  if (KeylessPublicKey.isInstance(publicKey) || Secp256k1PublicKey.isInstance(publicKey)) {
+    // eslint-disable-next-line no-console
+    console.warn("Expected AccountPublicKey, but got PublicKey. Please wrap your public key with AnyPublicKey.");
+    return new AccountAuthenticatorSingleKey(new AnyPublicKey(publicKey), new AnySignature(invalidSignature));
+  }
+
+  // TODO add support for AnyMultiKey
+  throw new Error("Unsupported public key");
 }
 
 /**

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 = `