@aptos-labs/ts-sdk 1.13.0-zeta.1 → 1.13.1-zeta.1

package/src/account/EphemeralKeyPair.ts

@@ -3,16 +3,22 @@
 
 import { randomBytes } from "@noble/hashes/utils";
 
-
-import { EPK_HORIZON_SECS, Ed25519PrivateKey, EphemeralPublicKey, EphemeralSignature, PrivateKey} from "../core/crypto";
+import {
+  EPK_HORIZON_SECS,
+  Ed25519PrivateKey,
+  EphemeralPublicKey,
+  EphemeralSignature,
+  PrivateKey,
+} from "../core/crypto";
 import { Hex } from "../core/hex";
 import { bytesToBigIntLE, padAndPackBytesWithLen, poseidonHash } from "../core/crypto/poseidon";
-import { HexInput, SigningSchemeInput } from "../types";
+import { EphemeralPublicKeyVariant, HexInput, SigningSchemeInput } from "../types";
+import { Deserializer, Serializable, Serializer } from "../bcs";
 
-export class EphemeralKeyPair {
+export class EphemeralKeyPair extends Serializable{
   readonly blinder: Uint8Array;
 
-  readonly expiryDateSecs: bigint;
+  readonly expiryDateSecs: bigint | number;
 
   readonly nonce: string;
 
@@ -20,7 +26,8 @@ export class EphemeralKeyPair {
 
   readonly publicKey: EphemeralPublicKey;
 
-  constructor(args: { privateKey: PrivateKey; expiryDateSecs?: bigint; blinder?: HexInput }) {
+  constructor(args: { privateKey: PrivateKey; expiryDateSecs?: bigint | number; blinder?: HexInput }) {
+    super()
     const { privateKey, expiryDateSecs, blinder } = args;
     this.privateKey = privateKey;
     this.publicKey = new EphemeralPublicKey(privateKey.publicKey());
@@ -29,7 +36,29 @@ export class EphemeralKeyPair {
     this.nonce = this.generateNonce();
   }
 
-  static generate(args?: {scheme: SigningSchemeInput}): EphemeralKeyPair {
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(this.publicKey.variant);
+    serializer.serializeBytes(this.privateKey.toUint8Array())
+    serializer.serializeU64(this.expiryDateSecs)
+    serializer.serializeFixedBytes(this.blinder)
+  }
+
+  static deserialize(deserializer: Deserializer): EphemeralKeyPair {
+    const variantIndex = deserializer.deserializeUleb128AsU32();
+    let privateKey: PrivateKey;
+    switch (variantIndex) {
+      case EphemeralPublicKeyVariant.Ed25519:
+        privateKey = Ed25519PrivateKey.deserialize(deserializer);
+        break;
+      default:
+        throw new Error(`Unknown variant index for EphemeralPublicKey: ${variantIndex}`);
+    }
+    const expiryDateSecs = deserializer.deserializeU64();
+    const blinder = deserializer.deserializeFixedBytes(31);
+    return new EphemeralKeyPair({privateKey, expiryDateSecs, blinder});
+  }
+
+  static generate(args?: { scheme: SigningSchemeInput }): EphemeralKeyPair {
     let privateKey: PrivateKey;
 
     switch (args?.scheme) {
@@ -43,8 +72,8 @@ export class EphemeralKeyPair {
 
   generateNonce(): string {
     const fields = padAndPackBytesWithLen(this.publicKey.bcsToBytes(), 93);
-    fields.push(BigInt(this.expiryDateSecs))
-    fields.push(bytesToBigIntLE(this.blinder))
+    fields.push(BigInt(this.expiryDateSecs));
+    fields.push(bytesToBigIntLE(this.blinder));
     const nonceHash = poseidonHash(fields);
     return nonceHash.toString();
   }
@@ -65,7 +94,7 @@ function generateBlinder(): Uint8Array {
 }
 
 function currentTimeInSeconds(): number {
-  return Math.floor(new Date().getTime() / 1000)
+  return Math.floor(new Date().getTime() / 1000);
 }
 
 function floorToWholeHour(timestampInSeconds: number): number {

package/src/account/KeylessAccount.ts

@@ -22,7 +22,7 @@ import { Account } from "./Account";
 import { EphemeralKeyPair } from "./EphemeralKeyPair";
 import { Hex } from "../core/hex";
 import { AccountAuthenticatorSingleKey } from "../transactions/authenticator/account";
-import { Serializer } from "../bcs";
+import { Deserializer, Serializer } from "../bcs";
 import { deriveTransactionType, generateSigningMessage } from "../transactions/transactionBuilder/signingMessage";
 import { AnyRawTransaction } from "../transactions/types";
 
@@ -44,9 +44,6 @@ export class KeylessAccount implements Account {
 
   static readonly SLIP_0010_SEED: string = "32 bytes";
 
-  static readonly APTOS_CONNECT_CLIENT_ID: string =
-    "734998116548-ib6ircv72o1b6l0no9ol4spnnkr8gm69.apps.googleusercontent.com";
-
   publicKey: KeylessPublicKey;
 
   ephemeralKeyPair: EphemeralKeyPair;
@@ -102,6 +99,41 @@ export class KeylessAccount implements Account {
     this.pepper = pepperBytes;
   }
 
+  async serialize(serializer: Serializer): Promise<void> {
+    serializer.serializeStr(this.jwt);
+    serializer.serializeStr(this.uidKey);
+    serializer.serializeFixedBytes(this.pepper);
+    this.ephemeralKeyPair.serialize(serializer);
+    const proof = await this.proof;
+    proof.serialize(serializer);
+  }
+
+  static deserialize(deserializer: Deserializer): KeylessAccount {
+    const jwt = deserializer.deserializeStr();
+    const uidKey = deserializer.deserializeStr();
+    const pepper = deserializer.deserializeFixedBytes(31);
+    const ephemeralKeyPair = EphemeralKeyPair.deserialize(deserializer);
+    const proof = SignedGroth16Signature.deserialize(deserializer);
+    return KeylessAccount.fromJWTAndProof({
+      proofFetcherOrData: proof,
+      pepper,
+      uidKey,
+      jwt,
+      ephemeralKeyPair,
+    });
+  }
+
+  async bcsToBytes(): Promise<Uint8Array> {
+    const serializer = new Serializer();
+    await this.serialize(serializer);
+    return serializer.toUint8Array();
+  }
+
+  async bcsToHex(): Promise<Hex> {
+    const bcsBytes = await this.bcsToBytes();
+    return Hex.fromHexInput(bcsBytes);
+  }
+
   private async initialize(promise: Promise<SignedGroth16Signature>) {
     try {
       this.proof = await promise;
@@ -119,7 +151,7 @@ export class KeylessAccount implements Account {
 
   async waitForProofFetch() {
     if (this.proof instanceof Promise) {
-      await this.proof
+      await this.proof;
     }
   }
 
@@ -138,7 +170,7 @@ export class KeylessAccount implements Account {
     const serializer = new Serializer();
     serializer.serializeFixedBytes(Hex.fromHexInput(data).toUint8Array());
     serializer.serializeOption(this.proof.proof);
-    const signMess = generateSigningMessage(serializer.toUint8Array(), "TransactionAndProof");
+    const signMess = generateSigningMessage(serializer.toUint8Array(), "APTOS::TransactionAndProof");
 
     const ephemeralSignature = this.ephemeralKeyPair.sign(signMess);
 
@@ -178,18 +210,6 @@ export class KeylessAccount implements Account {
     });
   }
 
-  deriveAptosConnectPublicKey(): KeylessPublicKey {
-    const { uidKey, uidVal, pepper } = this;
-    const { iss } = this.publicKey;
-    const addressSeed = computeAddressSeed({
-      uidKey,
-      uidVal,
-      aud: KeylessAccount.APTOS_CONNECT_CLIENT_ID,
-      pepper,
-    });
-    return new KeylessPublicKey(iss, addressSeed);
-  }
-
   // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this
   verifySignature(args: { message: HexInput; signature: Signature }): boolean {
     return true;

package/src/account/MultiKeyAccount.ts

@@ -78,9 +78,7 @@ export class MultiKeyAccount implements Account {
 
   async waitForProofFetch() {
     const keylessSigners = this.signers.filter((signer) => signer instanceof KeylessAccount) as KeylessAccount[];
-    await Promise.all(
-      keylessSigners.filter((signer) => signer.proof instanceof Promise).map( (signer) => signer.proof),
-    );
+    await Promise.all(keylessSigners.filter((signer) => signer.proof instanceof Promise).map((signer) => signer.proof));
   }
 
   /**

package/src/account/SingleKeyAccount.ts

@@ -109,17 +109,16 @@ export class SingleKeyAccount implements Account {
   }
 
   signWithAuthenticator(transaction: AnyRawTransaction) {
-    const innerSignature = this.sign(generateSigningMessageForTransaction(transaction));
-    const signature = new AnySignature(innerSignature);
+    const signature = this.sign(generateSigningMessageForTransaction(transaction));
     return new AccountAuthenticatorSingleKey(this.publicKey, signature);
   }
 
   sign(message: HexInput) {
-    return this.privateKey.sign(message);
+    return new AnySignature(this.privateKey.sign(message));
   }
 
   signTransaction(transaction: AnyRawTransaction) {
-    return this.sign(generateSigningMessageForTransaction(transaction))
+    return this.sign(generateSigningMessageForTransaction(transaction));
   }
 
   // endregion

package/src/api/account.ts

@@ -1,7 +1,7 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { Account as AccountModule} from "../account"
+import { Account as AccountModule } from "../account";
 import { AccountAddress, PrivateKey, AccountAddressInput } from "../core";
 import {
   AccountData,

package/src/api/ans.ts

@@ -1,6 +1,7 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
+import { Account } from "../account";
 import { AccountAddress, AccountAddressInput } from "../core";
 import {
   RegisterNameParameters,
@@ -26,7 +27,6 @@ import { GetANSNameResponse } from "../types";
 import { InputGenerateTransactionOptions } from "../transactions/types";
 import { AptosConfig } from "./aptosConfig";
 import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
-import { Account } from "../account";
 
 /**
  * A class to handle all `ANS` operations

package/src/api/aptosConfig.ts

@@ -135,7 +135,7 @@ export class AptosConfig {
   isPepperServiceRequest(url: string): boolean {
     return NetworkToPepperAPI[this.network] === url;
   }
-  
+
   /**
    * Checks if the URL is a known prover service endpoint
    *

package/src/api/digitalAsset.ts

@@ -14,6 +14,7 @@ import {
   TokenStandardArg,
 } from "../types";
 import { AccountAddress, AccountAddressInput } from "../core";
+import { Account } from "../account";
 import { InputGenerateTransactionOptions } from "../transactions/types";
 import {
   addDigitalAssetPropertyTransaction,
@@ -45,7 +46,6 @@ import {
 import { ProcessorType } from "../utils/const";
 import { AptosConfig } from "./aptosConfig";
 import { waitForIndexerOnVersion } from "./utils";
-import { Account } from "../account";
 import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
 
 /**

package/src/api/fungibleAsset.ts

@@ -23,9 +23,9 @@ import {
 import { ProcessorType } from "../utils/const";
 import { AptosConfig } from "./aptosConfig";
 import { waitForIndexerOnVersion } from "./utils";
+import { Account } from "../account";
 import { AccountAddressInput } from "../core";
 import { InputGenerateTransactionOptions } from "../transactions";
-import { Account } from "../account";
 import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
 
 /**

package/src/api/keyless.ts

@@ -1,28 +1,11 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { Account, EphemeralKeyPair, KeylessAccount, MultiKeyAccount } from "../account";
+import { EphemeralKeyPair, KeylessAccount } from "../account";
 import { deriveKeylessAccount, getPepper } from "../internal/keyless";
 import { HexInput } from "../types";
 import { AptosConfig } from "./aptosConfig";
 
-interface BaseDeriveKeylessAccountArgs {
-  jwt: string;
-  ephemeralKeyPair: EphemeralKeyPair;
-  uidKey?: string;
-  pepper?: HexInput;
-  extraFieldKey?: string;
-  fetchProofAsync?: boolean;
-}
-
-interface DeriveKeylessAccountArgs extends BaseDeriveKeylessAccountArgs {
-  disableConnect: true;
-}
-
-interface DeriveKeylessAccountWithConnectArgs extends BaseDeriveKeylessAccountArgs {
-  disableConnect?: boolean;
-}
-
 /**
  * A class to query all `OIDB` related queries on Aptos.
  */
@@ -35,12 +18,10 @@ export class Keyless {
    * @param args.jwt jwt token
    * @returns The pepper
    */
-  async getPepper(args: { jwt: string, ephemeralKeyPair: EphemeralKeyPair; }): Promise<Uint8Array> {
+  async getPepper(args: { jwt: string; ephemeralKeyPair: EphemeralKeyPair }): Promise<Uint8Array> {
     return getPepper({ aptosConfig: this.config, ...args });
   }
 
-  async deriveKeylessAccount(args: DeriveKeylessAccountArgs): Promise<KeylessAccount>;
-  async deriveKeylessAccount(args: DeriveKeylessAccountWithConnectArgs): Promise<MultiKeyAccount>;
   async deriveKeylessAccount(args: {
     jwt: string;
     ephemeralKeyPair: EphemeralKeyPair;
@@ -49,7 +30,7 @@ export class Keyless {
     extraFieldKey?: string;
     disableConnect?: boolean;
     fetchProofAsync?: boolean;
-  }): Promise<Account> {
+  }): Promise<KeylessAccount> {
     return deriveKeylessAccount({ aptosConfig: this.config, ...args });
   }
 }

package/src/api/transaction.ts

@@ -34,11 +34,11 @@ import {
   InputGenerateTransactionPayloadData,
 } from "../transactions";
 import { AccountAddressInput, PrivateKey } from "../core";
+import { Account } from "../account";
 import { Build } from "./transactionSubmission/build";
 import { Simulate } from "./transactionSubmission/simulate";
 import { Submit } from "./transactionSubmission/submit";
 import { TransactionManagement } from "./transactionSubmission/management";
-import { Account } from "../account/Account";
 import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
 
 export class Transaction {

package/src/client/post.ts

@@ -136,7 +136,6 @@ export async function postAptosFaucet<Req extends {}, Res extends {}>(
   });
 }
 
-
 export async function postAptosPepperService<Req extends {}, Res extends {}>(
   options: PostAptosRequestOptions,
 ): Promise<AptosResponse<Req, Res>> {
@@ -147,4 +146,4 @@ export async function postAptosProvingService<Req extends {}, Res extends {}>(
   options: PostAptosRequestOptions,
 ): Promise<AptosResponse<Req, Res>> {
   return post<Req, Res>({ ...options, type: AptosApiType.PROVER });
-}
+}

package/src/core/account/index.ts

@@ -0,0 +1,2 @@
+export * from "./utils";
+

package/src/core/crypto/ed25519.ts

@@ -7,11 +7,7 @@ import { Serializable, Serializer } from "../../bcs/serializer";
 import { AuthenticationKey } from "../authenticationKey";
 import { Hex } from "../hex";
 import { HexInput, SigningScheme as AuthenticationKeyScheme } from "../../types";
-import {
-  isValidHardenedPath,
-  fromDerivationPath as fromDerivationPathInner,
-  mnemonicToSeed,
-} from "./hdKey";
+import { isValidHardenedPath, fromDerivationPath as fromDerivationPathInner, mnemonicToSeed } from "./hdKey";
 import { PrivateKey } from "./privateKey";
 import { AccountPublicKey, VerifySignatureArgs } from "./publicKey";
 import { Signature } from "./signature";
@@ -189,7 +185,9 @@ export class Ed25519PrivateKey extends Serializable implements PrivateKey {
     if (!isValidHardenedPath(path)) {
       throw new Error(`Invalid derivation path ${path}`);
     }
-    return new Ed25519PrivateKey(fromDerivationPathInner(path, Ed25519PrivateKey.SLIP_0010_SEED, mnemonicToSeed(mnemonics)));
+    return new Ed25519PrivateKey(
+      fromDerivationPathInner(path, Ed25519PrivateKey.SLIP_0010_SEED, mnemonicToSeed(mnemonics)),
+    );
   }
 
   // endregion

package/src/core/crypto/ephemeral.ts

@@ -16,12 +16,15 @@ export class EphemeralPublicKey extends PublicKey {
    */
   public readonly publicKey: PublicKey;
 
+  public readonly variant: EphemeralPublicKeyVariant;
+
   constructor(publicKey: PublicKey) {
     super();
     const publicKeyType = publicKey.constructor.name;
     switch (publicKeyType) {
       case Ed25519PublicKey.name:
         this.publicKey = publicKey;
+        this.variant = EphemeralPublicKeyVariant.Ed25519;
         break;
       default:
         throw new Error(`Unsupported key for EphemeralPublicKey - ${publicKeyType}`);
@@ -43,7 +46,7 @@ export class EphemeralPublicKey extends PublicKey {
    * @returns string representation of the public key
    */
   toString(): string {
-    return this.bcsToHex().toString()
+    return this.bcsToHex().toString();
   }
 
   /**
@@ -86,7 +89,6 @@ export class EphemeralPublicKey extends PublicKey {
   }
 }
 
-
 export class EphemeralSignature extends Signature {
   public readonly signature: Signature;
 

package/src/core/crypto/keyless.ts

@@ -243,7 +243,13 @@ export class SignedGroth16Signature extends Signature {
     trainingWheelsSignature?: EphemeralSignature;
   }) {
     super();
-    const { proof, expHorizonSecs = BigInt(EPK_HORIZON_SECS), trainingWheelsSignature, extraField, overrideAudVal } = args;
+    const {
+      proof,
+      expHorizonSecs = BigInt(EPK_HORIZON_SECS),
+      trainingWheelsSignature,
+      extraField,
+      overrideAudVal,
+    } = args;
     this.proof = proof;
     this.expHorizonSecs = expHorizonSecs;
     this.trainingWheelsSignature = trainingWheelsSignature;
@@ -413,7 +419,7 @@ export class KeylessSignature extends Signature {
 
   readonly jwtHeader: string;
 
-  readonly expiryDateSecs: bigint;
+  readonly expiryDateSecs: bigint | number;
 
   readonly ephemeralPublicKey: EphemeralPublicKey;
 
@@ -427,7 +433,7 @@ export class KeylessSignature extends Signature {
   constructor(args: {
     jwtHeader: string;
     openIdSignatureOrZkProof: OpenIdSignatureOrZkProof;
-    expiryDateSecs: bigint;
+    expiryDateSecs: bigint | number;
     ephemeralPublicKey: EphemeralPublicKey;
     ephemeralSignature: EphemeralSignature;
   }) {

package/src/core/crypto/multiKey.ts

@@ -141,15 +141,13 @@ export class MultiKey extends AccountPublicKey {
   }
 
   getIndex(publicKey: PublicKey): number {
-
-    const anyPublicKey = publicKey instanceof AnyPublicKey ? publicKey : new AnyPublicKey(publicKey)
+    const anyPublicKey = publicKey instanceof AnyPublicKey ? publicKey : new AnyPublicKey(publicKey);
     const index = this.publicKeys.findIndex((pk) => pk.toString() === anyPublicKey.toString());
 
     if (index !== -1) {
-        return index;
-    } 
+      return index;
+    }
     throw new Error("Public key not found in MultiKey");
-  
   }
 }
 

package/src/core/crypto/singleKey.ts

@@ -178,9 +178,9 @@ export class AnySignature extends Signature {
       case AnySignatureVariant.Secp256k1:
         signature = Secp256k1Signature.deserialize(deserializer);
         break;
-        case AnySignatureVariant.Keyless:
-          signature = KeylessSignature.deserialize(deserializer);
-          break;
+      case AnySignatureVariant.Keyless:
+        signature = KeylessSignature.deserialize(deserializer);
+        break;
       default:
         throw new Error(`Unknown variant index for AnySignature: ${variantIndex}`);
     }

package/src/internal/ans.ts

@@ -8,8 +8,8 @@
  * name namespace and without having a dependency cycle error.
  */
 
-import { Account } from "../account";
 import { AptosConfig } from "../api/aptosConfig";
+import { Account } from "../account";
 import { AccountAddress, AccountAddressInput } from "../core";
 import { InputGenerateTransactionOptions } from "../transactions/types";
 import { GetANSNameResponse, MoveAddressType, OrderByArg, PaginationArgs, WhereArg } from "../types";

package/src/internal/digitalAsset.ts

@@ -11,6 +11,7 @@
 import { AptosConfig } from "../api/aptosConfig";
 import { Bool, MoveString, MoveVector, U64 } from "../bcs";
 import { AccountAddress, AccountAddressInput } from "../core";
+import { Account } from "../account";
 import { EntryFunctionABI, InputGenerateTransactionOptions } from "../transactions/types";
 import {
   AnyNumber,
@@ -53,7 +54,6 @@ import {
   TypeTagU64,
   TypeTagVector,
 } from "../transactions";
-import { Account } from "../account";
 import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
 
 // A property type map for the user input and what Move expects

package/src/internal/fungibleAsset.ts

@@ -34,6 +34,7 @@ import {
   FungibleAssetMetadataBoolExp,
 } from "../types/generated/types";
 import { AccountAddressInput } from "../core";
+import { Account } from "../account";
 import {
   EntryFunctionABI,
   InputGenerateTransactionOptions,
@@ -42,7 +43,6 @@ import {
   TypeTagU64,
 } from "../transactions";
 import { generateTransaction } from "./transactionSubmission";
-import { Account } from "../account";
 import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
 
 export async function getFungibleAssetMetadata(args: {

package/src/internal/keyless.ts

@@ -18,12 +18,11 @@ import {
   EphemeralSignature,
   Groth16Zkp,
   Hex,
-  MultiKey,
   SignedGroth16Signature,
 } from "../core";
 import { HexInput } from "../types";
 import { Serializer } from "../bcs";
-import { EphemeralKeyPair, KeylessAccount, MultiKeyAccount } from "../account";
+import { EphemeralKeyPair, KeylessAccount } from "../account";
 import { PepperFetchResponse, ProverResponse } from "../types/keyless";
 
 const APTOS_KEYLESS_PEPPER_PINKAS_VUF_DST = "APTOS_KEYLESS_PEPPER_PINKAS_VUF_DST";
@@ -171,15 +170,10 @@ export async function deriveKeylessAccount(args: {
   uidKey?: string;
   pepper?: HexInput;
   extraFieldKey?: string;
-  disableConnect?: boolean;
   fetchProofAsync?: boolean;
-}): Promise<KeylessAccount | MultiKeyAccount> {
+}): Promise<KeylessAccount> {
   const { fetchProofAsync } = args;
-  let { pepper, disableConnect } = args;
-
-  if (pepper || disableConnect) {
-    disableConnect = true;
-  }
+  let { pepper } = args;
   if (pepper === undefined) {
     pepper = await getPepper(args);
   } else if (Hex.fromHexInput(pepper).toUint8Array().length !== 31) {
@@ -191,15 +185,5 @@ export async function deriveKeylessAccount(args: {
 
   const keylessAccount = KeylessAccount.fromJWTAndProof({ ...args, proofFetcherOrData: proof, pepper });
 
-  if (disableConnect === true) {
     return keylessAccount;
-  }
-
-  const aptosConnectPublicKey = keylessAccount.deriveAptosConnectPublicKey();
-
-  const multiKey = new MultiKey({
-    publicKeys: [keylessAccount.publicKey, aptosConnectPublicKey],
-    signaturesRequired: 1,
-  });
-  return new MultiKeyAccount({ multiKey, signers: [keylessAccount] });
 }

package/src/internal/transactionSubmission.ts

@@ -100,10 +100,10 @@ export async function buildTransactionPayload(
   args: { aptosConfig: AptosConfig } & InputGenerateTransactionData,
 ): Promise<AnyTransactionPayloadInstance> {
   const { aptosConfig, data } = args;
-
   // Merge in aptosConfig for remote ABI on non-script payloads
   let generateTransactionPayloadData: InputGenerateTransactionPayloadDataWithRemoteABI;
   let payload: AnyTransactionPayloadInstance;
+
   if ("bytecode" in data) {
     // TODO: Add ABI checking later
     payload = await generateTransactionPayload(data);
@@ -114,6 +114,7 @@ export async function buildTransactionPayload(
       function: data.function,
       functionArguments: data.functionArguments,
       typeArguments: data.typeArguments,
+      abi: data.abi,
     };
     payload = await generateTransactionPayload(generateTransactionPayloadData);
   } else {
@@ -122,6 +123,7 @@ export async function buildTransactionPayload(
       function: data.function,
       functionArguments: data.functionArguments,
       typeArguments: data.typeArguments,
+      abi: data.abi,
     };
     payload = await generateTransactionPayload(generateTransactionPayloadData);
   }

package/src/transactions/transactionBuilder/index.ts

@@ -5,4 +5,3 @@ export * from "./helpers";
 export * from "./transactionBuilder";
 export * from "./remoteAbi";
 export * from "./signingMessage";
-