Skip to content

sendTransaction

发送 TBC 链交易。支持多种操作类型,包括 P2PKH 转账、NFT 操作、FT 操作、PoolNFT 流动性管理和稳定币操作。

用法

ts
const params = [{ flag: "P2PKH", address: "收款地址", satoshis: 10000 }];
const { txid } = await Turing.sendTransaction(params);

接口定义

ts
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;      // NFT 名称
  symbol: string;       // NFT 符号
  description: string;  // NFT 描述
  attributes: string;   // NFT 属性
  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;              // 单位为 satoshis,大数请使用 string
  collection_data?: string;
  ft_data?: string;
  nft_data?: string;
  collection_id?: string;
  nft_contract_address?: string;
  ft_contract_address?: string;            // FT 或稳定币合约交易 ID
  tbc_amount?: number | string;            // 大数请使用 string
  ft_amount?: number | string;             // 大数请使用 string
  merge_times?: number;
  with_lock?: boolean;
  lpCostAddress?: string;
  lpCostAmount?: number | string;          // 大数请使用 string
  pubKeyLock?: string[];
  poolNFT_version?: 1 | 2;                // 强制为 2,若提供为别的值转为 2
  serviceFeeRate?: number;
  serverProvider_tag?: string;
  lpPlan?: 1 | 2 | 3 | 4 | 5;              // 默认 1
  domain?: string;
  isLockTime?: boolean;
  lockTime?: number | string;              // 锁仓至指定区块高度(POOLNFT 相关),大数请使用 string
  broadcastEnabled?: boolean;
}

const params = [param: RequestParam];

返回值

ts
interface SendTransactionResponse {
  txid?: string;   // 交易 ID(broadcastEnabled 为 true 时)
  txraw?: string;  // 签名后的原始交易 hex(broadcastEnabled 为 false 时)
  error?: string;  // 错误信息
}
字段类型说明
txidstring广播成功后的交易 ID
txrawstringbroadcastEnabledfalse 时返回的原始交易 hex
errorstring交易失败时的错误信息

错误处理

ts
const result = await Turing.sendTransaction(params);

if (result.error) {
  console.error("交易失败:", result.error);
  return;
}

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

交易类型

P2PKH

发送标准 P2PKH 交易。

ts
const params = [
  {
    flag: "P2PKH",               // 必填
    address: "",                  // 必填,接收地址
    satoshis: 0,                  // 必填,转账金额,单位:聪
    broadcastEnabled: true,       // 可选,默认 true
    domain: "",                   // 可选,默认 api.turingbitchain.io
  },
];

const { txid } = await Turing.sendTransaction(params); // broadcastEnabled 为 true 时
// const { txraw } = await Turing.sendTransaction(params); // broadcastEnabled 为 false 时
// const { error } = await Turing.sendTransaction(params); // 发生错误时

COLLECTION_CREATE

创建新的 NFT 集合。

