# Aptos transaction

### 1. Generate Transaction

#### 1.1. Generate Transaction (Single signer)

*Generate transaction from readable **JSON format** payload.*

{% tabs %}
{% tab title="window\.fewcha" %}
**Method type**

```typescript
async generateTransaction(
    payload: EntryFunctionPayload,
    options?: Partial<SubmitTransactionRequest>
): Promise<Response<Uint8Array>>;

type SubmitTransactionRequest = {
    sender: string;
    sequence_number: string; // U64
    max_gas_amount: string; // U64
    gas_unit_price: string; // U64
    expiration_timestamp_secs: string; // U64
    payload: object; // Transaction Payload (entry, script, module_bundle)
    signature: object; // ed25519, multi_ed25519, multi_agent
}

type EntryFunctionPayload = {
    type: string;
    function: string;
    type_arguments: Array<string>;
    arguments: Array<any>;
}
```

**Example request**

```typescript
const receiverAddress = "0xcca3338dfda1b5e9bab0d744c3b50a9a24e3fe55bba48917307e813a4535e034";
const amount = 1000;

const payload = {
  type: "entry_function_payload",
  function: "0x1::coin::transfer",
  type_arguments: ["0x1::aptos_coin::AptosCoin"],
  arguments: [receiverAddress, amount],
};

const rawTransaction = await window.fewcha.generateTransaction(payload);
```

**Example response**

```typescript
{
    "method": "generateTransaction",
    "status": 200,
    "data": [...]
}
```

Response data: **TxnBuilderTypes.RawTransaction** as **Uint8Array**

Covert **Uint8Array** to **TxnBuilderTypes.RawTransaction** (optional)

```typescript
import { TxnBuilderTypes } from "aptos";

const d = new BCS.Deserializer(rawTransaction.data);
const tx = TxnBuilderTypes.RawTransaction.deserialize(d);

// type of tx is TxnBuilderTypes.RawTransaction
```

{% endtab %}
{% endtabs %}

#### 1.2. Generate Raw Transaction (Single signer)

*Generate **unsigned** transaction from **BCS serialized** payload*

{% tabs %}
{% tab title="window\.fewcha" %}
**Method type**

```typescript
async generateRawTransaction(
    payload: Uint8Array,
    extraArgs?: {
        maxGasAmount?: BCS.Uint64;
        gasUnitPrice?: BCS.Uint64;
        expireTimestamp?: BCS.Uint64
    }
): Promise<Response<Uint8Array>>;
```

**Example request**

```typescript
const receiverAddress = TxnBuilderTypes.AccountAddress.fromHex(
  "0xcca3338dfda1b5e9bab0d744c3b50a9a24e3fe55bba48917307e813a4535e034",
);
const sendBalance = 1000;

const token = new TxnBuilderTypes.TypeTagStruct(
  TxnBuilderTypes.StructTag.fromString("0x1::aptos_coin::AptosCoin"),
);
const entryFunctionPayload = new TxnBuilderTypes.TransactionPayloadEntryFunction(
  TxnBuilderTypes.EntryFunction.natural(
    "0x1::coin",
    "transfer",
    [token],
    [BCS.bcsToBytes(receiverAddress), BCS.bcsSerializeUint64(sendBalance)],
  ),
);

const s = new BCS.Serializer();
entryFunctionPayload.serialize(s);

const rawTxn = await window.fewcha.generateRawTransaction(s.getBytes());

console.log(rawTxn);
```

**Example response**

```typescript
{
    "method": "generateRawTransaction",
    "status": 200,
    "data": [...]
}
```

Response data: **TxnBuilderTypes.RawTransaction** as **Uint8Array**

Covert **Uint8Array** to **TxnBuilderTypes.RawTransaction** (optional)

```typescript
import { TxnBuilderTypes } from "aptos";

const d = new BCS.Deserializer(txnRequest.data);
const tx = TxnBuilderTypes.RawTransaction.deserialize(d);

// type of tx is TxnBuilderTypes.RawTransaction
```

{% endtab %}
{% endtabs %}

#### 1.3. Generate BCS Transaction (Single signer)

*Generate **signed*** ***BCS serialized** transaction from **BCS serialized** payload. Connected account will sign this **BCS serialized** payload.*

{% tabs %}
{% tab title="window\.fewcha" %}
**Method type**

```typescript
async generateBCSTransaction(
    rawTransaction: Uint8Array
): Promise<Response<Uint8Array>>;
```

**Example request**

