turing-wallet-provider 1.4.14 → 1.4.16

package/README.md

@@ -267,346 +267,535 @@ const { txraws } = await wallet.signAssociatedTransaction(params);
 
 ## sendTransaction
 
+使用钱包发送交易。支持多种交易类型，包括 P2PKH、NFT 操作、FT 操作和 PoolNFT 操作。
+
+### 接口定义
+
 ```ts
 interface FTData {
-​ name:string;
- symbol :string;
-​ decimal :number;
-​ amount :number;
-};
+  name: string;
+  symbol: string;
+  decimal: number;
+  amount: number | string; // 大数请使用 string
+}
 
 interface CollectionData {
-    collectionName: string;
-    description: string;
-    supply: number;
-    file: string;//file为图片base64编码后数据
-};
+  collectionName: string;
+  description: string;
+  supply: number;
+  file: string; // base64
+}
 
 interface NFTData {
-    nftName: string;
-    symbol: string;
-    description: string;
-    attributes: string;
-    file?: string;//file为图片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";
-    addres?: string;//交易接收者地址
-    satoshis?: number;//单位为satoshis
-    collection_data?: string; //json格式传
-    ft_data?: string; //json格式传
-    nft_data?: string; //json格式传
-    collection_id?: string;
-    nft_contract_address?: string;
-    ft_contract_address?: string;
-    tbc_amount?: number;
-    ft_amount?: number;
-    merge_times?:number; //可选字段 不提供默认为10
-    with_lock? boolean;
-    lpCostAddress?: string;//设置添加流动性扣款地址
-    lpCostAmount?: number;//设置添加流动性扣款TBC数量
-    pubKeyLock?: string[];
-    poolNFT_version?: number; // 废弃字段强制为2，若提供为别的值转为2
-    serviceFeeRate?: number; // 0-100 poolNFT_version为2有效 不提供默认为25
-    serverProvider_tag?:string; //poolNFT_version为2时为必需字段 poolNFT_version为1无效
-    lpPlan?:number; //1或2 不提供默认为1 lp手续费方案, 方案1: LP 0.25%  swap服务商 0.09%  协议0.01%; 方案2: LP 0.05%  swap服务商 0.29%  协议0.01%
-    domain?:string; // 设置构建及广播交易使用的节点和api服务 只支持https 不提供默认值是api.turingbitchain.io
-    isLockTime?: boolean;//是否具备锁仓功能
-    lockTime?: number;//锁仓至lockTime区块高度
-    broadcastEnabled?:boolean;//决定是否通过钱包进行广播,默认为true,选择false则钱包返回txraw而不是txid
-};
-
-const params = [param:RequestParam] //目前参数里只能放一个对象，有批量发送需求再扩展
+  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_CREATE" | "STABLECOIN_MINT" | "STABLECOIN_TRANSFER" | "STABLECOIN_FREEZE" | "STABLECOIN_UNFREEZE" | "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（稳定币的合约 ID 为 STABLECOIN_CREATE 返回的第一个 txid）
+  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;                          // 默认 1
+  domain?: string;
+  isLockTime?: boolean;
+  lockTime?: number | string;              // 锁仓至指定区块高度（POOLNFT 相关），或冻结至指定 unix 时间戳（STABLECOIN_FREEZE），大数请使用 string
+  broadcastEnabled?: boolean;
+  mint_message?: string;                   // 铸造/增发跨链信息（STABLECOIN_CREATE / STABLECOIN_MINT 使用）
+}
+
+const params = [param: RequestParam];
 ```
 
+### 返回值
+
+- `txid` - 交易 ID（当 `broadcastEnabled` 为 `true` 时）
+- `txraw` - 交易原始字符串（当 `broadcastEnabled` 为 `false` 时）
+- `error` - 错误对象（发生错误时）
+
 ### P2PKH
 
+发送标准 P2PKH 交易。
+
 ```ts
 const params = [
   {
-    flag: "P2PKH",
-    satoshis: 1000,
-    address: "",
-    broadcastEnabled?:true,//默认为true
-    domain?: "",
+    flag: "P2PKH",               // 必填
+    address: "",                  // 必填，接收地址
+    satoshis: 0,                  // 必填，转账金额，单位：聪
+    broadcastEnabled: true,       // 可选，默认 true
+    domain: "",                   // 可选，默认 api.turingbitchain.io
   },
 ];
-const { txid } = await wallet.sendTransaction(params);//broadcastEnabled为true
-//const { txraw } = await wallet.sendTransaction(params);broadcastEnabled为false
-//const { error } = await wallet.sendTransaction(params);构建或广播交易时出现错误
+
+const { txid } = await wallet.sendTransaction(params); // broadcastEnabled 为 true 时
+// const { txraw } = await wallet.sendTransaction(params); // broadcastEnabled 为 false 时
+// const { error } = await wallet.sendTransaction(params); // 发生错误时
 ```
 
 ### COLLECTION_CREATE
 
