sendTransaction

Send a TBC chain transaction. Supports a wide range of operations including P2PKH transfers, NFT operations, FT operations, PoolNFT liquidity management, and stablecoin operations.

Usage

const params = [{ flag: "P2PKH", address: "recipient", satoshis: 10000 }];
const { txid } = await Turing.sendTransaction(params);

Interface Definitions

interface FTData {
  name: string;
  symbol: string;
  decimal: number;
  amount: number;
}

interface CollectionData {
  collectionName: string;
  description: string;
  supply: number;
  file: string; // base64
}

interface NFTData {
  nftName: string;
  symbol: string;
  description: string;
  attributes: string;
  file?: string; // base64
}

interface RequestParam {
  flag: "P2PKH" | "COLLECTION_CREATE" | "NFT_CREATE" | "NFT_TRANSFER" | "FT_MINT" | "FT_TRANSFER" | "FT_MERGE" | "POOLNFT_MINT" | "POOLNFT_INIT" | "POOLNFT_LP_INCREASE" | "POOLNFT_LP_CONSUME" | "POOLNFT_LP_BURN" | "POOLNFT_SWAP_TO_TOKEN" | "POOLNFT_SWAP_TO_TBC" | "POOLNFT_MERGE" | "FTLP_MERGE" | "STABLECOIN_TRANSFER" | "STABLECOIN_MERGE";
  address?: string;
  satoshis?: number | string;              // In satoshis, use string for large numbers
  collection_data?: string;
  ft_data?: string;
  nft_data?: string;
  collection_id?: string;
  nft_contract_address?: string;
  ft_contract_address?: string;            // FT or stablecoin contract transaction ID
  tbc_amount?: number | string;            // Use string for large numbers
  ft_amount?: number | string;             // Use string for large numbers
  merge_times?: number;
  with_lock?: boolean;
  lpCostAddress?: string;
  lpCostAmount?: number | string;          // Use string for large numbers
  pubKeyLock?: string[];
  poolNFT_version?: 1 | 2;                // Forced to 2, other values will be converted to 2
  serviceFeeRate?: number;
  serverProvider_tag?: string;
  lpPlan?: 1 | 2 | 3 | 4 | 5;              // Defaults to 1
  domain?: string;
  isLockTime?: boolean;
  lockTime?: number | string;              // Lock until specified block height (POOLNFT related), use string for large numbers
  broadcastEnabled?: boolean;
}

const params = [param: RequestParam];

Returns

interface SendTransactionResponse {
  txid?: string;   // Transaction ID (when broadcastEnabled is true)
  txraw?: string;  // Raw signed transaction hex (when broadcastEnabled is false)
  error?: string;  // Error message on failure
}

Field	Type	Description
txid	string	Transaction ID on successful broadcast
txraw	string	Raw transaction hex when broadcastEnabled is false
error	string	Error message if the transaction fails

Error Handling

const result = await Turing.sendTransaction(params);

if (result.error) {
  console.error("Transaction failed:", result.error);
  return;
}

console.log("Success! txid:", result.txid);

Transaction Types

P2PKH

Send a standard P2PKH transaction to transfer TBC to a recipient address.

const params = [
  {
    flag: "P2PKH",               // Required
    address: "",                  // Required, recipient address
    satoshis: 0,                  // Required, amount in satoshis
    broadcastEnabled: true,       // Optional, defaults to true
    domain: "",                   // Optional, defaults to api.turingbitchain.io
  },
];

const { txid } = await Turing.sendTransaction(params); // When broadcastEnabled is true
// const { txraw } = await Turing.sendTransaction(params); // When broadcastEnabled is false
// const { error } = await Turing.sendTransaction(params); // When an error occurs

COLLECTION_CREATE

Create a new NFT collection with metadata including name, description, supply, and an image file.