```typescript
const receiverAddress = TxnBuilderTypes.AccountAddress.fromHex(
  "0xcca3338dfda1b5e9bab0d744c3b50a9a24e3fe55bba48917307e813a4535e034",
);
const sendBalance = 1000;

const token = new TxnBuilderTypes.TypeTagStruct(
  TxnBuilderTypes.StructTag.fromString("0x1::aptos_coin::AptosCoin"),
);
const entryFunctionPayload = new TxnBuilderTypes.TransactionPayloadEntryFunction(
  TxnBuilderTypes.EntryFunction.natural(
    "0x1::coin",
    "transfer",
    [token],
    [BCS.bcsToBytes(receiverAddress), BCS.bcsSerializeUint64(sendBalance)],
  ),
);

const s = new BCS.Serializer();
entryFunctionPayload.serialize(s);

const rawTxn = await web3.action.generateRawTransaction(s.getBytes());
if (!parseError(rawTxn.status)) return;

const bcsTxn = await web3.action.generateBCSTransaction(rawTxn.data);

console.log(bcsTxn);
```

**Example response**

```typescript
{
    "method": "generateBCSTransaction",
    "status": 200,
    "data": [...]
}
```

Response data: **TxnBuilderTypes.RawTransaction** as **Uint8Array**

Covert **Uint8Array** to **TxnBuilderTypes.RawTransaction** (optional)

```typescript
import { TxnBuilderTypes } from "aptos";

const d = new BCS.Deserializer(txnRequest.data);
const tx = TxnBuilderTypes.RawTransaction.deserialize(d);

// type of tx is TxnBuilderTypes.RawTransaction
```

{% endtab %}
{% endtabs %}

### 2. Sign Transaction

#### 2.1. Sign and Submit Transaction (Single signer)

{% hint style="info" %}
We **recommend** you use this method
{% endhint %}

{% tabs %}
{% tab title="window\.fewcha" %}
**Method type**

```typescript
async signAndSubmitTransaction(
    rawTransaction: Uint8Array
): Promise<Response<Gen.HexEncodedBytes>>;
```

**Example request**

```typescript
const receiverAddress = "0xcca3338dfda1b5e9bab0d744c3b50a9a24e3fe55bba48917307e813a4535e034";
const amount = 1000;

const payload = {
  type: "entry_function_payload",
  function: "0x1::coin::transfer",
  type_arguments: ["0x1::aptos_coin::AptosCoin"],
  arguments: [receiverAddress, amount],
};

const rawTransaction = await window.fewcha.generateTransaction(payload);
if (rawTransaction.status !== 200) return;

const txnHash = await window.fewcha.signAndSubmitTransaction(rawTransaction.data);

console.log("txnHash", txnHash);
```

**Example response**

```typescript
{
    "method": "signAndSubmitTransaction",
    "status": 200,
    "data": "0x67d7b7ccee8530659b91ad284ba2c24bd87fb70c5b4411737f4f314826b5cc97"
}
```

{% endtab %}
{% endtabs %}

#### 2.2. Sign Transaction (Single signer)

Sign a transaction and do not submit to the Aptos blockchain.

{% tabs %}
{% tab title="window\.fewcha" %}
**Method type**

```typescript
async signTransaction(
    rawTransaction: Uint8Array
): Promise<Response<Uint8Array>>;
```

**Example request**

```typescript
const receiverAddress = "0xcca3338dfda1b5e9bab0d744c3b50a9a24e3fe55bba48917307e813a4535e034";
const amount = 1000;

const payload = {
  type: "entry_function_payload",
  function: "0x1::coin::transfer",
  type_arguments: ["0x1::aptos_coin::AptosCoin"],
  arguments: [receiverAddress, amount],
};

const rawTransaction = await window.fewcha.generateTransaction(payload);
if (rawTransaction.status !== 200) return;

const signedTx = await window.fewcha.signTransaction(rawTransaction.data);

console.log("signedTx", signedTx);
```

**Example response**

```typescript
{
    "method": "signTransaction",
    "status": 200,
    "data": [...]
}
```

Response data: **Uint8Array**
{% endtab %}
{% endtabs %}

#### 2.3. Sign Message (Single signer)

{% tabs %}
{% tab title="signMessage" %}

```typescript
export interface SignMessagePayload {
  address?: boolean; // Should we include the address of the account in the message
  application?: boolean; // Should we include the domain of the dapp
  chainId?: boolean; // Should we include the current chain id the wallet is connected to
  message: string; // The message to be signed and displayed to the user
  nonce: string; // A nonce the dapp should generate
}

export interface SignMessageResponse {
  address: string;
  application: string;
  chainId: number;
  fullMessage: string; // The message that was generated to sign
  message: string; // The message passed in by the user
  nonce: string,
  prefix: string, // Should always be APTOS
  signature: string; // The signed full message
}
```