+创建新的 NFT 集合。
+
 ```ts
 const params = [
   {
-    flag: "COLLECTION_CREATE",
-    collection_data: "",
-    broadcastEnabled?:true,//默认为true
-    domain?: "",
+    flag: "COLLECTION_CREATE",    // 必填
+    collection_data: "",          // 必填，JSON 格式的 CollectionData
+    broadcastEnabled: true,       // 可选，默认 true
+    domain: "",                   // 可选
   },
 ];
+
 const { txid } = await wallet.sendTransaction(params);
-//const { txraw } = await wallet.sendTransaction(params);broadcastEnabled为false
-//const { error } = await wallet.sendTransaction(params);构建或广播交易时出现错误
+// const { txraw } = await wallet.sendTransaction(params); // broadcastEnabled 为 false 时
+// const { error } = await wallet.sendTransaction(params); // 发生错误时
 ```
 
 ### NFT_CREATE
 
+创建新的 NFT。
+
 ```ts
 const params = [
   {
-    flag: "NFT_CREATE",
-    nft_data: "",
-    collection_id: "",
-    broadcastEnabled?:true,
-    domain?: "",
+    flag: "NFT_CREATE",           // 必填
+    collection_id: "",            // 必填，集合 ID
+    nft_data: "",                 // 必填，JSON 格式的 NFTData
+    broadcastEnabled: true,       // 可选，默认 true
+    domain: "",                   // 可选
   },
 ];
+
 const { txid } = await wallet.sendTransaction(params);
-//const { txraw } = await wallet.sendTransaction(params);broadcastEnabled为false
-//const { error } = await wallet.sendTransaction(params);构建或广播交易时出现错误
+// const { txraw } = await wallet.sendTransaction(params); // broadcastEnabled 为 false 时
+// const { error } = await wallet.sendTransaction(params); // 发生错误时
 ```
 
 ### NFT_TRANSFER
 
+将 NFT 转移到另一个地址。
+
 ```ts
 const params = [
   {
-    flag: "NFT_TRANSFER",
-    nft_contract_address: "",
-    address: "",
-    broadcastEnabled?:true,
-    domain?: "",
+    flag: "NFT_TRANSFER",         // 必填
+    nft_contract_address: "",     // 必填，NFT 合约地址
+    address: "",                  // 必填，接收地址
+    broadcastEnabled: true,       // 可选，默认 true
+    domain: "",                   // 可选
   },
 ];
+
 const { txid } = await wallet.sendTransaction(params);
-//const { txraw } = await wallet.sendTransaction(params);broadcastEnabled为false
-//const { error } = await wallet.sendTransaction(params);构建或广播交易时出现错误
+// const { txraw } = await wallet.sendTransaction(params); // broadcastEnabled 为 false 时
+// const { error } = await wallet.sendTransaction(params); // 发生错误时
 ```
 
 ### FT_MINT
 
+铸造同质化代币。
+
 ```ts
 const params = [
   {
-    flag: "FT_MINT",
-    ft_data: "",
-    broadcastEnabled?:true,
-    domain?: "",
+    flag: "FT_MINT",              // 必填
+    ft_data: "",                  // 必填，JSON 格式的 FTData
+    broadcastEnabled: true,       // 可选，默认 true
+    domain: "",                   // 可选
   },
 ];
+
 const { txid } = await wallet.sendTransaction(params);
-//const { txraw } = await wallet.sendTransaction(params);broadcastEnabled为false 这里返回的txraw有两个，用逗号隔开，需批量广播，保证前面的txraw先广播
-//const { error } = await wallet.sendTransaction(params);构建或广播交易时出现错误
+// const { txraw } = await wallet.sendTransaction(params); // broadcastEnabled 为 false 时，返回的 txraw 有两个，用逗号隔开，需批量广播，保证前面的 txraw 先广播
+// const { error } = await wallet.sendTransaction(params); // 发生错误时
 ```
 
 ### FT_TRANSFER
 