ts
const params = [
  {
    flag: "COLLECTION_CREATE",    // 必填
    collection_data: "",          // 必填,JSON 格式的 CollectionData
    broadcastEnabled: true,       // 可选,默认 true
    domain: "",                   // 可选
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // broadcastEnabled 为 false 时
// const { error } = await Turing.sendTransaction(params); // 发生错误时

NFT_CREATE

创建新的 NFT。

ts
const params = [
  {
    flag: "NFT_CREATE",           // 必填
    collection_id: "",            // 必填,集合 ID
    nft_data: "",                 // 必填,JSON 格式的 NFTData
    broadcastEnabled: true,       // 可选,默认 true
    domain: "",                   // 可选
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // broadcastEnabled 为 false 时
// const { error } = await Turing.sendTransaction(params); // 发生错误时

NFT_TRANSFER

将 NFT 转移到另一个地址。

ts
const params = [
  {
    flag: "NFT_TRANSFER",         // 必填
    nft_contract_address: "",     // 必填,NFT 合约地址
    address: "",                  // 必填,接收地址
    broadcastEnabled: true,       // 可选,默认 true
    domain: "",                   // 可选
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // broadcastEnabled 为 false 时
// const { error } = await Turing.sendTransaction(params); // 发生错误时

FT_MINT

铸造同质化代币。

ts
const params = [
  {
    flag: "FT_MINT",              // 必填
    ft_data: "",                  // 必填,JSON 格式的 FTData
    broadcastEnabled: true,       // 可选,默认 true
    domain: "",                   // 可选
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // broadcastEnabled 为 false 时,返回的 txraw 有两个,用逗号隔开,需批量广播,保证前面的 txraw 先广播
// const { error } = await Turing.sendTransaction(params); // 发生错误时

FT_TRANSFER

转移同质化代币。

ts
const params = [
  {
    flag: "FT_TRANSFER",          // 必填
    ft_contract_address: "",      // 必填,FT 合约地址
    address: "",                  // 必填,接收地址
    ft_amount: 0,                 // 必填,转移的 FT 数量
    tbc_amount: 0,                // 可选,同时转移 TBC 的数量,默认 0
    broadcastEnabled: true,       // 可选,默认 true
    domain: "",                   // 可选
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // broadcastEnabled 为 false 时
// const { error } = await Turing.sendTransaction(params); // 发生错误时

FT_MERGE

合并 FT UTXO。

ts
const params = [
  {
    flag: "FT_MERGE",             // 必填
    ft_contract_address: "",      // 必填,FT 合约地址
    domain: "",                   // 可选
  },
];

const { txid } = await Turing.sendTransaction(params); // txid 为多个 Merge 交易的 txid,用逗号隔开
// const { error } = await Turing.sendTransaction(params); // 发生错误时

POOLNFT_MINT

铸造 PoolNFT。

ts
const params = [
  {
    flag: "POOLNFT_MINT",         // 必填
    ft_contract_address: "",      // 必填,FT 合约地址
    serverProvider_tag: "",       // 必填,服务提供商标签
    poolNFT_version: 2,           // 可选,强制为 2
    serviceFeeRate: 25,           // 可选,任意正整数,默认 25
    with_lock: false,             // 可选,默认 false;为 true 时创建带哈希锁的池子
    pubKeyLock: ["pubkey1", "pubkey2"], // with_lock 为 true 时必填
    lpCostAddress: "",            // with_lock 为 true 时必填,扣除流动性添加成本的地址
    lpCostAmount: 0,              // with_lock 为 true 时必填,扣除流动性添加成本的 TBC 数量
    lpPlan: 1,                    // 可选,1-5,默认 1
    isLockTime: false,            // 可选,默认 false
    broadcastEnabled: true,       // 可选,默认 true
    domain: "",                   // 可选
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // broadcastEnabled 为 false 时,返回的 txraw 有两个,用逗号隔开,需批量广播,保证前面的 txraw 先广播
// const { error } = await Turing.sendTransaction(params); // 发生错误时

POOLNFT_INIT

初始化 PoolNFT 池。

ts
const params = [
  {
    flag: "POOLNFT_INIT",         // 必填
    nft_contract_address: "",     // 必填,PoolNFT 合约地址
    address: "",                  // 必填,接收地址
    tbc_amount: 0,                // 必填,初始注入的 TBC 数量
    ft_amount: 0,                 // 必填,初始注入的 FT 数量
    poolNFT_version: 2,           // 可选,强制为 2
    lockTime: 0,                  // 可选,锁定到指定的区块高度
    broadcastEnabled: true,       // 可选,默认 true
    domain: "",                   // 可选
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // broadcastEnabled 为 false 时
// const { error } = await Turing.sendTransaction(params); // 发生错误时

POOLNFT_LP_INCREASE

增加 PoolNFT 池中的流动性。

ts
const params = [
  {
    flag: "POOLNFT_LP_INCREASE",  // 必填
    nft_contract_address: "",     // 必填,PoolNFT 合约地址
    address: "",                  // 必填,接收地址
    tbc_amount: 0,                // 必填,增加的 TBC 数量
    poolNFT_version: 2,           // 可选,强制为 2
    lockTime: 0,                  // 可选,锁定到指定的区块高度
    broadcastEnabled: true,       // 可选,默认 true
    domain: "",                   // 可选
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // broadcastEnabled 为 false 时
// const { error } = await Turing.sendTransaction(params); // 发生错误时

POOLNFT_LP_CONSUME

从 PoolNFT 池中消耗流动性。

ts
const params = [
  {
    flag: "POOLNFT_LP_CONSUME",   // 必填
    nft_contract_address: "",     // 必填,PoolNFT 合约地址
    address: "",                  // 必填,接收地址
    ft_amount: 0,                 // 必填,消耗的 FT LP 数量
    poolNFT_version: 2,           // 可选,强制为 2
    lockTime: 0,                  // 可选,手动设置解锁参数到最大可解锁区块高度。如果启用了锁定但没有此参数,解锁参数将自动设置为(当前区块高度 - 2)
    broadcastEnabled: true,       // 可选,默认 true
    domain: "",                   // 可选
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // broadcastEnabled 为 false 时
// const { error } = await Turing.sendTransaction(params); // 发生错误时

POOLNFT_LP_BURN

从 PoolNFT 池中销毁流动性。

ts
const params = [
  {
    flag: "POOLNFT_LP_BURN",      // 必填
    nft_contract_address: "",     // 必填,PoolNFT 合约地址
    poolNFT_version: 2,           // 可选,强制为 2
    broadcastEnabled: true,       // 可选,默认 true
    domain: "",                   // 可选
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // broadcastEnabled 为 false 时
// const { error } = await Turing.sendTransaction(params); // 发生错误时

POOLNFT_SWAP_TO_TOKEN

在 PoolNFT 池中将 TBC 交换为代币。

ts
const params = [
  {
    flag: "POOLNFT_SWAP_TO_TOKEN", // 必填
    nft_contract_address: "",      // 必填,PoolNFT 合约地址
    address: "",                   // 必填,接收地址
    tbc_amount: 0,                 // 必填,用于交换的 TBC 数量
    poolNFT_version: 2,            // 可选,强制为 2
    lpPlan: 1,                     // 可选,1-5,默认 1
    broadcastEnabled: true,        // 可选,默认 true
    domain: "",                    // 可选
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // broadcastEnabled 为 false 时
// const { error } = await Turing.sendTransaction(params); // 发生错误时

POOLNFT_SWAP_TO_TBC

在 PoolNFT 池中将代币交换为 TBC。

ts
const params = [
  {
    flag: "POOLNFT_SWAP_TO_TBC",  // 必填
    nft_contract_address: "",     // 必填,PoolNFT 合约地址
    address: "",                  // 必填,接收地址
    ft_amount: 0,                 // 必填,用于交换的 FT 数量
    poolNFT_version: 2,           // 可选,强制为 2
    lpPlan: 1,                    // 可选,1-5,默认 1
    broadcastEnabled: true,       // 可选,默认 true
    domain: "",                   // 可选
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // broadcastEnabled 为 false 时
// const { error } = await Turing.sendTransaction(params); // 发生错误时

POOLNFT_MERGE

合并 PoolNFT 交易。

ts
const params = [
  {
    flag: "POOLNFT_MERGE",        // 必填
    nft_contract_address: "",     // 必填,PoolNFT 合约地址
    poolNFT_version: 2,           // 可选,强制为 2
    merge_times: 10,              // 可选,1-10 次,默认 10 次,不足时提前终止
    domain: "",                   // 可选
  },
];

const { txid } = await Turing.sendTransaction(params); // txid 为多个 Merge 交易的 txid,用逗号隔开
// const { error } = await Turing.sendTransaction(params); // 发生错误时

FTLP_MERGE

合并 FTLP 交易。

ts
const params = [
  {
    flag: "FTLP_MERGE",           // 必填
    nft_contract_address: "",     // 必填,PoolNFT 合约地址
    poolNFT_version: 2,           // 可选,强制为 2
    lockTime: 0,                  // 可选,手动设置解锁参数到最大可解锁区块高度。如果启用了锁定但没有此参数,解锁参数将自动设置为(当前区块高度 - 2)
    domain: "",                   // 可选
  },
];

const { txid } = await Turing.sendTransaction(params); // txid 为多个 Merge 交易的 txid,用逗号隔开
// const { error } = await Turing.sendTransaction(params); // 发生错误时

STABLECOIN_TRANSFER

转移稳定币。

ts
const params = [
  {
    flag: "STABLECOIN_TRANSFER",     // 必填
    ft_contract_address: "",         // 必填,稳定币合约交易 ID
    address: "",                     // 必填,接收地址
    ft_amount: 1000,                 // 必填,转移数量,大数请使用 string
    tbc_amount: 0,                   // 可选,同时转 TBC 和稳定币时设置此值
    broadcastEnabled: true,          // 可选,默认 true
    domain: "",                      // 可选
  },
];

const { txid } = await Turing.sendTransaction(params);
// const { txraw } = await Turing.sendTransaction(params); // broadcastEnabled 为 false 时
// const { error } = await Turing.sendTransaction(params); // 发生错误时

STABLECOIN_MERGE

合并稳定币 UTXO(要求所有 coinutxo 均已上链)。

ts
const params = [
  {
    flag: "STABLECOIN_MERGE",        // 必填
    ft_contract_address: "",         // 必填,稳定币合约交易 ID
    domain: "",                      // 可选
  },
];

const { txid } = await Turing.sendTransaction(params); // txid 为多个 Merge 交易的 txid,用逗号隔开
// const { error } = await Turing.sendTransaction(params); // 发生错误时