```typescript
async signMessage(message: SignMessagePayload):
    Promise<Response<SignMessageResponse>>
```

{% endtab %}
{% endtabs %}

### 3. Submit Transaction

#### 3.1 Submit Transaction (Single signer)

{% tabs %}
{% tab title="window\.fewcha" %}
**Method type**

```typescript
async submitTransaction(
    signedTxn: Uint8Array
): Promise<Response<Gen.HexEncodedBytes>>
```

**Example request**

```typescript
const receiverAddress = "0xcca3338dfda1b5e9bab0d744c3b50a9a24e3fe55bba48917307e813a4535e034";
const amount = 1000;

const payload = {
  type: "entry_function_payload",
  function: "0x1::coin::transfer",
  type_arguments: ["0x1::aptos_coin::AptosCoin"],
  arguments: [receiverAddress, amount],
};

const txnRequest = await window.fewcha.generateTransaction(payload);
if (!parseError(txnRequest.status)) return;

const signedTx = await window.fewcha.signTransaction(txnRequest.data);
if (!parseError(signedTx.status)) return;

const txnHash = await window.fewcha.submitTransaction(signedTx.data);
if (!parseError(txnHash.status)) return;

console.log("tx", txnHash);
```

**Example response**

```typescript
{
    "method": "submitTransaction",
    "status": 200,
    "data": "0x4af85fb48400715fda9c4ea9c3f2bad0c1d6995f6aa0be7f5ea6d74d4f5f7682"
}
```

Response data: **Gen.HexEncodedBytes**
{% endtab %}
{% endtabs %}

### 4. Simulate Transaction

Verify if the transaction is valid. You can use this function to estimate gas consumer.

#### 4.1. simulateTransaction (Single Signer, Multi-Sign)

{% tabs %}
{% tab title="window\.fewcha" %}
**Method type**

```typescript
async simulateTransaction(
    rawTransaction: Uint8Array
): Promise<Response<Gen.UserTransaction[]>>
```

**Example request**

```typescript
const receiverAddress = "0xcca3338dfda1b5e9bab0d744c3b50a9a24e3fe55bba48917307e813a4535e034";
const sendBalance = 1000;

const payload = {
  type: "entry_function_payload",
  function: "0x1::coin::transfer",
  type_arguments: ["0x1::aptos_coin::AptosCoin"],
  arguments: [receiverAddress, sendBalance],
};

const txnRequest = await window.fewcha.generateTransaction(payload);
if (!parseError(txnRequest.status)) return;

const siTx = await window.fewcha.simulateTransaction(txnRequest.data);
if (!parseError(siTx.status)) return;

console.log("siTx", siTx);
```

**Example response**

```typescript
{
    "method": "simulateTransaction",
    "status": 200,
    "data": [
        {
            "version": "19832615",
            "hash": "0x0000000000000000000000000000000000000000000000000000000000000000",
            "state_change_hash": "0x0000000000000000000000000000000000000000000000000000000000000000",
            "event_root_hash": "0x0000000000000000000000000000000000000000000000000000000000000000",
            "state_checkpoint_hash": null,
            "gas_used": "51",
            "success": true,
            "vm_status": "Executed successfully",
            "accumulator_root_hash": "0x0000000000000000000000000000000000000000000000000000000000000000",
            "changes": [...],
            "sender": "0x20364f4121f608f2a09830bc0ab6980fdccff45c2f5df6c41c17f40e511fe80e",
            "sequence_number": "12",
            "max_gas_amount": "2000",
            "gas_unit_price": "1",
            "expiration_timestamp_secs": "1661767977",
            "payload": {
                "function": "0x1::coin::transfer",
                "type_arguments": [
                    "0x1::aptos_coin::AptosCoin"
                ],
                "arguments": [
                    "0xcca3338dfda1b5e9bab0d744c3b50a9a24e3fe55bba48917307e813a4535e034",
                    "1000"
                ],
                "type": "entry_function_payload"
            },
            "signature": {
                "public_key": "0x89a10bded6d812d21299ee129410d53a74f12f91183989c19282fa24ce629b49",
                "signature": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
                "type": "ed25519_signature"
            },
            "events": [
                {
                    "key": "0x030000000000000020364f4121f608f2a09830bc0ab6980fdccff45c2f5df6c41c17f40e511fe80e",
                    "sequence_number": "9",
                    "type": "0x1::coin::WithdrawEvent",
                    "data": {
                        "amount": "1000"
                    }
                },
                {
                    "key": "0x0200000000000000cca3338dfda1b5e9bab0d744c3b50a9a24e3fe55bba48917307e813a4535e034",
                    "sequence_number": "10",
                    "type": "0x1::coin::DepositEvent",
                    "data": {
                        "amount": "1000"
                    }
                }
            ],
            "timestamp": "1661767957293402"
        }
    ]
}
```