+转移同质化代币。
+
 ```ts
 const params = [
   {
-    flag: "FT_TRANSFER",
-    ft_contract_address: "",
-    ft_amount: 0.1,
-    address: "",
-    tbc_amount?: 1, //同时转ft和tbc时候可提供参数
-    broadcastEnabled?:true,
-    domain?: "",
+    flag: "FT_TRANSFER",          // 必填
+    ft_contract_address: "",      // 必填，FT 合约地址
+    address: "",                  // 必填，接收地址
+    ft_amount: 0,                 // 必填，转移的 FT 数量
+    tbc_amount: 0,                // 可选，同时转移 TBC 的数量，默认 0
+    broadcastEnabled: true,       // 可选，默认 true
+    domain: "",                   // 可选
   },
 ];
+
 const { txid } = await wallet.sendTransaction(params);
-//const { txraw } = await wallet.sendTransaction(params);broadcastEnabled为false
-//const { error } = await wallet.sendTransaction(params);构建或广播交易时出现错误
+// const { txraw } = await wallet.sendTransaction(params); // broadcastEnabled 为 false 时
+// const { error } = await wallet.sendTransaction(params); // 发生错误时
 ```
 
 ### FT_MERGE
 
+合并 FT UTXO。
+
 ```ts
 const params = [
   {
-    flag: "FT_MERGE",
-    ft_contract_address: "",
-    domain?: "",
+    flag: "FT_MERGE",             // 必填
+    ft_contract_address: "",      // 必填，FT 合约地址
+    domain: "",                   // 可选
   },
 ];
-const { txid } = await wallet.sendTransaction(params);//txid为多个Merge交易的txid之间用逗号隔开
-//const { error } = await wallet.sendTransaction(params);广播交易时出现错误
+
+const { txid } = await wallet.sendTransaction(params); // txid 为多个 Merge 交易的 txid，用逗号隔开
+// const { error } = await wallet.sendTransaction(params); // 发生错误时
 ```
 
 ### POOLNFT_MINT
 
+铸造 PoolNFT。
+
 ```ts
 const params = [
   {
-    flag: "POOLNFT_MINT",
-    ft_contract_address: "",
-    poolNFT_version?: 2,
-    serverProvider_tag？: "",
-    serviceFeeRate?: 25, // poolNFT_version为2时此参数有效，默认为25
-    with_lock?: false, //默认值为false，为true则创建带哈希锁的poolNFT
-    pubKeyLock?: ["pubkey1", "pubkey2"],
-    lpCostAddress?: "", //设置添加流动性扣款地址
-    lpCostAmount?: 5, //设置添加流动性扣款TBC数量
-    lpPlan?: 1, //默认值为1
-    isLockTime?: false, //是否具备锁仓功能 默认为false
-    broadcastEnabled?:true,
-    domain?: "",
+    flag: "POOLNFT_MINT",         // 必填
+    ft_contract_address: "",      // 必填，FT 合约地址
+    serverProvider_tag: "",       // 必填，服务提供商标签
+    poolNFT_version: 2,           // 可选，强制为 2
+    serviceFeeRate: 25,           // 可选，0-100 整数，默认 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 或 2，默认 1
+    isLockTime: false,            // 可选，默认 false
+    broadcastEnabled: true,       // 可选，默认 true
+    domain: "",                   // 可选
   },
 ];
+
 const { txid } = await wallet.sendTransaction(params);
-//const { txraw } = await wallet.sendTransaction(params);broadcastEnabled为false 这里返回的txraw有两个，用逗号隔开，需批量广播，保证前面的txraw先广播
-//const { error } = await wallet.sendTransaction(params);构建或广播交易时出现错误
+// const { txraw } = await wallet.sendTransaction(params); // broadcastEnabled 为 false 时，返回的 txraw 有两个，用逗号隔开，需批量广播，保证前面的 txraw 先广播
+// const { error } = await wallet.sendTransaction(params); // 发生错误时
 ```
 
 ### POOLNFT_INIT
 
+初始化 PoolNFT 池。
+
 ```ts
 const params = [
   {
-    flag: "POOLNFT_INIT",
-    nft_contract_address: "",
-    address: "",
-    tbc_amount: 30,
-    ft_amount: 1000,
-    poolNFT_version?: 2,
-    lockTime?: 900000, //锁仓至指定区块高度
-    broadcastEnabled?:true,
-    domain?: "",
+    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 wallet.sendTransaction(params);
-//const { txraw } = await wallet.sendTransaction(params);broadcastEnabled为false
-//const { error } = await wallet.sendTransaction(params);构建或广播交易时出现错误
+// const { txraw } = await wallet.sendTransaction(params); // broadcastEnabled 为 false 时
+// const { error } = await wallet.sendTransaction(params); // 发生错误时
 ```
 
 ### POOLNFT_LP_INCREASE
 
