# Transaction

To create the transaction with wallet

### ETH Transaction

#### 1. Build ETH Transaction

To create an Ethereum transaction, use the `ETHTransactionRequest` with the following attributes:

* create a new Build `ETHTransactionRequest` should include the following attributes:
  * `chainID` : Chain ID (e.g., Ethereum is 1).
  * `toAddress` : Recipient's wallet address.
  * `amount` : Amount to transfer.
  * `gasPrice` : Gas price per unit.
  * `gasLimit` : Maximum gas allowed for the transaction.
  * `nonce` : Transaction count for the sender's account.
  * `data` : Optional additional data for the transaction.
  * `paillierGroupID` : User's Paillier group ID.
  * `keyGenGroupID` : the keygen Group ID of master wallet
  * `keyIdentity` : the keyIdentity of wallet
  * `ecType`: Cryptographic algorithm type (e.g., `eddsa`, `ecdsa`)

**Example**:

```kotlin
    val rawTxBytes = BuildETHTransactionRequest(
        chainID = "1",
        toAddress = "0xRecipientAddress",
        amount = "10000",
        gasPrice = "20000000000",
        gasLimit = "21000",
        nonce = "0",
        data = null,
        paillierGroupID = "paillierGroupID",
        keyGenGroupID = "keyGenGroupID",
        keyIdentity = "walletKeyIdentity",
        ecType = "ecdsa"
    )
    val rawTransaction = client.buildETHTransaction(rawTxBytes)
```

#### 2. Send ETH Transaction with Web3

**Example**:

```kotlin
    val web3j = Web3j.build(HttpService("https://mainnet.infura.io/v3/YOUR_INFURA_PROJECT_ID"))
    val transactionResponse = web3j.ethSendRawTransaction(rawTxBytes).send()
    val transactionHash = transactionResponse.transactionHash
```

### SOLANA Transaction

#### 1. Build Solana Transaction

* create a new Build `BuildSolTransactionRequest` should include the following attributes:
  * chainID: Chain ID (e.g., Solana mainnet is 501).
  * fromAddress: Sender's wallet address.
  * toAddress: Recipient's wallet address.
  * Amount: Amount to transfer.
  * paillierGroupID: User's Paillier group ID.
  * keyGenGroupID: Master wallet's key generation group ID.
  * KkeyIdentity: the keyIdentity of wallet
  * eCType: Cryptographic algorithm type (e.g., eddsa, ecdsa).

**Example**:

```kotlin
   val rawTxBytes = BuildSolTransactionRequest(
        chainID = "501",
        fromAddress = "SenderAddress",
        toAddress = "RecipientAddress",
        amount = "10000",
        paillierGroupID = "paillierGroupID",
        keyGenGroupID = "keyGenGroupID",
        keyIdentity = "walletKeyIdentity",
        ecType = "eddsa"
    )
    val rawTransaction = client.buildSolTransaction(rawTxBytes)

```

#### 2. Send SOLANA Transaction

* Use a Solana library to send the raw transaction. Encode the raw transaction to Base58 before sending. **Example**:

```kotlin
    val rpc = RPC("https://api.mainnet-beta.solana.com")
    val rawTXBase58 = Base58Util.encodeBase58(rawTxBytes)
    val transactionHash = rpc.sendTransaction(rawTXBase58)
```

### TRON Transaction

#### 1. Build TRON Transaction

* create a new Build `BuildTronTransactionRequest` should include the following attributes:
  * chainID: Chain ID (e.g., Tron mainnet is 728, testnet is 939).
  * fromAddress: Sender's wallet address.
  * toAddress: Recipient's wallet address.
  * amount: Amount to transfer.
  * paillierGroupID: User's Paillier group ID.
  * keyGenGroupID: Master wallet's key generation group ID.
  * KkeyIdentity: the keyIdentity of wallet
  * eCType: Cryptographic algorithm type (e.g., eddsa, ecdsa).

**Example**:

```kotlin
   val rawTxBytes = BuildTronTransactionRequest(
        chainID = "728",
        fromAddress = "SenderAddress",
        toAddress = "RecipientAddress",
        amount = "10000",
        paillierGroupID = "paillierGroupID",
        keyGenGroupID = "keyGenGroupID",
        keyIdentity = "walletKeyIdentity",
        ecType = "eddsa"
    )
    val rawTransaction = client.buildTronTransaction(rawTxBytes)

```

#### 2. Send TRON Transaction

* Use a TRON library to send the raw transaction. Encode the raw transaction to Base58 before sending. **Example**:

```kotlin
    val rpc = RPC("https://api.shasta.trongrid.io")
    val transactionHash = rpc.sendTransaction(rawTxBytes)
```

### TON Coin Transaction

#### 1. Build TON CoinTransaction

* create a new Build `BuildTonTransactionRequest` should include the following attributes:
  * chainID: Chain ID (e.g., Ton mainnet is ton, testnet is ton-testnet).
  * fromAddress: Sender's wallet address.
  * toAddress: Recipient's wallet address.
  * amount: Amount to transfer.
  * paillierGroupID: User's Paillier group ID.
  * keyGenGroupID: Master wallet's key generation group ID.
  * keyIdentity: the keyIdentity of wallet
  * ellipticCurveType: Cryptographic algorithm type (e.g., eddsa, ecdsa).
  * derivationPath: derivation Path of Ton chain "m/44'/607'/0'"
  * subwallet: The type of ton wallet v3r2 (698983191)
  * comment: memo of transaction
  * bounce: the transaction to bounce (true, false)