Response data: **Gen.UserTransaction\[]** (array of Gen.UserTransaction)
{% endtab %}
{% endtabs %}

Learn more about **response data types** at [Response Format and Types](/response-format-and-types.md)

### 5. Supported methods

```typescript
generateTransaction(
  payload: Gen.EntryFunctionPayload,
  options?: Partial<Gen.SubmitTransactionRequest>,
): Promise<Uint8Array>;
generateRawTransaction(payload: Uint8Array, extraArgs?: OptionalTransactionArgs): Promise<Uint8Array>;
generateMultiAgentTransaction(
  payload: Gen.EntryFunctionPayload,
  secondarySenders: MaybeHexString[],
  options?: Partial<Gen.SubmitTransactionRequest>,
): Promise<Uint8Array>;
generateSignSubmitTransaction(
  payload: Gen.EntryFunctionPayload,
  extraArgs?: Partial<Gen.SubmitTransactionRequest>,
): Promise<Gen.HexEncodedBytes>;
generateSignSubmitRawTransaction(
  payload: Uint8Array,
  extraArgs?: {
    maxGasAmount?: BCS.Uint64;
    gasUnitPrice?: BCS.Uint64;
    expireTimestamp?: BCS.Uint64;
    checkSuccess?: boolean;
    timeoutSecs?: number;
  },
): Promise<Gen.HexEncodedBytes>;
generateSignSubmitWaitForTransaction(
  payload: Uint8Array,
  extraArgs?: {
    maxGasAmount?: BCS.Uint64;
    gasUnitPrice?: BCS.Uint64;
    expireTimestamp?: BCS.Uint64;
    checkSuccess?: boolean;
    timeoutSecs?: number;
  },
): Promise<Gen.Transaction>;
signMessage(message: SignMessagePayload): Promise<SignMessageResponse>;
signBuffer(buffer: Uint8Array): Promise<HexString>;
simulateTransaction(
  rawTransaction: Uint8Array,
  query?: {
    estimateGasUnitPrice?: boolean;
    estimateMaxGasAmount?: boolean;
    estimatePrioritizedGasUnitPrice: boolean;
  },
): Promise<Gen.UserTransaction[]>;
simulateMultiAgentTransaction(
  multiAgentTxn: Uint8Array,
  addresses: MaybeHexString[],
  publicKeys: MaybeHexString[],
  query?: {
    estimateGasUnitPrice?: boolean;
    estimateMaxGasAmount?: boolean;
    estimatePrioritizedGasUnitPrice?: boolean;
  },
): Promise<Gen.UserTransaction[]>;
signTransaction(rawTransaction: Uint8Array): Promise<Uint8Array>;
signMultiAgentTransaction(rawMultiAgentTransaction: Uint8Array): Promise<Uint8Array>;
signMultiSignTransaction(rawTransaction: Uint8Array): Promise<Uint8Array>;
submitTransaction(signedTxn: Uint8Array): Promise<Gen.HexEncodedBytes>;
submitSignedBCSMultiAgentTransaction(
  multiAgentTxn: Uint8Array,
  addresses: MaybeHexString[],
  publicKeys: MaybeHexString[],
  _signatures: Uint8Array[],
): Promise<Gen.HexEncodedBytes>;
submitSignedBCSMultiSignTransaction(
  rawTxn: Uint8Array,
  bitmap: number[],
  multiSignPubKey: MaybeHexString,
  _signatures: Uint8Array[],
): Promise<Gen.HexEncodedBytes>;
signAndSubmitTransaction(rawTransaction: Uint8Array): Promise<Gen.HexEncodedBytes>;
generateBCSTransaction(rawTransaction: Uint8Array): Promise<Uint8Array>;
generateBCSSimulation(rawTransaction: Uint8Array): Promise<Uint8Array>;
submitSignedBCSTransaction(signedTxn: Uint8Array): Promise<Gen.HexEncodedBytes>;
submitBCSSimulation(
  bcsBody: Uint8Array,
  query?: {
    estimateGasUnitPrice?: boolean;
    estimateMaxGasAmount?: boolean;
    estimatePrioritizedGasUnitPrice: boolean;
  },
): Promise<Gen.UserTransaction[]>;
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.fewcha.app/reference/wallet-methods/transactions/aptos-transaction.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.