@aptos-labs/ts-sdk 0.0.2 → 0.0.4

package/src/internal/account.ts

@@ -10,10 +10,9 @@
 
 import { AptosConfig } from "../api/aptosConfig";
 import { AptosApiError, getAptosFullNode, paginateWithCursor } from "../client";
-import { AccountAddress } from "../core/accountAddress";
+import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
 import { Account } from "../core/account";
 import { PrivateKey } from "../core/crypto/asymmetricCrypto";
-import { Hex } from "../core/hex";
 import { getTableItem, queryIndexer } from "./general";
 import {
   AccountData,
@@ -22,11 +21,10 @@ import {
   GetAccountOwnedObjectsResponse,
   GetAccountOwnedTokensFromCollectionResponse,
   GetAccountOwnedTokensQueryResponse,
-  HexInput,
   LedgerVersion,
   MoveModuleBytecode,
   MoveResource,
-  MoveResourceType,
+  MoveStructType,
   OrderBy,
   PaginationArgs,
   SigningScheme,
@@ -57,26 +55,29 @@ import { memoizeAsync } from "../utils/memoize";
 import { Secp256k1PrivateKey, AuthenticationKey, Ed25519PrivateKey } from "../core";
 import { AnyPublicKey } from "../core/crypto/anyPublicKey";
 
-export async function getInfo(args: { aptosConfig: AptosConfig; accountAddress: HexInput }): Promise<AccountData> {
+export async function getInfo(args: {
+  aptosConfig: AptosConfig;
+  accountAddress: AccountAddressInput;
+}): Promise<AccountData> {
   const { aptosConfig, accountAddress } = args;
   const { data } = await getAptosFullNode<{}, AccountData>({
     aptosConfig,
     originMethod: "getInfo",
-    path: `accounts/${AccountAddress.fromHexInput(accountAddress).toString()}`,
+    path: `accounts/${AccountAddress.from(accountAddress).toString()}`,
   });
   return data;
 }
 
 export async function getModules(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
   options?: PaginationArgs & LedgerVersion;
 }): Promise<MoveModuleBytecode[]> {
   const { aptosConfig, accountAddress, options } = args;
   return paginateWithCursor<{}, MoveModuleBytecode[]>({
     aptosConfig,
     originMethod: "getModules",
-    path: `accounts/${AccountAddress.fromHexInput(accountAddress).toString()}/modules`,
+    path: `accounts/${AccountAddress.from(accountAddress).toString()}/modules`,
     params: {
       ledger_version: options?.ledgerVersion,
       start: options?.offset,
@@ -95,7 +96,7 @@ export async function getModules(args: {
  */
 export async function getModule(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
   moduleName: string;
   options?: LedgerVersion;
 }): Promise<MoveModuleBytecode> {
@@ -114,7 +115,7 @@ export async function getModule(args: {
 
 async function getModuleInner(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
   moduleName: string;
   options?: LedgerVersion;
 }): Promise<MoveModuleBytecode> {
@@ -123,7 +124,7 @@ async function getModuleInner(args: {
   const { data } = await getAptosFullNode<{}, MoveModuleBytecode>({
     aptosConfig,
     originMethod: "getModule",
-    path: `accounts/${AccountAddress.fromHexInput(accountAddress).toString()}/module/${moduleName}`,
+    path: `accounts/${AccountAddress.from(accountAddress).toString()}/module/${moduleName}`,
     params: { ledger_version: options?.ledgerVersion },
   });
   return data;
@@ -131,28 +132,28 @@ async function getModuleInner(args: {
 
 export async function getTransactions(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
   options?: PaginationArgs;
 }): Promise<TransactionResponse[]> {
   const { aptosConfig, accountAddress, options } = args;
   return paginateWithCursor<{}, TransactionResponse[]>({
     aptosConfig,
     originMethod: "getTransactions",
-    path: `accounts/${AccountAddress.fromHexInput(accountAddress).toString()}/transactions`,
+    path: `accounts/${AccountAddress.from(accountAddress).toString()}/transactions`,
     params: { start: options?.offset, limit: options?.limit },
   });
 }
 
 export async function getResources(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
   options?: PaginationArgs & LedgerVersion;
 }): Promise<MoveResource[]> {
   const { aptosConfig, accountAddress, options } = args;
   return paginateWithCursor<{}, MoveResource[]>({
     aptosConfig,
     originMethod: "getResources",
-    path: `accounts/${AccountAddress.fromHexInput(accountAddress).toString()}/resources`,
+    path: `accounts/${AccountAddress.from(accountAddress).toString()}/resources`,
     params: {
       ledger_version: options?.ledgerVersion,
       start: options?.offset,
@@ -163,15 +164,15 @@ export async function getResources(args: {
 
 export async function getResource<T extends {}>(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
-  resourceType: MoveResourceType;
+  accountAddress: AccountAddressInput;
+  resourceType: MoveStructType;
   options?: LedgerVersion;
 }): Promise<T> {
   const { aptosConfig, accountAddress, resourceType, options } = args;
   const { data } = await getAptosFullNode<{}, MoveResource>({
     aptosConfig,
     originMethod: "getResource",
-    path: `accounts/${AccountAddress.fromHexInput(accountAddress).toString()}/resource/${resourceType}`,
+    path: `accounts/${AccountAddress.from(accountAddress).toString()}/resource/${resourceType}`,
     params: { ledger_version: options?.ledgerVersion },
   });
   return data.data as T;
@@ -179,7 +180,7 @@ export async function getResource<T extends {}>(args: {
 
 export async function lookupOriginalAccountAddress(args: {
   aptosConfig: AptosConfig;
-  authenticationKey: HexInput;
+  authenticationKey: AccountAddressInput;
   options?: LedgerVersion;
 }): Promise<AccountAddress> {
   const { aptosConfig, authenticationKey, options } = args;
@@ -197,24 +198,26 @@ export async function lookupOriginalAccountAddress(args: {
     address_map: { handle },
   } = resource;
 
+  const authKeyAddress = AccountAddress.from(authenticationKey);
+
   // If the address is not found in the address map, which means its not rotated
   // then return the address as is
   try {
-    const originalAddress = await getTableItem({
+    const originalAddress = await getTableItem<string>({
       aptosConfig,
       handle,
       data: {
-        key: Hex.fromHexInput(authenticationKey).toString(),
+        key: authKeyAddress.toString(),
         key_type: "address",
         value_type: "address",
       },
       options,
     });
 
-    return AccountAddress.fromHexInput(originalAddress);
+    return AccountAddress.from(originalAddress);
   } catch (err) {
     if (err instanceof AptosApiError && err.data.error_code === "table_item_not_found") {
-      return AccountAddress.fromHexInput(authenticationKey);
+      return authKeyAddress;
     }
 
     throw err;
@@ -223,15 +226,15 @@ export async function lookupOriginalAccountAddress(args: {
 
 export async function getAccountTokensCount(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
 }): Promise<number> {
   const { aptosConfig, accountAddress } = args;
 
-  const address = AccountAddress.fromHexInput(accountAddress).toString();
+  const address = AccountAddress.from(accountAddress).toStringLong();
 
-  const whereCondition: any = {
+  const whereCondition: { owner_address: { _eq: string }; amount: { _gt: number } } = {
     owner_address: { _eq: address },
-    amount: { _gt: "0" },
+    amount: { _gt: 0 },
   };
 
   const graphqlQuery = {
@@ -252,7 +255,7 @@ export async function getAccountTokensCount(args: {
 
 export async function getAccountOwnedTokens(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
   options?: {
     tokenStandard?: TokenStandard;
     pagination?: PaginationArgs;
@@ -260,12 +263,13 @@ export async function getAccountOwnedTokens(args: {
   };
 }): Promise<GetAccountOwnedTokensQueryResponse> {
   const { aptosConfig, accountAddress, options } = args;
-  const address = AccountAddress.fromHexInput(accountAddress).toString();
+  const address = AccountAddress.from(accountAddress).toStringLong();
 
-  const whereCondition: any = {
-    owner_address: { _eq: address },
-    amount: { _gt: 0 },
-  };
+  const whereCondition: { owner_address: { _eq: string }; amount: { _gt: number }; token_standard?: { _eq: string } } =
+    {
+      owner_address: { _eq: address },
+      amount: { _gt: 0 },
+    };
 
   if (options?.tokenStandard) {
     whereCondition.token_standard = { _eq: options?.tokenStandard };
@@ -292,8 +296,8 @@ export async function getAccountOwnedTokens(args: {
 
 export async function getAccountOwnedTokensFromCollectionAddress(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
-  collectionAddress: HexInput;
+  accountAddress: AccountAddressInput;
+  collectionAddress: AccountAddressInput;
   options?: {
     tokenStandard?: TokenStandard;
     pagination?: PaginationArgs;
@@ -301,10 +305,15 @@ export async function getAccountOwnedTokensFromCollectionAddress(args: {
   };
 }): Promise<GetAccountOwnedTokensFromCollectionResponse> {
   const { aptosConfig, accountAddress, collectionAddress, options } = args;
-  const ownerAddress = AccountAddress.fromHexInput(accountAddress).toString();
-  const collAddress = Hex.fromHexInput(collectionAddress).toString();
-
-  const whereCondition: any = {
+  const ownerAddress = AccountAddress.from(accountAddress).toStringLong();
+  const collAddress = AccountAddress.from(collectionAddress).toStringLong();
+
+  const whereCondition: {
+    owner_address: { _eq: string };
+    current_token_data: { collection_id: { _eq: string } };
+    amount: { _gt: number };
+    token_standard?: { _eq: string };
+  } = {
     owner_address: { _eq: ownerAddress },
     current_token_data: { collection_id: { _eq: collAddress } },
     amount: { _gt: 0 },
@@ -335,7 +344,7 @@ export async function getAccountOwnedTokensFromCollectionAddress(args: {
 
 export async function getAccountCollectionsWithOwnedTokens(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
   options?: {
     tokenStandard?: TokenStandard;
     pagination?: PaginationArgs;
@@ -343,9 +352,13 @@ export async function getAccountCollectionsWithOwnedTokens(args: {
   };
 }): Promise<GetAccountCollectionsWithOwnedTokenResponse> {
   const { aptosConfig, accountAddress, options } = args;
-  const address = AccountAddress.fromHexInput(accountAddress).toString();
+  const address = AccountAddress.from(accountAddress).toStringLong();
 
-  const whereCondition: any = {
+  const whereCondition: {
+    owner_address: { _eq: string };
+    amount: { _gt: number };
+    current_collection?: { token_standard: { _eq: string } };
+  } = {
     owner_address: { _eq: address },
     amount: { _gt: 0 },
   };
@@ -377,11 +390,11 @@ export async function getAccountCollectionsWithOwnedTokens(args: {
 
 export async function getAccountTransactionsCount(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
 }): Promise<number> {
   const { aptosConfig, accountAddress } = args;
 
-  const address = AccountAddress.fromHexInput(accountAddress).toString();
+  const address = AccountAddress.from(accountAddress).toStringLong();
 
   const graphqlQuery = {
     query: GetAccountTransactionsCount,
@@ -403,16 +416,16 @@ export async function getAccountTransactionsCount(args: {
 
 export async function getAccountCoinsData(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
   options?: {
     pagination?: PaginationArgs;
     orderBy?: OrderBy<GetAccountCoinsDataResponse[0]>;
   };
 }): Promise<GetAccountCoinsDataResponse> {
   const { aptosConfig, accountAddress, options } = args;
-  const address = AccountAddress.fromHexInput(accountAddress).toString();
+  const address = AccountAddress.from(accountAddress).toStringLong();
 
-  const whereCondition: any = {
+  const whereCondition: { owner_address: { _eq: string } } = {
     owner_address: { _eq: address },
   };
 
@@ -437,10 +450,10 @@ export async function getAccountCoinsData(args: {
 
 export async function getAccountCoinsCount(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
 }): Promise<number> {
   const { aptosConfig, accountAddress } = args;
-  const address = AccountAddress.fromHexInput(accountAddress).toString();
+  const address = AccountAddress.from(accountAddress).toStringLong();
 
   const graphqlQuery = {
     query: GetAccountCoinsCount,
@@ -462,16 +475,16 @@ export async function getAccountCoinsCount(args: {
 
 export async function getAccountOwnedObjects(args: {
   aptosConfig: AptosConfig;
-  accountAddress: HexInput;
+  accountAddress: AccountAddressInput;
   options?: {
     pagination?: PaginationArgs;
     orderBy?: OrderBy<GetAccountOwnedObjectsResponse[0]>;
   };
 }): Promise<GetAccountOwnedObjectsResponse> {
   const { aptosConfig, accountAddress, options } = args;
-  const address = AccountAddress.fromHexInput(accountAddress).toString();
+  const address = AccountAddress.from(accountAddress).toStringLong();
 
-  const whereCondition: any = {
+  const whereCondition: { owner_address: { _eq: string } } = {
     owner_address: { _eq: address },
   };
   const graphqlQuery = {
@@ -492,6 +505,15 @@ export async function getAccountOwnedObjects(args: {
   return data.current_objects;
 }
 
+/**
+ * NOTE: There is a potential issue once unified single signer scheme will be adopted
+ * by the community.
+ *
+ * Becuase on could create 2 accounts with the same private key with this new authenticator type,
+ * we’ll need to determine the order in which we lookup the accounts. First unified
+ * scheme and then legacy scheme vs first legacy scheme and then unified scheme.
+ *
+ */
 export async function deriveAccountFromPrivateKey(args: {
   aptosConfig: AptosConfig;
   privateKey: PrivateKey;
@@ -502,30 +524,30 @@ export async function deriveAccountFromPrivateKey(args: {
   if (privateKey instanceof Secp256k1PrivateKey) {
     // private key is secp256k1, therefore we know it for sure uses a single signer key
     const authKey = AuthenticationKey.fromPublicKeyAndScheme({ publicKey, scheme: SigningScheme.SingleKey });
-    const address = new AccountAddress({ data: authKey.toUint8Array() });
-    return Account.fromPrivateKey({ privateKey, address });
+    const address = authKey.derivedAddress();
+    return Account.fromPrivateKeyAndAddress({ privateKey, address });
   }
 
   if (privateKey instanceof Ed25519PrivateKey) {
     // lookup single sender ed25519
-    const SingleSenderTransactionAuthenticatorAuthKey = AuthenticationKey.fromPublicKeyAndScheme({
+    const singleSenderTransactionAuthenticatorAuthKey = AuthenticationKey.fromPublicKeyAndScheme({
       publicKey,
       scheme: SigningScheme.SingleKey,
     });
     const isSingleSenderTransactionAuthenticator = await isAccountExist({
-      authKey: SingleSenderTransactionAuthenticatorAuthKey,
+      authKey: singleSenderTransactionAuthenticatorAuthKey,
       aptosConfig,
     });
     if (isSingleSenderTransactionAuthenticator) {
-      const address = new AccountAddress({ data: SingleSenderTransactionAuthenticatorAuthKey.toUint8Array() });
-      return Account.fromPrivateKey({ privateKey, address });
+      const address = singleSenderTransactionAuthenticatorAuthKey.derivedAddress();
+      return Account.fromPrivateKeyAndAddress({ privateKey, address, legacy: false });
     }
     // lookup legacy ed25519
     const legacyAuthKey = AuthenticationKey.fromPublicKeyAndScheme({ publicKey, scheme: SigningScheme.Ed25519 });
     const isLegacyEd25519 = await isAccountExist({ authKey: legacyAuthKey, aptosConfig });
     if (isLegacyEd25519) {
-      const address = new AccountAddress({ data: legacyAuthKey.toUint8Array() });
-      return Account.fromPrivateKey({ privateKey, address, legacy: true });
+      const address = legacyAuthKey.derivedAddress();
+      return Account.fromPrivateKeyAndAddress({ privateKey, address, legacy: true });
     }
   }
   // if we are here, it means we couldn't find an address with an
@@ -537,13 +559,13 @@ export async function isAccountExist(args: { aptosConfig: AptosConfig; authKey:
   const { aptosConfig, authKey } = args;
   const accountAddress = await lookupOriginalAccountAddress({
     aptosConfig,
-    authenticationKey: authKey.toString(),
+    authenticationKey: authKey.derivedAddress(),
   });
 
   try {
     await getInfo({
       aptosConfig,
-      accountAddress: accountAddress.toString(),
+      accountAddress,
     });
     return true;
   } catch (error: any) {

package/src/internal/ans.ts

@@ -0,0 +1,177 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * This file contains the underlying implementations for exposed API surface in
+ * the {@link api/name}. By moving the methods out into a separate file,
+ * other namespaces and processes can access these methods without depending on the entire
+ * name namespace and without having a dependency cycle error.
+ */
+
+import { AptosConfig } from "../api/aptosConfig";
+import { MoveOption, MoveString, U64 } from "../bcs";
+import { Account, AccountAddress } from "../core";
+import { InputGenerateTransactionOptions, InputSingleSignerTransaction } from "../transactions/types";
+import { HexInput, MoveAddressType, MoveValue } from "../types";
+import { Network } from "../utils/apiEndpoints";
+import { view } from "./general";
+import { generateTransaction } from "./transactionSubmission";
+
+export const VALIDATION_RULES_DESCRIPTION = [
+  "A name must be between 3 and 63 characters long,",
+  "and can only contain lowercase a-z, 0-9, and hyphens.",
+  "A name may not start or end with a hyphen.",
+].join(" ");
+
+/**
+ *
+ * @param fragment A fragment of a name, either the domain or subdomain
+ * @returns boolean indicating if the fragment is a valid fragment
+ */
+export function isValidANSSegment(fragment: string): boolean {
+  if (!fragment) return false;
+  if (fragment.length < 3) return false;
+  if (fragment.length > 63) return false;
+  // only lowercase a-z and 0-9 are allowed, along with -. a domain may not start or end with a hyphen
+  if (!/^[a-z\d][a-z\d-]{1,61}[a-z\d]$/.test(fragment)) return false;
+  return true;
+}
+
+/**
+ * Checks if an ANS name is valid or not
+ *
+ * @param name A string of the domain name, can include or exclude the .apt suffix
+ */
+export function isValidANSName(name: string): { domainName: string; subdomainName?: string } {
+  const [first, second, ...rest] = name.replace(/\.apt$/, "").split(".");
+
+  if (rest.length > 0) {
+    throw new Error(`${name} is invalid. A name can only have two parts, a domain and a subdomain separated by a "."`);
+  }
+
+  if (!isValidANSSegment(first)) {
+    throw new Error(`${first} is not valid. ${VALIDATION_RULES_DESCRIPTION}`);
+  }
+
+  if (second && !isValidANSSegment(second)) {
+    throw new Error(`${second} is not valid. ${VALIDATION_RULES_DESCRIPTION}`);
+  }
+
+  return {
+    domainName: second || first,
+    subdomainName: second ? first : undefined,
+  };
+}
+
+export const LOCAL_ANS_ACCOUNT_PK =
+  (process.env.ANS_TEST_ACCOUNT_PRIVATE_KEY as string) ||
+  "0x37368b46ce665362562c6d1d4ec01a08c8644c488690df5a17e13ba163e20221";
+export const LOCAL_ANS_ACCOUNT_ADDRESS =
+  (process.env.ANS_TEST_ACCOUNT_ADDRESS as string) ||
+  "0x585fc9f0f0c54183b039ffc770ca282ebd87307916c215a3e692f2f8e4305e82";
+
+const NetworkToAnsContract: Record<Network, string | null> = {
+  [Network.TESTNET]: "0x5f8fd2347449685cf41d4db97926ec3a096eaf381332be4f1318ad4d16a8497c",
+  [Network.MAINNET]: "0x867ed1f6bf916171b1de3ee92849b8978b7d1b9e0a8cc982a3d19d535dfd9c0c",
+  [Network.LOCAL]: LOCAL_ANS_ACCOUNT_ADDRESS,
+  [Network.CUSTOM]: null,
+  [Network.DEVNET]: null,
+};
+
+function getRouterAddress(aptosConfig: AptosConfig): string {
+  const address = NetworkToAnsContract[aptosConfig.network];
+  if (!address) throw new Error(`The ANS contract is not deployed to ${aptosConfig.network}`);
+  return address;
+}
+
+const Some = <T>(value: T): MoveValue => ({ vec: [value] } as any);
+const None = (): MoveValue => ({ vec: [] } as any);
+// != here is intentional, we want to check for null and undefined
+// eslint-disable-next-line eqeqeq
+const Option = <T>(value: T | undefined | null): MoveValue => (value != undefined ? Some(value) : None());
+
+const unwrapOption = <T>(option: any): T | undefined => {
+  if (!!option && typeof option === "object" && "vec" in option && Array.isArray(option.vec)) {
+    return option.vec[0];
+  }
+
+  return undefined;
+};
+
+export async function getOwnerAddress(args: { aptosConfig: AptosConfig; name: string }): Promise<string | undefined> {
+  const { aptosConfig, name } = args;
+  const routerAddress = getRouterAddress(aptosConfig);
+  const { domainName, subdomainName } = isValidANSName(name);
+
+  const res = await view({
+    aptosConfig,
+    payload: {
+      function: `${routerAddress}::router::get_owner_addr`,
+      functionArguments: [domainName, Option(subdomainName)],
+    },
+  });
+
+  const owner = unwrapOption<MoveAddressType>(res[0]);
+
+  return owner ? AccountAddress.fromRelaxed(owner).toString() : undefined;
+}
+
+export interface RegisterNameParameters {
+  aptosConfig: AptosConfig;
+  sender: Account;
+  name: string;
+  expiration:
+    | { policy: "domain"; years: 1 }
+    | { policy: "subdomain:follow-domain" }
+    | { policy: "subdomain:independent"; expirationDate: Date };
+  transferable?: boolean;
+  toAddress?: HexInput;
+  targetAddress?: HexInput;
+  options?: InputGenerateTransactionOptions;
+}
+
+export async function registerName(args: RegisterNameParameters): Promise<InputSingleSignerTransaction> {
+  const { aptosConfig, expiration, name, sender, targetAddress, toAddress, options } = args;
+  const routerAddress = getRouterAddress(aptosConfig);
+  const { domainName, subdomainName } = isValidANSName(name);
+
+  const hasSubdomainPolicy =
+    expiration.policy === "subdomain:independent" || expiration.policy === "subdomain:follow-domain";
+
+  if (subdomainName && !hasSubdomainPolicy) {
+    throw new Error(
+      "Subdomains must have an expiration policy of either 'subdomain:independent' or 'subdomain:follow-domain'",
+    );
+  }
+
+  if (hasSubdomainPolicy && !subdomainName) {
+    throw new Error(`Policy is set to ${expiration.policy} but no subdomain was provided`);
+  }
+
+  if (expiration.policy === "domain") {
+    if (expiration.years !== 1) {
+      throw new Error("For now, names can only be registered for 1 year at a time");
+    }
+
+    const registrationDuration = expiration.years * 31536000;
+
+    const transaction = await generateTransaction({
+      aptosConfig,
+      sender: sender.accountAddress.toString(),
+      data: {
+        function: `${routerAddress}::router::register_domain`,
+        functionArguments: [
+          new MoveString(domainName),
+          new U64(registrationDuration),
+          new MoveOption(targetAddress ? AccountAddress.from(targetAddress) : null),
+          new MoveOption(toAddress ? AccountAddress.from(toAddress) : null),
+        ],
+      },
+      options,
+    });
+
+    return transaction as InputSingleSignerTransaction;
+  }
+
+  throw new Error(`Policy ${expiration.policy} is not supported yet`);
+}

package/src/internal/coin.ts

@@ -1,32 +1,32 @@
 import { AptosConfig } from "../api/aptosConfig";
 import { U64 } from "../bcs/serializable/movePrimitives";
-import { Account, AccountAddress } from "../core";
-import { GenerateTransactionOptions, SingleSignerTransaction } from "../transactions/types";
-import { StructTag, TypeTagStruct } from "../transactions/typeTag/typeTag";
-import { HexInput, AnyNumber, MoveResourceType } from "../types";
+import { Account, AccountAddress, AccountAddressInput } from "../core";
+import { InputGenerateTransactionOptions, InputSingleSignerTransaction } from "../transactions/types";
+import { AnyNumber, MoveStructType } from "../types";
 import { APTOS_COIN } from "../utils/const";
 import { generateTransaction } from "./transactionSubmission";
+import { parseTypeTag } from "../transactions/typeTag/parser";
 
 export async function transferCoinTransaction(args: {
   aptosConfig: AptosConfig;
   sender: Account;
-  recipient: HexInput;
+  recipient: AccountAddressInput;
   amount: AnyNumber;
-  coinType?: MoveResourceType;
-  options?: GenerateTransactionOptions;
-}): Promise<SingleSignerTransaction> {
+  coinType?: MoveStructType;
+  options?: InputGenerateTransactionOptions;
+}): Promise<InputSingleSignerTransaction> {
   const { aptosConfig, sender, recipient, amount, coinType, options } = args;
   const coinStructType = coinType ?? APTOS_COIN;
   const transaction = await generateTransaction({
     aptosConfig,
-    sender: sender.accountAddress.toString(),
+    sender: sender.accountAddress,
     data: {
       function: "0x1::aptos_account::transfer_coins",
-      typeArguments: [new TypeTagStruct(StructTag.fromString(coinStructType))],
-      functionArguments: [AccountAddress.fromHexInput(recipient), new U64(amount)],
+      typeArguments: [parseTypeTag(coinStructType)],
+      functionArguments: [AccountAddress.from(recipient), new U64(amount)],
     },
     options,
   });
 
-  return transaction as SingleSignerTransaction;
+  return transaction as InputSingleSignerTransaction;
 }