+增加 PoolNFT 池中的流动性。
+
 ```ts
 const params = [
   {
-    flag: "POOLNFT_LP_INCREASE",
-    nft_contract_address: "",
-    address: "",
-    tbc_amount: 3,
-    poolNFT_version?: 2,
-    lockTime?: 900000, //锁仓至指定区块高度
-    broadcastEnabled?:true,
-    domain?: "",
+    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 wallet.sendTransaction(params);
-//const { txraw } = await wallet.sendTransaction(params);broadcastEnabled为false
-//const { error } = await wallet.sendTransaction(params);构建或广播交易时出现错误
+// const { txraw } = await wallet.sendTransaction(params); // broadcastEnabled 为 false 时
+// const { error } = await wallet.sendTransaction(params); // 发生错误时
 ```
 
 ### POOLNFT_LP_CONSUME
 
+从 PoolNFT 池中消耗流动性。
+
 ```ts
 const params = [
   {
-    flag: "POOLNFT_LP_CONSUME",
-    nft_contract_address: "",
-    address: "",
-    ft_amount: 100,
-    poolNFT_version?: 2,
-    lockTime?: 900000, //用于手动设置解锁参数，设置为可解锁的最大高度。若不带此参数情况下若带有锁仓，会自动设置解锁参数为 (当前区块高度 - 2)
-    broadcastEnabled?:true,
-    domain?: "",
+    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 wallet.sendTransaction(params);
-//const { txraw } = await wallet.sendTransaction(params);broadcastEnabled为false
-//const { error } = await wallet.sendTransaction(params);构建或广播交易时出现错误
+// const { txraw } = await wallet.sendTransaction(params); // broadcastEnabled 为 false 时
+// const { error } = await wallet.sendTransaction(params); // 发生错误时
 ```
 
 ### POOLNFT_LP_BURN
 
+从 PoolNFT 池中销毁流动性。
+
 ```ts
 const params = [
   {
-    flag: "POOLNFT_LP_BURN",
-    nft_contract_address: "",
-    poolNFT_version?: 2, //默认为2.且仅支持版本2
-    broadcastEnabled?:true,
-    domain?: "",
+    flag: "POOLNFT_LP_BURN",      // 必填
+    nft_contract_address: "",     // 必填，PoolNFT 合约地址
+    poolNFT_version: 2,           // 可选，强制为 2
+    broadcastEnabled: true,       // 可选，默认 true
+    domain: "",                   // 可选
   },
 ];
+
 const { txid } = await wallet.sendTransaction(params);
-//const { txraw } = await wallet.sendTransaction(params);broadcastEnabled为false
-//const { error } = await wallet.sendTransaction(params);构建或广播交易时出现错误
+// const { txraw } = await wallet.sendTransaction(params); // broadcastEnabled 为 false 时
+// const { error } = await wallet.sendTransaction(params); // 发生错误时
 ```
 
 ### POOLNFT_SWAP_TO_TOKEN
 
+在 PoolNFT 池中将 TBC 交换为代币。
+
 ```ts
 const params = [
   {
-    flag: "POOLNFT_SWAP_TO_TOKEN",
-    nft_contract_address: "",
-    address: "",
-    tbc_amount: 10,
-    poolNFT_version?: 2,
-    lpPlan?: 1, //默认值为1
-    broadcastEnabled?:true,
-    domain?: "",
+    flag: "POOLNFT_SWAP_TO_TOKEN", // 必填
+    nft_contract_address: "",      // 必填，PoolNFT 合约地址
+    address: "",                   // 必填，接收地址
+    tbc_amount: 0,                 // 必填，用于交换的 TBC 数量
+    poolNFT_version: 2,            // 可选，强制为 2
+    lpPlan: 1,                     // 可选，1 或 2，默认 1
+    broadcastEnabled: true,        // 可选，默认 true
+    domain: "",                    // 可选
   },
 ];
+
 const { txid } = await wallet.sendTransaction(params);
-//const { txraw } = await wallet.sendTransaction(params);broadcastEnabled为false
-//const { error } = await wallet.sendTransaction(params);构建或广播交易时出现错误
+// const { txraw } = await wallet.sendTransaction(params); // broadcastEnabled 为 false 时
+// const { error } = await wallet.sendTransaction(params); // 发生错误时
 ```
 
 ### POOLNFT_SWAP_TO_TBC
 
+在 PoolNFT 池中将代币交换为 TBC。
+
 ```ts
-const params = [{
-    flag:"POOLNFT_SWAP_TO_TBC",
-    nft_contract_address:"",
-    address:"",
-    ft_amount:10,
-    poolNFT_version?: 2,
-    lpPlan?:1 //默认值为1,
-    broadcastEnabled?:true,
-    domain?: "",
-}];
+const params = [
+  {
+    flag: "POOLNFT_SWAP_TO_TBC",  // 必填
+    nft_contract_address: "",     // 必填，PoolNFT 合约地址
+    address: "",                  // 必填，接收地址
+    ft_amount: 0,                 // 必填，用于交换的 FT 数量
+    poolNFT_version: 2,           // 可选，强制为 2
+    lpPlan: 1,                    // 可选，1 或 2，默认 1
+    broadcastEnabled: true,       // 可选，默认 true
+    domain: "",                   // 可选
+  },
+];
+
 const { txid } = await wallet.sendTransaction(params);
-//const { txraw } = await wallet.sendTransaction(params);broadcastEnabled为false
-//const { error } = await wallet.sendTransaction(params);构建或广播交易时出现错误
+// const { txraw } = await wallet.sendTransaction(params); // broadcastEnabled 为 false 时
+// const { error } = await wallet.sendTransaction(params); // 发生错误时
 ```
 
 ### POOLNFT_MERGE
 