**Example**:

```kotlin

    val rqTon = BuildTonTransactionRequest(
        keyGenGroupID = "keygenGroupId"
        paillierGroupID = "paillierGroupId"
        keyIdentity = "keyIdentity"
        ellipticCurveType = "eddsa"
        derivationPath = "derivationPath"
        chainID = "ton-testnet"
        toAddress = "toAddress"
        fromAddress = "fromAddress"
        amount = "amount"
        subwallet = "subWallet"
        comment = "memo"
        bounce = true
    )

    val rawTxBytes = client.buildTonTransaction(rqTon)

```

#### 2. Send TON Coin Transaction

* Use a TON library to send the raw transaction. Encode the raw transaction to Base58 before sending. **Example**:

```kotlin
    val rpc = RPC("https://main.us.mpc.memigma.io/proxy/ton/sendBocReturnHash")
    val bocTx = Base64.encodeToString(data, Base64.DEFAULT);
    val transactionHash = rpc.sendBocReturnHash(bocTx)
```

### Bitcoin Transaction

#### 1. Build Bitcoin Transaction

* create a new Build `BuildBtcTransactionRequest` should include the following attributes:
  * chainID: Chain ID (e.g., BTC mainnet is btc, testnet is btc-testnet).
  * fromAddress: Sender's wallet address.
  * receiverAddress: Recipient's wallet address.
  * amount: Amount to transfer.
  * paillierGroupID: User's Paillier group ID.
  * keyGenGroupID: Master wallet's key generation group ID.
  * keyIdentity: the keyIdentity of wallet
  * ellipticCurveType: Cryptographic algorithm type (e.g., eddsa, ecdsa).
  * IgnoringFee: The flag used to skip fee enforcement on testnet. This should always be set to false on mainnet.

**Example**:

```kotlin

    val rqBTC = BuildBtcTransactionRequest(
        chainId = "chainId"
        fromAddress = "fromAddress"
        receiverAddress = "toAddress"
        amount = "amount"
        ellipticCurveType = "ecType"
        paillierGroupID = "paillierGroupId"
        keyGenGroupID = "keygenGroupId"
        keyIdentity = "keyIdentity"
        derivationPath = "derivationPath"
        IgnoringFee = true
    )`

    val rawTxBytes = client.buildBtcTransaction(rqBTC)

```

#### 2. Send Bitcoin Transaction

* Use a BTC library to send the raw transaction. Encode the raw transaction to Base58 before sending. **Example**:

```kotlin
    val rpc = RPC("https://blockstream.info/testnet/api/tx")
    val transactionHash = rpc.sendTransaction(rawTxBytes)
```

### XRP  Transaction

#### Build XRP Transaction <a href="#id-1-build-xrp-transaction" id="id-1-build-xrp-transaction"></a>

To create an XRP transaction, use the `buildXrpTransaction` method with the following attributes:

* `paillierGroupId`: The Paillier group ID associated with your wallet.
* `keygenGroupId`: The Keygen group ID of your master wallet.
* `wallet`: The current wallet object containing details like `keyIdentity`, `ecType`, etc.
* `toAddress`: The recipient's XRP wallet address.
* `fromAddress`: The sender's XRP wallet address.
* `chainId`: The ID of the XRP chain or network.
* `amount`: The amount of XRP to send.
* `keygenGroupServerShard`: The server shard of the Keygen group that was saved in secure storage.
* `paillierGroupServerShard`: The server shard of the Paillier group that was saved in secure storage.

**Example**:

```kotlin
fun main() {
    val paillierGroupID = "paillierGroupID"
    val keygenGroupID = "keygenGroupID"
    val currentWallet = Wallet(/*...*/) // Your initialized wallet
    val recipientXrpAddress = "rRecipientXRPAddress"
    val senderXrpAddress = "rSenderXRPAddress"
    val chainID = "XRPChainID"
    val amountToSend = "1000"

    // Shards retrieved from your secure storage
    val keygenShardBytes = /* Keygen group server shard bytes */
    val paillierShardBytes = /* Paillier group server shard bytes */

    // Build the XRP transaction
    val rawTxFlow = buildXrpTransaction(
        paillierGroupId = paillierGroupID,
        keygenGroupId = keygenGroupID,
        wallet = currentWallet,
        toAddress = recipientXrpAddress,
        fromAddress = senderXrpAddress,
        chainId = chainID,
        amount = amountToSend,
        keygenGroupServerShard = keygenShardBytes,
        paillierGroupServerShard = paillierShardBytes
    )

    // Retrieve the raw transaction bytes
    val rawTransactionBytes = rawTxFlow.first()
    println("Raw XRP Transaction Bytes: $rawTransactionBytes")
}
```


---

# 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://cramiumlabs.gitbook.io/docs/sdk-mpc-android/usage-guide-for-an-mpc-wallet-app/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.