# Manage through ABI

**Step 1: Generate the payload for your requirement**

```typescript
// Initialize the ABI coder from the ethers library for encoding transaction data.
const coder = ethers.AbiCoder.defaultAbiCoder();

// Encode the user's Solana address as a `bytes32` format for Ethereum compatibility.
// The Solana address is converted to a byte array and then encoded.
const userAddress = coder.encode(
  ["bytes32"],
  [Buffer.from(new PublicKey("6v9YRMJbiXSjwco3evS2XdNuqPbwzKf3ykmn5iQJ4UyF").toBytes())]
); // Solana address corresponding to Ethereum address

// Encode the USDT contract address as a `bytes32` format. 
// The contract address is converted from a hex string and padded to 32 bytes for standardization.
const contract_address = coder.encode(
  ["bytes32"],
  [ethers.zeroPadValue(Buffer.from(hexStringToUint8Array('0xaA8E23Fb1079EA71e0a56F48a2aA51851D8433D0')), 32)]
); // USDT contract address on Ethereum

// Define the ABI for the `transfer` function of the USDT contract.
// The `transfer` function sends tokens to a specified address with a specified value.
let ABI = ["function transfer(address to, uint256 value) returns (bool)"];

// Create an `ethers.Interface` instance for interacting with the USDT contract.
let iface = new ethers.Interface(ABI);

// Encode the `transfer` function data. This includes the recipient address and transfer amount.
// USDT has 6 decimal places, so `100000000` represents 100 USDT.
let paras = iface.encodeFunctionData("transfer", [
  '0xa550C6011DfBA4925abEb0B48104062682870BB8', // Recipient address
  BigInt('100000000') // Transfer amount: 100 USDT (6 decimals)
]);

// Prepare a payload part by encoding the contract address, an unused parameter (0), and the `transfer` function data.
let payload_part = coder.encode(
  ["bytes32", "uint256", "bytes"],
  [contract_address, 0, paras]
);

// Finally, assemble the full payload by encoding the user's address and the payload part.
const payload = coder.encode(["bytes32", "bytes"], [userAddress, payload_part]);

// Output the assembled payload for inspection or further processing.
console.log(payload);

```

**Step 2: Call Ethereum smart contract using this payload**

```typescript
// Encode the Solana address as a bytes32 format, compatible with Ethereum.
const solanaAddress = coder.encode(
  ["bytes32"],
  [Buffer.from(new PublicKey("your-solana-account").toBytes())]
);

// Encode the target Ethereum contract address, padded to 32 bytes for consistency.
const contractAddress = coder.encode(
  ["bytes32"],
  [ethers.utils.zeroPad(Buffer.from([contractAddressYouWantToCall]), 32)]
);

// Define the ABI for the Ethereum contract's "store" function, which accepts a uint256 parameter.
let ABI = ["function store(uint256 num)"];

// Create an ethers Interface instance to encode the function call data.
let iface = new ethers.utils.Interface(ABI);

// Encode the function call for the "store" function with a parameter value of 2.
let params = iface.encodeFunctionData("store", [2]);

// Assemble the payload part by encoding the contract address, a placeholder value (0), and the encoded function data.
let payloadPart = coder.encode(
  ["bytes32", "uint256", "bytes"],
  [contractAddress, 0, params]
);

// Final payload: combine the Solana address and the payload part into a single message.
const payload = coder.encode(
  ["bytes32", "bytes"],
  [solanaAddress, payloadPart]
);

// Send the message using the Solana program (via the Anchor framework).
const programID = new PublicKey("solana-program-address"); // The Solana program ID.
const program = new anchor.Program(idl, programID); // Anchor program instance.
const message = hexStringToUint8Array(payload); // Convert payload to a byte array.

// Create the instruction to send the message to the Solana program.
const ix3 = program.methods
  .sendMessage(Buffer.from(message)) // Pass the message as a buffer.
  .accounts({
    config: realConfig, // Real configuration for the program.
    wormholeProgram: CORE_BRIDGE_PID, // Wormhole program ID for cross-chain communication.
    ...wormholeAccounts2, // Additional necessary accounts for the transaction.
  })
  .instruction();

// Create a new transaction and add the instruction.
const tx3 = new Transaction().add(await ix3);

try {
  const commitment: Commitment = 'confirmed'; // Set the commitment level for transaction confirmation.
  
  // Send the transaction and await confirmation.
  await sendAndConfirmTransaction(provider.connection, tx3, [yourSolanaAccount], { commitment });
} catch (error) {
  // Catch and log any errors during the transaction submission process.
  console.error("Error submitting transaction:", error);
}

```


---

# 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.bolarity.xyz/quick-start/cross-chain-asset-management/manage-through-abi.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.