+合并 PoolNFT 交易。
+
 ```ts
 const params = [
   {
-    flag: "POOLNFT_MERGE",
-    nft_contract_address: "",
-    poolNFT_version?: 2,
-    merge_times?: 10, //1-10次 默认为10次 不足10次会提前终止
-    domain?: "",
+    flag: "POOLNFT_MERGE",        // 必填
+    nft_contract_address: "",     // 必填，PoolNFT 合约地址
+    poolNFT_version: 2,           // 可选，强制为 2
+    merge_times: 10,              // 可选，1-10 次，默认 10 次，不足时提前终止
+    domain: "",                   // 可选
   },
 ];
-const { txid } = await wallet.sendTransaction(params);//txid为多个Merge交易的txid之间用逗号隔开
-//const { error } = await wallet.sendTransaction(params);广播交易时出现错误
+
+const { txid } = await wallet.sendTransaction(params); // txid 为多个 Merge 交易的 txid，用逗号隔开
+// const { error } = await wallet.sendTransaction(params); // 发生错误时
 ```
 
 ### FTLP_MERGE
 
+合并 FTLP 交易。
+
 ```ts
 const params = [
   {
-    flag: "FTLP_MERGE",
-    nft_contract_address: "",
-    poolNFT_version?: 2,
-    lockTime?: 900000, //用于手动设置解锁参数，设置为可解锁的最大高度。若不带此参数情况下若带有锁仓，会自动设置解锁参数为 (当前区块高度 - 2)
-    domain?: "",
+    flag: "FTLP_MERGE",           // 必填
+    nft_contract_address: "",     // 必填，PoolNFT 合约地址
+    poolNFT_version: 2,           // 可选，强制为 2
+    lockTime: 0,                  // 可选，手动设置解锁参数到最大可解锁区块高度。如果启用了锁定但没有此参数，解锁参数将自动设置为（当前区块高度 - 2）
+    domain: "",                   // 可选
   },
 ];
-const { txid } = await wallet.sendTransaction(params);//txid为多个Merge交易的txid之间用逗号隔开
-//const { error } = await wallet.sendTransaction(params);广播交易时出现错误
+
+const { txid } = await wallet.sendTransaction(params); // txid 为多个 Merge 交易的 txid，用逗号隔开
+// const { error } = await wallet.sendTransaction(params); // 发生错误时
+```
+
+### STABLECOIN_CREATE
+
+发行稳定币合约（仅需执行一次）。稳定币继承自 FT，构造方式与 FT 相同。
+
+```ts
+const params = [
+  {
+    flag: "STABLECOIN_CREATE",       // 必填
+    ft_data: JSON.stringify({        // 必填，JSON 格式的 FTData
+      name: "USD Test",
+      symbol: "USDT",
+      decimal: 6,
+      amount: 100000000,
+    }),
+    address: "",                     // 必填，初始接收地址（一般是管理员自身）
+    mint_message: "SourceChain: BSC, TXID: 34434...", // 必填，跨链信息，起始链名称和交易 id
+    broadcastEnabled: true,          // 可选，默认 true
+    domain: "",                      // 可选
+  },
+];
+
+const { txid } = await wallet.sendTransaction(params); // txid 有两个，用逗号隔开，第一个 txid 即为稳定币合约 ID
+// const { txraw } = await wallet.sendTransaction(params); // broadcastEnabled 为 false 时，返回的 txraw 有两个，用逗号隔开，第一个 txraw 对应的 txid 即为稳定币合约 ID，需批量广播，保证前面的 txraw 先广播
+// const { error } = await wallet.sendTransaction(params); // 发生错误时
+```
+
+### STABLECOIN_MINT
+
+增发稳定币（仅管理员可操作）。
+
+```ts
+const params = [
+  {
+    flag: "STABLECOIN_MINT",         // 必填
+    ft_contract_address: "",         // 必填，稳定币合约交易 ID（STABLECOIN_CREATE 返回的第一个 txid）
+    address: "",                     // 必填，接收新铸稳定币的地址
+    ft_amount: 50000,                // 必填，增发数量，大数请使用 string
+    mint_message: "SourceChain: BSC, TXID: 34434...", // 必填，跨链信息，起始链名称和交易 id
+    broadcastEnabled: true,          // 可选，默认 true
+    domain: "",                      // 可选
+  },
+];
+
+const { txid } = await wallet.sendTransaction(params);
+// const { txraw } = await wallet.sendTransaction(params); // broadcastEnabled 为 false 时
+// const { error } = await wallet.sendTransaction(params); // 发生错误时
+```
+
+### STABLECOIN_TRANSFER
+
+转移稳定币。
+
+```ts
+const params = [
+  {
+    flag: "STABLECOIN_TRANSFER",     // 必填
+    ft_contract_address: "",         // 必填，稳定币合约交易 ID（STABLECOIN_CREATE 返回的第一个 txid）
+    address: "",                     // 必填，接收地址
+    ft_amount: 1000,                 // 必填，转移数量，大数请使用 string
+    tbc_amount: 0,                   // 可选，同时转 TBC 和稳定币时设置此值
+    broadcastEnabled: true,          // 可选，默认 true
+    domain: "",                      // 可选
+  },
+];
+
+const { txid } = await wallet.sendTransaction(params);
+// const { txraw } = await wallet.sendTransaction(params); // broadcastEnabled 为 false 时
+// const { error } = await wallet.sendTransaction(params); // 发生错误时
+```
+
+### STABLECOIN_FREEZE
+
+冻结指定地址的稳定币 UTXO（仅管理员可操作）。冻结后，持有者须等到冻结到期才能使用该 UTXO。
+
+```ts
+const params = [
+  {
+    flag: "STABLECOIN_FREEZE",       // 必填
+    ft_contract_address: "",         // 必填，稳定币合约交易 ID（STABLECOIN_CREATE 返回的第一个 txid）
+    address: "",                     // 必填，被冻结的目标地址
+    lockTime: 1774410989,            // 必填，冻结至指定 unix 时间戳
+    broadcastEnabled: true,          // 可选，默认 true
+    domain: "",                      // 可选
+  },
+];
+
+const { txid } = await wallet.sendTransaction(params);
+// const { txraw } = await wallet.sendTransaction(params); // broadcastEnabled 为 false 时
+// const { error } = await wallet.sendTransaction(params); // 发生错误时
+```
+
+### STABLECOIN_UNFREEZE
+
+解冻指定地址的稳定币 UTXO（仅管理员可操作）。
+
+```ts
+const params = [
+  {
+    flag: "STABLECOIN_UNFREEZE",     // 必填
+    ft_contract_address: "",         // 必填，稳定币合约交易 ID（STABLECOIN_CREATE 返回的第一个 txid）
+    address: "",                     // 必填，被解冻的目标地址
+    broadcastEnabled: true,          // 可选，默认 true
+    domain: "",                      // 可选
+  },
+];
+
+const { txid } = await wallet.sendTransaction(params);
+// const { txraw } = await wallet.sendTransaction(params); // broadcastEnabled 为 false 时
+// const { error } = await wallet.sendTransaction(params); // 发生错误时
+```
+
+### STABLECOIN_MERGE
+
+合并稳定币 UTXO（要求所有 coinutxo 均已上链）。
+
+```ts
+const params = [
+  {
+    flag: "STABLECOIN_MERGE",        // 必填
+    ft_contract_address: "",         // 必填，稳定币合约交易 ID（STABLECOIN_CREATE 返回的第一个 txid）
+    domain: "",                      // 可选
+  },
+];
+
+const { txid } = await wallet.sendTransaction(params); // txid 为多个 Merge 交易的 txid，用逗号隔开
+// const { error } = await wallet.sendTransaction(params); // 发生错误时
 ```
 
 ## sendBatchRequest
