@moveindustries/ts-sdk 5.1.4

package/src/api/transactionSubmission/simulate.ts

@@ -0,0 +1,192 @@
+// Copyright © Move Industries
+// SPDX-License-Identifier: Apache-2.0
+
+import { PublicKey } from "../../core";
+import { simulateTransaction } from "../../internal/transactionSubmission";
+import { AnyRawTransaction, InputSimulateTransactionOptions } from "../../transactions";
+import { UserTransactionResponse } from "../../types";
+import { MovementConfig } from "../movementConfig";
+import { ValidateFeePayerDataOnSimulation } from "./helpers";
+
+/**
+ * A class to handle all `Simulate` transaction operations.
+ * @group Implementation
+ */
+export class Simulate {
+  readonly config: MovementConfig;
+
+  /**
+   * Initializes a new instance of the Movement client with the specified configuration.
+   * This allows you to interact with the Movement blockchain using the provided settings.
+   *
+   * @param config - The configuration settings for the Movement client.
+   * @param config.network - The network to connect to (e.g., TESTNET, MAINNET).
+   * @param config.nodeUrl - The URL of the Movement node to connect to.
+   *
+   * @example
+   * ```typescript
+   * import { Movement, MovementConfig, Network } from "@moveindustries/ts-sdk";
+   *
+   * async function runExample() {
+   *     // Create a configuration for the Movement client
+   *     const config = new MovementConfig({ network: Network.TESTNET }); // Specify your desired network
+   *
+   *     // Initialize the Movement client with the configuration
+   *     const movement = new Movement(config);
+   *
+   *     console.log("Movement client initialized:", aptos);
+   * }
+   * runExample().catch(console.error);
+   * ```
+   * @group Implementation
+   */
+  constructor(config: MovementConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Simulates a transaction based on the provided parameters and returns the result.
+   * This function helps you understand the outcome of a transaction before executing it on the blockchain.
+   *
+   * @param args - The parameters for simulating the transaction.
+   * @param args.signerPublicKey - The public key of the signer for the transaction (optional).
+   * @param args.transaction - The raw transaction data to simulate.
+   * @param args.feePayerPublicKey - The public key of the fee payer (optional).
+   * @param args.options - Additional options for simulating the transaction (optional).
+   *
+   * @example
+   * ```typescript
+   * import {
+   *     Account,
+   *     Movement,
+   *     MovementConfig,
+   *     Network,
+   * } from "@moveindustries/ts-sdk";
+   *
+   * async function example() {
+   *     let sender = Account.generate();
+   *     let receiver = Account.generate();
+   *
+   *     // 0. Set up the client and test accounts
+   *     const config = new MovementConfig({ network: Network.DEVNET });
+   *     const movement = new Movement(config);
+   *
+   *     await movement.fundAccount({
+   *         accountAddress: sender.accountAddress,
+   *         amount: 100_000_000,
+   *     });
+   *
+   *     // 1. Build the transaction to preview the impact of it
+   *     const transaction = await movement.transaction.build.simple({
+   *         sender: sender.accountAddress,
+   *         data: {
+   *             // All transactions on Movement are implemented via smart contracts.
+   *             function: "0x1::aptos_account::transfer",
+   *             functionArguments: [receiver.accountAddress, 100],
+   *         },
+   *     });
+   *
+   *     // 2. Simulate to see what would happen if we execute this transaction
+   *     const [userTransactionResponse] = await movement.transaction.simulate.simple({
+   *         signerPublicKey: sender.publicKey,
+   *         transaction,
+   *     });
+   *     console.log(userTransactionResponse);
+   *
+   *     // If the fee looks ok, continue to signing!
+   *     // ...
+   * }
+   *
+   * example();
+   * ```
+   * @group Implementation
+   */
+  @ValidateFeePayerDataOnSimulation
+  async simple(args: {
+    signerPublicKey?: PublicKey;
+    transaction: AnyRawTransaction;
+    feePayerPublicKey?: PublicKey;
+    options?: InputSimulateTransactionOptions;
+  }): Promise<Array<UserTransactionResponse>> {
+    return simulateTransaction({ movementConfig: this.config, ...args });
+  }
+
+  /**
+   * Simulates a multi-agent transaction by generating a signed transaction and posting it to the Movement full node.
+   * This function helps in understanding the outcome of a transaction involving multiple signers before it is executed.
+   *
+   * @param args - The parameters for simulating the transaction.
+   * @param args.signerPublicKey - The public key of the primary signer (optional).
+   * @param args.transaction - The raw transaction to be simulated.
+   * @param args.secondarySignersPublicKeys - An array of public keys for secondary signers (optional).
+   *        Each element of the array can be optional, allowing the corresponding key check to be skipped.
+   * @param args.feePayerPublicKey - The public key of the fee payer (optional).
+   * @param args.options - Options for simulating the transaction (optional).
+   *
+   * @example
+   * ```typescript
+   * import {
+   *     Account,
+   *     Movement,
+   *     MovementConfig,
+   *     Network,
+   * } from "@moveindustries/ts-sdk";
+   *
+   * async function example() {
+   *     let sender1 = Account.generate();
+   *     let sender2 = Account.generate();
+   *     let receiver = Account.generate();
+   *
+   *     // 0. Set up the client and test accounts
+   *     const config = new MovementConfig({ network: Network.DEVNET });
+   *     const movement = new Movement(config);
+   *
+   *     await movement.fundAccount({
+   *         accountAddress: sender.accountAddress,
+   *         amount: 100_000_000,
+   *     });
+   *
+   *     // 1. Build
+   *     console.log("\n=== 1. Building the transaction ===\n");
+   *     const transaction = await movement.transaction.build.multiAgent({
+   *     sender: sender1.accountAddress,
+   *     secondarySignerAddresses: [sender2.accountAddress],
+   *     data: {
+   *        // REPLACE WITH YOUR MULTI-AGENT FUNCTION HERE
+   *        function:
+   *          "<REPLACE WITH YOUR MULTI AGENT MOVE ENTRY FUNCTION> (Syntax {address}::{module}::{function})",
+   *          functionArguments: [],
+   *        },
+   *      });
+   *      console.log("Transaction:", transaction);
+   *
+   *      // 2. Simulate (Optional)
+   *      console.log("\n === 2. Simulating Response (Optional) === \n");
+   *      const [userTransactionResponse] = await movement.transaction.simulate.multiAgent(
+   *        {
+   *          signerPublicKey: sender1.publicKey,
+   *          secondarySignersPublicKeys: [sender2.publicKey],
+   *          transaction,
+   *        },
+   *      );
+   *      console.log(userTransactionResponse);
+   *
+   *      // If the fee looks ok, continue to signing!
+   *      // ...
+   * }
+   *
+   * example();
+   * ```
+   * @group Implementation
+   */
+  @ValidateFeePayerDataOnSimulation
+  async multiAgent(args: {
+    signerPublicKey?: PublicKey;
+    transaction: AnyRawTransaction;
+    secondarySignersPublicKeys?: Array<PublicKey | undefined>;
+    feePayerPublicKey?: PublicKey;
+    options?: InputSimulateTransactionOptions;
+  }): Promise<Array<UserTransactionResponse>> {
+    return simulateTransaction({ movementConfig: this.config, ...args });
+  }
+}

package/src/api/transactionSubmission/submit.ts

@@ -0,0 +1,156 @@
+// Copyright © Move Industries
+// SPDX-License-Identifier: Apache-2.0
+
+import { submitTransaction } from "../../internal/transactionSubmission";
+import { AccountAuthenticator, AnyRawTransaction, InputTransactionPluginData } from "../../transactions";
+import { PendingTransactionResponse } from "../../types";
+import { MovementConfig } from "../movementConfig";
+import { validateFeePayerDataOnSubmission } from "./helpers";
+
+/**
+ * A class to handle all `Submit` transaction operations.
+ * @group Implementation
+ */
+export class Submit {
+  readonly config: MovementConfig;
+
+  /**
+   * Initializes a new instance of the Movement client with the specified configuration.
+   * This allows you to interact with the Movement blockchain using the provided settings.
+   *
+   * @param config - The configuration settings for the Movement client.
+   * @param config.network - The network to connect to (e.g., TESTNET, MAINNET).
+   * @param config.nodeUrl - The URL of the Movement node to connect to.
+   * @param config.faucetUrl - The URL of the faucet for obtaining test tokens.
+   *
+   * @example
+   * ```typescript
+   * import { Movement, MovementConfig, Network } from "@moveindustries/ts-sdk";
+   *
+   * async function runExample() {
+   *     // Create a configuration for the Movement client
+   *     const config = new MovementConfig({
+   *         network: Network.TESTNET, // Use the TESTNET for testing
+   *         nodeUrl: "https://testnet.movement.dev", // Specify the node URL
+   *         faucetUrl: "https://faucet.testnet.movement.dev" // Specify the faucet URL
+   *     });
+   *
+   *     // Initialize the Movement client with the configuration
+   *     const movement = new Movement(config);
+   *
+   *     console.log("Movement client initialized:", aptos);
+   * }
+   * runExample().catch(console.error);
+   * ```
+   * @group Implementation
+   */
+  constructor(config: MovementConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Submits a transaction to the Movement blockchain using the provided transaction details and authenticators.
+   * This function allows you to execute transactions securely by specifying the sender and optional fee payer authenticators.
+   *
+   * @param args - The arguments for submitting the transaction.
+   * @param args.transaction - The raw transaction data to be submitted.
+   * @param args.senderAuthenticator - The authenticator for the sender's account.
+   * @param [args.feePayerAuthenticator] - The optional authenticator for the fee payer's account.
+   *
+   * @example
+   * ```typescript
+   * import { Movement, MovementConfig, Network, Account } from "@moveindustries/ts-sdk";
+   *
+   * const config = new MovementConfig({ network: Network.TESTNET });
+   * const movement = new Movement(config);
+   *
+   * async function runExample() {
+   *   const sender = Account.generate(); // Generate a new sender account
+   *   const transaction = await movement.transaction.build.simple({
+   *     sender: sender.accountAddress,
+   *     data: {
+   *       function: "0x1::aptos_account::transfer",
+   *       functionArguments: [Account.generate().accountAddress, 100], // Replace with a real destination account
+   *     },
+   *   });
+   *
+   *   // Submit the transaction
+   *   const response = await movement.simple({
+   *     transaction,
+   *     senderAuthenticator: sender.getAuthenticator(), // Use the sender's authenticator
+   *   });
+   *
+   *   console.log("Transaction submitted:", response);
+   * }
+   * runExample().catch(console.error);
+   * ```
+   * @group Implementation
+   */
+  async simple(
+    args: {
+      transaction: AnyRawTransaction;
+      senderAuthenticator: AccountAuthenticator;
+      feePayerAuthenticator?: AccountAuthenticator;
+    } & InputTransactionPluginData,
+  ): Promise<PendingTransactionResponse> {
+    validateFeePayerDataOnSubmission(this.config, args);
+    return submitTransaction({ movementConfig: this.config, ...args });
+  }
+
+  /**
+   * Submits a multi-agent transaction to the Movement network, allowing multiple signers to authorize the transaction.
+   * This function is useful for scenarios where a transaction requires approval from multiple accounts.
+   *
+   * @param args - The parameters for the multi-agent transaction.
+   * @param args.transaction - The raw transaction to be submitted.
+   * @param args.senderAuthenticator - The authenticator for the sender account.
+   * @param args.additionalSignersAuthenticators - An array of authenticators for additional signers.
+   * @param [args.feePayerAuthenticator] - An optional authenticator for the fee payer account.
+   *
+   * @example
+   * ```typescript
+   * import { Movement, MovementConfig, Network, Account } from "@moveindustries/ts-sdk";
+   *
+   * const config = new MovementConfig({ network: Network.TESTNET });
+   * const movement = new Movement(config);
+   *
+   * async function runExample() {
+   *   const sender = Account.generate(); // Generate a new sender account
+   *   const additionalSigner1 = Account.generate(); // Generate an additional signer account
+   *   const additionalSigner2 = Account.generate(); // Generate another additional signer account
+   *
+   *   const transaction = await movement.transaction.build.simple({
+   *     sender: sender.accountAddress,
+   *     data: {
+   *       function: "0x1::aptos_account::transfer",
+   *       functionArguments: [additionalSigner1.accountAddress, 100],
+   *     },
+   *   });
+   *
+   *   const response = await movement.multiAgent({
+   *     transaction,
+   *     senderAuthenticator: sender.getAuthenticator(), // Use the sender's authenticator
+   *     additionalSignersAuthenticators: [
+   *       additionalSigner1.getAuthenticator(), // Use the first additional signer's authenticator
+   *       additionalSigner2.getAuthenticator(), // Use the second additional signer's authenticator
+   *     ],
+   *   });
+   *
+   *   console.log(response); // Log the response from the transaction submission
+   * }
+   * runExample().catch(console.error);
+   * ```
+   * @group Implementation
+   */
+  async multiAgent(
+    args: {
+      transaction: AnyRawTransaction;
+      senderAuthenticator: AccountAuthenticator;
+      additionalSignersAuthenticators: Array<AccountAuthenticator>;
+      feePayerAuthenticator?: AccountAuthenticator;
+    } & InputTransactionPluginData,
+  ): Promise<PendingTransactionResponse> {
+    validateFeePayerDataOnSubmission(this.config, args);
+    return submitTransaction({ movementConfig: this.config, ...args });
+  }
+}

package/src/api/utils.ts

@@ -0,0 +1,48 @@
+import { waitForIndexer } from "../internal/transaction";
+import { AnyNumber } from "../types";
+import { ProcessorType } from "../utils";
+import { MovementConfig } from "./movementConfig";
+
+/**
+ * Waits for the indexer to reach a specified ledger version, allowing for synchronization with the blockchain.
+ * This function is useful for ensuring that your application is working with the most up-to-date data before proceeding.
+ *
+ * @param args - The parameters for waiting on the indexer.
+ * @param args.config - The configuration object for Movement.
+ * @param [args.minimumLedgerVersion] - The minimum ledger version to wait for. If not specified, the function will not wait.
+ * @param args.processorType - The type of processor to wait for.
+ *
+ * @example
+ * ```typescript
+ * import { Movement, MovementConfig, Network, ProcessorType } from "@moveindustries/ts-sdk";
+ *
+ * const config = new MovementConfig({ network: Network.TESTNET });
+ * const movement = new Movement(config);
+ *
+ * async function runExample() {
+ *   // Wait for the indexer to reach a specific ledger version
+ *   await movement.waitForIndexerOnVersion({
+ *     config: config,
+ *     minimumLedgerVersion: 1000n, // replace with a real ledger version
+ *     processorType: ProcessorType.DEFAULT,
+ *   });
+ *
+ *   console.log("Indexer is synced to the specified ledger version.");
+ * }
+ * runExample().catch(console.error);
+ * ```
+ * @group Implementation
+ */
+export async function waitForIndexerOnVersion(args: {
+  config: MovementConfig;
+  minimumLedgerVersion?: AnyNumber;
+  processorType: ProcessorType;
+}) {
+  if (args.minimumLedgerVersion !== undefined) {
+    await waitForIndexer({
+      movementConfig: args.config,
+      minimumLedgerVersion: args.minimumLedgerVersion,
+      processorType: args.processorType,
+    });
+  }
+}

package/src/bcs/consts.ts

@@ -0,0 +1,28 @@
+// Copyright © Move Industries
+// SPDX-License-Identifier: Apache-2.0
+
+import { Int128, Int16, Int256, Int32, Int64, Int8, Uint128, Uint16, Uint256, Uint32, Uint64, Uint8 } from "../types";
+
+// Upper bound values for uint8, uint16, uint64 etc.  These are all derived as
+// 2^N - 1, where N is the number of bits in the type.
+export const MAX_U8_NUMBER: Uint8 = 255;
+export const MAX_U16_NUMBER: Uint16 = 65535;
+export const MAX_U32_NUMBER: Uint32 = 4294967295;
+export const MAX_U64_BIG_INT: Uint64 = 18446744073709551615n;
+export const MAX_U128_BIG_INT: Uint128 = 340282366920938463463374607431768211455n;
+export const MAX_U256_BIG_INT: Uint256 =
+  115792089237316195423570985008687907853269984665640564039457584007913129639935n;
+
+// Signed integer bounds
+export const MIN_I8_NUMBER: Int8 = -128;
+export const MAX_I8_NUMBER: Int8 = 127;
+export const MIN_I16_NUMBER: Int16 = -32768;
+export const MAX_I16_NUMBER: Int16 = 32767;
+export const MIN_I32_NUMBER: Int32 = -2147483648;
+export const MAX_I32_NUMBER: Int32 = 2147483647;
+export const MIN_I64_BIG_INT: Int64 = -9223372036854775808n;
+export const MAX_I64_BIG_INT: Int64 = 9223372036854775807n;
+export const MIN_I128_BIG_INT: Int128 = -170141183460469231731687303715884105728n;
+export const MAX_I128_BIG_INT: Int128 = 170141183460469231731687303715884105727n;
+export const MIN_I256_BIG_INT: Int256 = -57896044618658097711785492504343953926634992332820282019728792003956564819968n;
+export const MAX_I256_BIG_INT: Int256 = 57896044618658097711785492504343953926634992332820282019728792003956564819967n;