const params = [
  {
    flag: "COLLECTION_CREATE",    // Required
    collection_data: "",          // Required, CollectionData in JSON format
    broadcastEnabled: true,       // Optional, defaults to true
    domain: "",                   // Optional
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // When broadcastEnabled is false
// const { error } = await Turing.sendTransaction(params); // When an error occurs

NFT_CREATE

Create a new NFT within an existing collection.

const params = [
  {
    flag: "NFT_CREATE",           // Required
    collection_id: "",            // Required, collection ID
    nft_data: "",                 // Required, NFTData in JSON format
    broadcastEnabled: true,       // Optional, defaults to true
    domain: "",                   // Optional
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // When broadcastEnabled is false
// const { error } = await Turing.sendTransaction(params); // When an error occurs

NFT_TRANSFER

Transfer an NFT to another address.

const params = [
  {
    flag: "NFT_TRANSFER",         // Required
    nft_contract_address: "",     // Required, NFT contract address
    address: "",                  // Required, recipient address
    broadcastEnabled: true,       // Optional, defaults to true
    domain: "",                   // Optional
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // When broadcastEnabled is false
// const { error } = await Turing.sendTransaction(params); // When an error occurs

FT_MINT

Mint a new fungible token with specified name, symbol, decimal places, and initial supply.

const params = [
  {
    flag: "FT_MINT",              // Required
    ft_data: "",                  // Required, FTData in JSON format
    broadcastEnabled: true,       // Optional, defaults to true
    domain: "",                   // Optional
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // When broadcastEnabled is false, the returned txraw contains two transactions separated by commas, which need to be broadcast in batch, ensuring the first txraw is broadcast first
// const { error } = await Turing.sendTransaction(params); // When an error occurs

FT_TRANSFER

Transfer fungible tokens to a recipient. Optionally transfer TBC simultaneously.

const params = [
  {
    flag: "FT_TRANSFER",          // Required
    ft_contract_address: "",      // Required, FT contract address
    address: "",                  // Required, recipient address
    ft_amount: 0,                 // Required, FT amount to transfer
    tbc_amount: 0,                // Optional, TBC amount to transfer simultaneously, defaults to 0
    broadcastEnabled: true,       // Optional, defaults to true
    domain: "",                   // Optional
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // When broadcastEnabled is false
// const { error } = await Turing.sendTransaction(params); // When an error occurs

FT_MERGE

Merge FT UTXOs to consolidate fragmented token holdings.

const params = [
  {
    flag: "FT_MERGE",             // Required
    ft_contract_address: "",      // Required, FT contract address
    domain: "",                   // Optional
  },
];

const { txid } = await Turing.sendTransaction(params); // txid is multiple Merge transaction txids separated by commas
// const { error } = await Turing.sendTransaction(params); // When an error occurs

POOLNFT_MINT

Mint a PoolNFT to create a new liquidity pool for a fungible token. Supports optional hash lock and lock time configurations.

const params = [
  {
    flag: "POOLNFT_MINT",         // Required
    ft_contract_address: "",      // Required, FT contract address
    serverProvider_tag: "",       // Required, service provider tag
    poolNFT_version: 2,           // Optional, forced to 2
    serviceFeeRate: 25,           // Optional, any positive integer, defaults to 25
    with_lock: false,             // Optional, defaults to false; when true, creates a poolNFT with hash lock
    pubKeyLock: ["pubkey1", "pubkey2"], // Required when with_lock is true
    lpCostAddress: "",            // Required when with_lock is true, address for deducting liquidity addition costs
    lpCostAmount: 0,              // Required when with_lock is true, TBC amount for deducting liquidity addition costs
    lpPlan: 1,                    // Optional, 1-5, defaults to 1
    isLockTime: false,            // Optional, defaults to false
    broadcastEnabled: true,       // Optional, defaults to true
    domain: "",                   // Optional
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // When broadcastEnabled is false, the returned txraw contains two transactions separated by commas, which need to be broadcast in batch, ensuring the first txraw is broadcast first
// const { error } = await Turing.sendTransaction(params); // When an error occurs

POOLNFT_INIT

Initialize a PoolNFT liquidity pool with initial TBC and FT amounts.

const params = [
  {
    flag: "POOLNFT_INIT",         // Required
    nft_contract_address: "",     // Required, PoolNFT contract address
    address: "",                  // Required, recipient address
    tbc_amount: 0,                // Required, initial TBC amount
    ft_amount: 0,                 // Required, initial FT amount
    poolNFT_version: 2,           // Optional, forced to 2
    lockTime: 0,                  // Optional, lock until the specified block height
    broadcastEnabled: true,       // Optional, defaults to true
    domain: "",                   // Optional
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // When broadcastEnabled is false
// const { error } = await Turing.sendTransaction(params); // When an error occurs

POOLNFT_LP_INCREASE

Increase liquidity in a PoolNFT pool by adding TBC.

const params = [
  {
    flag: "POOLNFT_LP_INCREASE",  // Required
    nft_contract_address: "",     // Required, PoolNFT contract address
    address: "",                  // Required, recipient address
    tbc_amount: 0,                // Required, TBC amount to add
    poolNFT_version: 2,           // Optional, forced to 2
    lockTime: 0,                  // Optional, lock until the specified block height
    broadcastEnabled: true,       // Optional, defaults to true
    domain: "",                   // Optional
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // When broadcastEnabled is false
// const { error } = await Turing.sendTransaction(params); // When an error occurs

POOLNFT_LP_CONSUME

Consume liquidity from a PoolNFT pool by redeeming LP tokens.

const params = [
  {
    flag: "POOLNFT_LP_CONSUME",   // Required
    nft_contract_address: "",     // Required, PoolNFT contract address
    address: "",                  // Required, recipient address
    ft_amount: 0,                 // Required, FT LP amount to consume
    poolNFT_version: 2,           // Optional, forced to 2
    lockTime: 0,                  // Optional, manually set unlock parameters to the maximum unlockable block height. If lock-up is enabled without this parameter, unlock parameters will be automatically set to (current block height - 2)
    broadcastEnabled: true,       // Optional, defaults to true
    domain: "",                   // Optional
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // When broadcastEnabled is false
// const { error } = await Turing.sendTransaction(params); // When an error occurs

POOLNFT_LP_BURN

Burn all LP tokens from a PoolNFT pool.

const params = [
  {
    flag: "POOLNFT_LP_BURN",      // Required
    nft_contract_address: "",     // Required, PoolNFT contract address
    poolNFT_version: 2,           // Optional, forced to 2
    broadcastEnabled: true,       // Optional, defaults to true
    domain: "",                   // Optional
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // When broadcastEnabled is false
// const { error } = await Turing.sendTransaction(params); // When an error occurs

POOLNFT_SWAP_TO_TOKEN

Swap TBC for tokens in a PoolNFT liquidity pool.

const params = [
  {
    flag: "POOLNFT_SWAP_TO_TOKEN", // Required
    nft_contract_address: "",      // Required, PoolNFT contract address
    address: "",                   // Required, recipient address
    tbc_amount: 0,                 // Required, TBC amount to swap
    poolNFT_version: 2,            // Optional, forced to 2
    lpPlan: 1,                     // Optional, 1-5, defaults to 1
    broadcastEnabled: true,        // Optional, defaults to true
    domain: "",                    // Optional
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // When broadcastEnabled is false
// const { error } = await Turing.sendTransaction(params); // When an error occurs

POOLNFT_SWAP_TO_TBC

Swap tokens for TBC in a PoolNFT liquidity pool.

const params = [
  {
    flag: "POOLNFT_SWAP_TO_TBC",  // Required
    nft_contract_address: "",     // Required, PoolNFT contract address
    address: "",                  // Required, recipient address
    ft_amount: 0,                 // Required, FT amount to swap
    poolNFT_version: 2,           // Optional, forced to 2
    lpPlan: 1,                    // Optional, 1-5, defaults to 1
    broadcastEnabled: true,       // Optional, defaults to true
    domain: "",                   // Optional
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // When broadcastEnabled is false
// const { error } = await Turing.sendTransaction(params); // When an error occurs

POOLNFT_MERGE

Merge PoolNFT-related UTXOs to consolidate pool state.

const params = [
  {
    flag: "POOLNFT_MERGE",        // Required
    nft_contract_address: "",     // Required, PoolNFT contract address
    poolNFT_version: 2,           // Optional, forced to 2
    merge_times: 10,              // Optional, 1-10 times, defaults to 10, terminates early if fewer
    domain: "",                   // Optional
  },
];

const { txid } = await Turing.sendTransaction(params); // txid is multiple Merge transaction txids separated by commas
// const { error } = await Turing.sendTransaction(params); // When an error occurs

FTLP_MERGE

Merge FTLP UTXOs to consolidate LP token holdings.

const params = [
  {
    flag: "FTLP_MERGE",           // Required
    nft_contract_address: "",     // Required, PoolNFT contract address
    poolNFT_version: 2,           // Optional, forced to 2
    lockTime: 0,                  // Optional, manually set unlock parameters to the maximum unlockable block height. If lock-up is enabled without this parameter, unlock parameters will be automatically set to (current block height - 2)
    domain: "",                   // Optional
  },
];

const { txid } = await Turing.sendTransaction(params); // txid is multiple Merge transaction txids separated by commas
// const { error } = await Turing.sendTransaction(params); // When an error occurs

STABLECOIN_TRANSFER

Transfer stablecoins to a recipient address. Optionally transfer TBC simultaneously.

const params = [
  {
    flag: "STABLECOIN_TRANSFER",     // Required
    ft_contract_address: "",         // Required, stablecoin contract transaction ID
    address: "",                     // Required, recipient address
    ft_amount: 1000,                 // Required, transfer amount, use string for large numbers
    tbc_amount: 0,                   // Optional, set this value when transferring both TBC and stablecoins
    broadcastEnabled: true,          // Optional, defaults to true
    domain: "",                      // Optional
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // When broadcastEnabled is false
// const { error } = await Turing.sendTransaction(params); // When an error occurs

STABLECOIN_MERGE

Merge stablecoin UTXOs to consolidate holdings (requires all coinutxos to be on-chain).

const params = [
  {
    flag: "STABLECOIN_MERGE",        // Required
    ft_contract_address: "",         // Required, stablecoin contract transaction ID
    domain: "",                      // Optional
  },
];

const { txid } = await Turing.sendTransaction(params); // txid is multiple Merge transaction txids separated by commas
// const { error } = await Turing.sendTransaction(params); // When an error occurs