@@ -831,3 +1020,212 @@ if (result.txraw) {
   // 可以自行广播这个交易
 }
 ```
+
+## btc.sendTransaction
+
+通过 `btc` 对象发送 BTC 链上的交易。
+
+### 参数说明
+
+```ts
+interface BtcSendTransaction {
+  toAddress: string; // 接收地址
+  amount: string; // 转账金额,字符串格式,单位为 satoshis
+  broadcastEnabled?: boolean; // 是否广播交易,默认为 true
+}
+
+interface BtcSendTransactionResponse {
+  txid?: string; // 交易哈希(广播成功时返回)
+  txraw?: string; // 交易原始数据(broadcastEnabled为false时返回)
+  error?: string; // 错误信息
+}
+```
+
+### 使用示例
+
+#### 转账 BTC
+
+```ts
+const wallet = useTuringWallet();
+
+const result = await wallet.btc.sendTransaction({
+  toAddress: "bc1qxyz...",
+  amount: "100000", // 100000 satoshis
+  broadcastEnabled: true,
+});
+
+if (result.txid) {
+  console.log("交易哈希:", result.txid);
+} else if (result.error) {
+  console.error("交易失败:", result.error);
+}
+```
+
+#### 不广播,仅返回签名交易
+
+```ts
+const wallet = useTuringWallet();
+
+const result = await wallet.btc.sendTransaction({
+  toAddress: "bc1qxyz...",
+  amount: "100000",
+  broadcastEnabled: false,
+});
+
+if (result.txraw) {
+  console.log("交易原始数据:", result.txraw);
+}
+```
+
+## btc.signTransaction
+
+通过 `btc` 对象对单个 BTC 裸交易进行签名,支持 legacy、segwit_v0、taproot 三种签名类型。taproot 类型下通过 `leafHashesHex` 区分 key path 和 script path:对应输入为 `undefined` 则走 key path,有值则走 script path。
+
+### 参数说明
+
+```ts
+type BtcSigHashType = "legacy" | "segwit_v0" | "taproot";
+
+interface BtcSignTransaction {
+  txHex: string; // 裸交易 hex
+  type: BtcSigHashType; // 签名哈希类型
+  prevOutScriptsHex: string[]; // 每个输入对应的前置输出脚本 hex
+  values?: number[]; // 每个输入对应的金额(satoshis),segwit_v0/taproot 必填
+  leafHashesHex?: (string | undefined)[]; // 每个输入对应的叶子哈希,仅 taproot 类型使用,undefined 表示 key path,有值表示 script path
+}
+
+interface BtcSignTransactionResponse {
+  sigs?: string[]; // 每个输入对应的签名 hex
+  error?: string; // 错误信息
+}
+```
+
+### 使用示例
+
+#### Legacy (P2PKH) 签名
+
+```ts
+const wallet = useTuringWallet();
+
+const result = await wallet.btc.signTransaction({
+  txHex: "0200000001...",
+  type: "legacy",
+  prevOutScriptsHex: ["76a914...88ac"],
+});
+
+if (result.sigs) {
+  console.log("签名列表:", result.sigs);
+} else if (result.error) {
+  console.error("签名失败:", result.error);
+}
+```
+
+#### SegWit V0 (P2WPKH) 签名
+
+```ts
+const wallet = useTuringWallet();
+
+const result = await wallet.btc.signTransaction({
+  txHex: "0200000001...",
+  type: "segwit_v0",
+  prevOutScriptsHex: ["76a914...88ac"],
+  values: [100000],
+});
+
+if (result.sigs) {
+  console.log("签名列表:", result.sigs);
+}
+```
+
+#### Taproot Key Path 签名
+
+```ts
+const wallet = useTuringWallet();
+
+const result = await wallet.btc.signTransaction({
+  txHex: "0200000001...",
+  type: "taproot",
+  prevOutScriptsHex: ["5120..."],
+  values: [100000],
+  // leafHashesHex 不传或对应位置为 undefined,走 key path
+});
+
+if (result.sigs) {
+  console.log("签名列表:", result.sigs);
+}
+```
+
+#### Taproot Script Path 签名
+
+```ts
+const wallet = useTuringWallet();
+
+const result = await wallet.btc.signTransaction({
+  txHex: "0200000001...",
+  type: "taproot",
+  prevOutScriptsHex: ["5120..."],
+  values: [100000],
+  leafHashesHex: ["ab12cd34..."], // 对应输入有 leafHash,走 script path
+});
+
+if (result.sigs) {
+  console.log("签名列表:", result.sigs);
+}
+```
+
+## btc.sendBatchRequest
+
+通过 `btc` 对象批量提交 BTC 相关请求,每个请求独立执行,一个失败不影响其他请求。
+
+### 支持的方法
+
+- `sendTransaction` - 发送交易
+- `signTransaction` - 签名交易
+
+### 参数说明
+
+```ts
+type BtcBatchRequestMethod = "sendTransaction" | "signTransaction";
+
+interface BtcBatchRequest {
+  method: BtcBatchRequestMethod;
+  params: BtcSendTransaction | BtcSignTransaction;
+}
+
+type BtcBatchResponse = Array<BtcSendTransactionResponse | BtcSignTransactionResponse>;
+```
+
+### 使用示例
+
+```ts
+const wallet = useTuringWallet();
+
+const requests = [
+  {
+    method: "sendTransaction",
+    params: {
+      toAddress: "bc1qxyz...",
+      amount: "100000",
+      broadcastEnabled: true,
+    },
+  },
+  {
+    method: "signTransaction",
+    params: {
+      txHex: "0200000001...",
+      type: "legacy",
+      prevOutScriptsHex: ["76a914...88ac"],
+    },
+  },
+];
+
+const results = await wallet.btc.sendBatchRequest(requests);
+
+results.forEach((result, index) => {
+  if (result.error) {
+    console.error(`Request ${index + 1} failed:`, result.error);
+  } else {
+    console.log(`Request ${index + 1} success:`, result);
+  }
+});
+```

package/dist/context/TuringWalletContext.d.ts

@@ -1,5 +1,5 @@
 import { ReactNode } from "react";
-import { TuringProviderType } from "../types/providerTypes"
+
 export declare const TuringContext: import("react").Context<TuringProviderType | undefined>;
 interface TuringProviderProps {
     children: ReactNode;

package/dist/types/providerTypes.d.ts

@@ -33,12 +33,18 @@ export type TransactionFlag =
   | "POOLNFT_SWAP_TO_TOKEN"
   | "POOLNFT_SWAP_TO_TBC"
   | "POOLNFT_MERGE"
-  | "FTLP_MERGE";
+  | "FTLP_MERGE"
+  | "STABLECOIN_CREATE"
+  | "STABLECOIN_MINT"
+  | "STABLECOIN_TRANSFER"
+  | "STABLECOIN_FREEZE"
+  | "STABLECOIN_UNFREEZE"
+  | "STABLECOIN_MERGE";
 
 
 export type SendTransaction = {
   flag: TransactionFlag;
-  satoshis?: number;
+  satoshis?: number | string;
   address?: string;
   collection_data?: string;
   ft_data?: string;
@@ -46,21 +52,22 @@ export type SendTransaction = {
   collection_id?: string;
   nft_contract_address?: string;
   ft_contract_address?: string;
-  tbc_amount?: number;
-  ft_amount?: number;
+  tbc_amount?: number | string;
+  ft_amount?: number | string;
   merge_times?: number;
   with_lock?: boolean;
   lpCostAddress?: string;
-  lpCostAmount?: number;
+  lpCostAmount?: number | string;
   pubKeyLock?: string[];
-  poolNFT_version?: number;
+  poolNFT_version?: 1 | 2;
   serviceFeeRate?: number;
   serviceProvider_flag?: string;
-  lpPlan?: number;
+  lpPlan?: 1 | 2;
   domain?: string;
   isLockTime?: boolean;
-  lockTime?: number;
+  lockTime?: number | string;
   broadcastEnabled?: boolean;
+  mint_message?: string;
 };
 
 export type SendTransactionResponse = {
@@ -179,6 +186,50 @@ export type EvmProvider = {
   sendTransaction: (params: EvmSendTransaction) => Promise<EvmSendTransactionResponse | undefined>;
 };
 
+export type BtcSendTransaction = {
+  toAddress: string;
+  amount: string;
+  broadcastEnabled?: boolean;
+};
+
+export type BtcSendTransactionResponse = {
+  txid?: string;
+  txraw?: string;
+  error?: string;
+};
+
+export type BtcSigHashType = "legacy" | "segwit_v0" | "taproot";
+
+export type BtcSignTransaction = {
+  txHex: string;
+  type: BtcSigHashType;
+  prevOutScriptsHex: string[];
+  values?: number[];
+  leafHashesHex?: (string | undefined)[];
+};
+
+export type BtcSignTransactionResponse = {
+  sigs?: string[];
+  error?: string;
+};
+
+export type BtcBatchRequestMethod = "sendTransaction" | "signTransaction";
+
+export type BtcBatchRequest = {
+  method: BtcBatchRequestMethod;
+  params: BtcSendTransaction | BtcSignTransaction;
+};
+
+export type BtcBatchResponse = Array<
+  BtcSendTransactionResponse | BtcSignTransactionResponse
+>;
+
+export type BtcProvider = {
+  sendTransaction: (params: BtcSendTransaction) => Promise<BtcSendTransactionResponse | undefined>;
+  signTransaction: (params: BtcSignTransaction) => Promise<BtcSignTransactionResponse | undefined>;
+  sendBatchRequest: (requests: BtcBatchRequest[]) => Promise<BtcBatchResponse | undefined>;
+};
+
 export type TuringProviderType = {
   isReady: boolean;
   connect: () => Promise<ConnectResponse | undefined>;
@@ -203,4 +254,5 @@ export type TuringProviderType = {
   ) => Promise<SignAssociatedTransactionResponse | undefined>;
   sendBatchRequest: (requests: BatchRequest[]) => Promise<BatchResponse | undefined>;
   evm: EvmProvider;
+  btc: BtcProvider;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turing-wallet-provider",
-  "version": "1.4.14",
+  "version": "1.4.16",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [