@bennyblader/ddk-ts 0.1.5

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@bennyblader/ddk-ts",
+  "version": "0.1.5",
+  "description": "dlcdevkit typescript bindings",
+  "main": "index.js",
+  "repository": "https://github.com/bennyblader/ddk-ffi",
+  "license": "MIT",
+  "keywords": [
+    "napi-rs",
+    "rust",
+    "rust-dlc",
+    "ddk",
+    "dlcdevkit"
+  ],
+  "files": [
+    "src"
+  ],
+  "napi": {
+    "binaryName": "ddk-ts",
+    "targets": [
+      "aarch64-apple-darwin",
+      "x86_64-unknown-linux-gnu"
+    ]
+  },
+  "engines": {
+    "node": ">= 6.14.2 < 7 || >= 8.11.2 < 9 || >= 9.11.0 < 10 || >= 10.0.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "scripts": {
+    "artifacts": "napi artifacts",
+    "bench": "node --import @oxc-node/core/register benchmark/bench.ts",
+    "build": "napi build --platform --release --js index.js --dts index.d.ts",
+    "build:debug": "napi build --platform --js src/index.js --dts src/index.d.ts",
+    "build:all": "napi build --release --js src/index.js --dts src/index.d.ts --target aarch64-apple-darwin --target x86_64-unknown-linux-gnu",
+    "prepublish": "napi prepublish -t npm",
+    "prepublishOnly": "napi prepublish -t npm",
+    "build:darwin-x64": "napi build --release --js index.js --dts index.d.ts --target x86_64-apple-darwin",
+    "build:darwin-arm64": "napi build --release --js index.js --dts index.d.ts --target aarch64-apple-darwin",
+    "build:linux-x64": "napi build --release --js index.js --dts index.d.ts --target x86_64-unknown-linux-gnu",
+    "build:linux-x64-musl": "napi build --release --js index.js --dts index.d.ts --target x86_64-unknown-linux-musl",
+    "build:linux-arm64": "napi build --release --js src/index.js --dts src/index.d.ts --target aarch64-unknown-linux-gnu",
+    "build:linux-arm64-musl": "napi build --release --js src/index.js --dts src/index.d.ts --target aarch64-unknown-linux-musl",
+    "format": "run-p format:prettier format:rs format:toml",
+    "format:prettier": "prettier . -w",
+    "format:toml": "taplo format",
+    "format:rs": "cargo fmt",
+    "test": "ava",
+    "test:all": "yarn verify && cargo test && yarn test",
+    "verify": "node scripts/verify-parity.js && node scripts/verify-types.js",
+    "verify:parity": "node scripts/verify-parity.js",
+    "verify:types": "node scripts/verify-types.js",
+    "version": "napi version",
+    "prepare": "husky"
+  },
+  "devDependencies": {
+    "@emnapi/core": "^1.4.5",
+    "@emnapi/runtime": "^1.4.5",
+    "@napi-rs/cli": "^3.0.3",
+    "@taplo/cli": "^0.7.0",
+    "@tybys/wasm-util": "^0.10.0",
+    "ava": "^6.4.1",
+    "chalk": "^5.4.1",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.1.2",
+    "npm-run-all2": "^8.0.4",
+    "prettier": "^3.6.2",
+    "tinybench": "^4.0.1",
+    "typescript": "^5.8.3"
+  },
+  "ava": {
+    "timeout": "2m",
+    "workerThreads": false,
+    "files": [
+      "__test__/**/*.spec.mjs"
+    ]
+  },
+  "prettier": {
+    "printWidth": 120,
+    "semi": false,
+    "trailingComma": "all",
+    "singleQuote": true,
+    "arrowParens": "always"
+  },
+  "workspaces": [
+    "example"
+  ],
+  "packageManager": "yarn@4.9.2",
+  "optionalDependencies": {
+    "@bennyblader/ddk-ts-darwin-arm64": "0.1.5",
+    "@bennyblader/ddk-ts-linux-x64-gnu": "0.1.5"
+  }
+}

package/src/conversions.rs

@@ -0,0 +1,268 @@
+use crate::types::*;
+use napi::bindgen_prelude::*;
+
+// Helper function to convert BigInt to u64 safely
+pub fn bigint_to_u64(bi: &BigInt) -> Result<u64> {
+  let (sign_bit, value, _lossless) = bi.get_u64();
+  if sign_bit {
+    return Err(Error::from_reason("BigInt value is negative"));
+  }
+  Ok(value)
+}
+
+// Helper function to convert Vec<u8> to Buffer
+pub fn vec_to_buffer(vec: Vec<u8>) -> Buffer {
+  Buffer::from(vec)
+}
+
+// Helper function to convert Buffer to Vec<u8>
+pub fn buffer_to_vec(buffer: &Buffer) -> Vec<u8> {
+  buffer.to_vec()
+}
+
+// Convert ddk_ffi Transaction to NAPI Transaction
+impl From<ddk_ffi::Transaction> for Transaction {
+  fn from(tx: ddk_ffi::Transaction) -> Self {
+    Transaction {
+      version: tx.version,
+      lock_time: tx.lock_time,
+      inputs: tx.inputs.into_iter().map(Into::into).collect(),
+      outputs: tx.outputs.into_iter().map(Into::into).collect(),
+      raw_bytes: Buffer::from(tx.raw_bytes),
+    }
+  }
+}
+
+// Convert NAPI Transaction to ddk_ffi Transaction
+impl TryFrom<Transaction> for ddk_ffi::Transaction {
+  type Error = napi::Error;
+
+  fn try_from(tx: Transaction) -> Result<Self> {
+    let outputs: Result<Vec<_>> = tx.outputs.into_iter().map(TryInto::try_into).collect();
+    Ok(ddk_ffi::Transaction {
+      version: tx.version,
+      lock_time: tx.lock_time,
+      inputs: tx.inputs.into_iter().map(Into::into).collect(),
+      outputs: outputs?,
+      raw_bytes: tx.raw_bytes.to_vec(),
+    })
+  }
+}
+
+// Convert NAPI TxInput to ddk_ffi TxInput
+impl From<TxInput> for ddk_ffi::TxInput {
+  fn from(input: TxInput) -> Self {
+    ddk_ffi::TxInput {
+      txid: input.txid,
+      vout: input.vout,
+      script_sig: input.script_sig.to_vec(),
+      sequence: input.sequence,
+      witness: input.witness.into_iter().map(|w| w.to_vec()).collect(),
+    }
+  }
+}
+
+// Convert ddk_ffi TxInput to NAPI TxInput
+impl From<ddk_ffi::TxInput> for TxInput {
+  fn from(input: ddk_ffi::TxInput) -> Self {
+    TxInput {
+      txid: input.txid,
+      vout: input.vout,
+      script_sig: Buffer::from(input.script_sig),
+      sequence: input.sequence,
+      witness: input.witness.into_iter().map(Buffer::from).collect(),
+    }
+  }
+}
+
+// Convert NAPI TxOutput to ddk_ffi TxOutput
+impl TryFrom<TxOutput> for ddk_ffi::TxOutput {
+  type Error = napi::Error;
+
+  fn try_from(output: TxOutput) -> Result<Self> {
+    Ok(ddk_ffi::TxOutput {
+      value: bigint_to_u64(&output.value)?,
+      script_pubkey: output.script_pubkey.to_vec(),
+    })
+  }
+}
+
+// Convert ddk_ffi TxOutput to NAPI TxOutput
+impl From<ddk_ffi::TxOutput> for TxOutput {
+  fn from(output: ddk_ffi::TxOutput) -> Self {
+    TxOutput {
+      value: BigInt::from(output.value),
+      script_pubkey: Buffer::from(output.script_pubkey),
+    }
+  }
+}
+
+// Convert NAPI TxInputInfo to ddk_ffi TxInputInfo
+impl TryFrom<TxInputInfo> for ddk_ffi::TxInputInfo {
+  type Error = napi::Error;
+
+  fn try_from(info: TxInputInfo) -> Result<Self> {
+    Ok(ddk_ffi::TxInputInfo {
+      txid: info.txid,
+      vout: info.vout,
+      script_sig: info.script_sig.to_vec(),
+      max_witness_length: info.max_witness_length,
+      serial_id: bigint_to_u64(&info.serial_id)?,
+    })
+  }
+}
+
+// Convert ddk_ffi TxInputInfo to NAPI TxInputInfo
+impl From<ddk_ffi::TxInputInfo> for TxInputInfo {
+  fn from(info: ddk_ffi::TxInputInfo) -> Self {
+    TxInputInfo {
+      txid: info.txid,
+      vout: info.vout,
+      script_sig: Buffer::from(info.script_sig),
+      max_witness_length: info.max_witness_length,
+      serial_id: BigInt::from(info.serial_id),
+    }
+  }
+}
+
+// Convert NAPI DlcOutcome to ddk_ffi DlcOutcome
+impl TryFrom<DlcOutcome> for ddk_ffi::DlcOutcome {
+  type Error = napi::Error;
+
+  fn try_from(outcome: DlcOutcome) -> Result<Self> {
+    Ok(ddk_ffi::DlcOutcome {
+      local_payout: bigint_to_u64(&outcome.local_payout)?,
+      remote_payout: bigint_to_u64(&outcome.remote_payout)?,
+    })
+  }
+}
+
+// Convert ddk_ffi DlcOutcome to NAPI DlcOutcome
+impl From<ddk_ffi::DlcOutcome> for DlcOutcome {
+  fn from(outcome: ddk_ffi::DlcOutcome) -> Self {
+    DlcOutcome {
+      local_payout: BigInt::from(outcome.local_payout),
+      remote_payout: BigInt::from(outcome.remote_payout),
+    }
+  }
+}
+
+// Convert NAPI DlcInputInfo to ddk_ffi DlcInputInfo
+impl TryFrom<DlcInputInfo> for ddk_ffi::DlcInputInfo {
+  type Error = napi::Error;
+
+  fn try_from(info: DlcInputInfo) -> Result<Self> {
+    Ok(ddk_ffi::DlcInputInfo {
+      fund_tx: info.fund_tx.try_into()?,
+      fund_vout: info.fund_vout,
+      local_fund_pubkey: info.local_fund_pubkey.to_vec(),
+      remote_fund_pubkey: info.remote_fund_pubkey.to_vec(),
+      fund_amount: bigint_to_u64(&info.fund_amount)?,
+      max_witness_len: info.max_witness_len,
+      input_serial_id: bigint_to_u64(&info.input_serial_id)?,
+      contract_id: info.contract_id.to_vec(),
+    })
+  }
+}
+
+// Convert ddk_ffi DlcInputInfo to NAPI DlcInputInfo
+impl From<ddk_ffi::DlcInputInfo> for DlcInputInfo {
+  fn from(info: ddk_ffi::DlcInputInfo) -> Self {
+    DlcInputInfo {
+      fund_tx: info.fund_tx.into(),
+      fund_vout: info.fund_vout,
+      local_fund_pubkey: Buffer::from(info.local_fund_pubkey),
+      remote_fund_pubkey: Buffer::from(info.remote_fund_pubkey),
+      fund_amount: BigInt::from(info.fund_amount),
+      max_witness_len: info.max_witness_len,
+      input_serial_id: BigInt::from(info.input_serial_id),
+      contract_id: Buffer::from(info.contract_id),
+    }
+  }
+}
+
+// Convert NAPI PartyParams to ddk_ffi PartyParams
+impl TryFrom<PartyParams> for ddk_ffi::PartyParams {
+  type Error = napi::Error;
+
+  fn try_from(params: PartyParams) -> Result<Self> {
+    let inputs: Result<Vec<_>> = params.inputs.into_iter().map(TryInto::try_into).collect();
+    let dlc_inputs: Result<Vec<_>> = params
+      .dlc_inputs
+      .into_iter()
+      .map(TryInto::try_into)
+      .collect();
+
+    Ok(ddk_ffi::PartyParams {
+      fund_pubkey: params.fund_pubkey.to_vec(),
+      change_script_pubkey: params.change_script_pubkey.to_vec(),
+      change_serial_id: bigint_to_u64(&params.change_serial_id)?,
+      payout_script_pubkey: params.payout_script_pubkey.to_vec(),
+      payout_serial_id: bigint_to_u64(&params.payout_serial_id)?,
+      inputs: inputs?,
+      input_amount: bigint_to_u64(&params.input_amount)?,
+      collateral: bigint_to_u64(&params.collateral)?,
+      dlc_inputs: dlc_inputs?,
+    })
+  }
+}
+
+// Convert ddk_ffi PartyParams to NAPI PartyParams
+impl From<ddk_ffi::PartyParams> for PartyParams {
+  fn from(params: ddk_ffi::PartyParams) -> Self {
+    PartyParams {
+      fund_pubkey: Buffer::from(params.fund_pubkey),
+      change_script_pubkey: Buffer::from(params.change_script_pubkey),
+      change_serial_id: BigInt::from(params.change_serial_id),
+      payout_script_pubkey: Buffer::from(params.payout_script_pubkey),
+      payout_serial_id: BigInt::from(params.payout_serial_id),
+      inputs: params.inputs.into_iter().map(Into::into).collect(),
+      input_amount: BigInt::from(params.input_amount),
+      collateral: BigInt::from(params.collateral),
+      dlc_inputs: params.dlc_inputs.into_iter().map(Into::into).collect(),
+    }
+  }
+}
+
+// Convert ddk_ffi DlcTransactions to NAPI DlcTransactions
+impl From<ddk_ffi::DlcTransactions> for DlcTransactions {
+  fn from(txs: ddk_ffi::DlcTransactions) -> Self {
+    DlcTransactions {
+      fund: txs.fund.into(),
+      cets: txs.cets.into_iter().map(Into::into).collect(),
+      refund: txs.refund.into(),
+      funding_script_pubkey: Buffer::from(txs.funding_script_pubkey),
+    }
+  }
+}
+
+// Convert ddk_ffi ChangeOutputAndFees to NAPI ChangeOutputAndFees
+impl From<ddk_ffi::ChangeOutputAndFees> for ChangeOutputAndFees {
+  fn from(fees: ddk_ffi::ChangeOutputAndFees) -> Self {
+    ChangeOutputAndFees {
+      change_output: fees.change_output.into(),
+      fund_fee: BigInt::from(fees.fund_fee),
+      cet_fee: BigInt::from(fees.cet_fee),
+    }
+  }
+}
+
+// Convert NAPI OracleInfo to ddk_ffi OracleInfo
+impl From<OracleInfo> for ddk_ffi::OracleInfo {
+  fn from(info: OracleInfo) -> Self {
+    ddk_ffi::OracleInfo {
+      public_key: info.public_key.to_vec(),
+      nonces: info.nonces.into_iter().map(|n| n.to_vec()).collect(),
+    }
+  }
+}
+
+// Convert ddk_ffi AdaptorSignature to NAPI AdaptorSignature
+impl From<ddk_ffi::AdaptorSignature> for AdaptorSignature {
+  fn from(sig: ddk_ffi::AdaptorSignature) -> Self {
+    AdaptorSignature {
+      signature: Buffer::from(sig.signature),
+      proof: Buffer::from(sig.proof),
+    }
+  }
+}

package/src/lib.rs

@@ -0,0 +1,285 @@
+#![deny(clippy::all)]
+
+pub mod conversions;
+mod types;
+
+use conversions::*;
+use napi::bindgen_prelude::*;
+use napi_derive::napi;
+use types::*;
+
+// Import ddk_ffi crate
+extern crate ddk_ffi;
+
+#[napi]
+pub fn version() -> String {
+  ddk_ffi::version()
+}
+
+#[napi]
+pub fn create_fund_tx_locking_script(
+  local_fund_pubkey: Buffer,
+  remote_fund_pubkey: Buffer,
+) -> Result<Buffer> {
+  let local_pubkey = buffer_to_vec(&local_fund_pubkey);
+  let remote_pubkey = buffer_to_vec(&remote_fund_pubkey);
+
+  let result = ddk_ffi::create_fund_tx_locking_script(local_pubkey, remote_pubkey)
+    .map_err(|e| Error::from_reason(format!("{:?}", e)))?;
+
+  Ok(vec_to_buffer(result))
+}
+
+#[napi]
+pub fn create_dlc_transactions(
+  outcomes: Vec<DlcOutcome>,
+  local_params: PartyParams,
+  remote_params: PartyParams,
+  refund_locktime: u32,
+  fee_rate: BigInt,
+  fund_lock_time: u32,
+  cet_lock_time: u32,
+  fund_output_serial_id: BigInt,
+) -> Result<DlcTransactions> {
+  let ffi_outcomes: Result<Vec<ddk_ffi::DlcOutcome>> =
+    outcomes.into_iter().map(TryInto::try_into).collect();
+
+  let ffi_local_params = local_params.try_into()?;
+  let ffi_remote_params = remote_params.try_into()?;
+
+  let result = ddk_ffi::create_dlc_transactions(
+    ffi_outcomes?,
+    ffi_local_params,
+    ffi_remote_params,
+    refund_locktime,
+    bigint_to_u64(&fee_rate)?,
+    fund_lock_time,
+    cet_lock_time,
+    bigint_to_u64(&fund_output_serial_id)?,
+  )
+  .map_err(|e| Error::from_reason(format!("{:?}", e)))?;
+
+  Ok(result.into())
+}
+
+#[napi]
+pub fn create_spliced_dlc_transactions(
+  outcomes: Vec<DlcOutcome>,
+  local_params: PartyParams,
+  remote_params: PartyParams,
+  refund_locktime: u32,
+  fee_rate: BigInt,
+  fund_lock_time: u32,
+  cet_lock_time: u32,
+  fund_output_serial_id: BigInt,
+) -> Result<DlcTransactions> {
+  let ffi_outcomes: Result<Vec<ddk_ffi::DlcOutcome>> =
+    outcomes.into_iter().map(TryInto::try_into).collect();
+
+  let ffi_local_params = local_params.try_into()?;
+  let ffi_remote_params = remote_params.try_into()?;
+
+  let result = ddk_ffi::create_spliced_dlc_transactions(
+    ffi_outcomes?,
+    ffi_local_params,
+    ffi_remote_params,
+    refund_locktime,
+    bigint_to_u64(&fee_rate)?,
+    fund_lock_time,
+    cet_lock_time,
+    bigint_to_u64(&fund_output_serial_id)?,
+  )
+  .map_err(|e| Error::from_reason(format!("{:?}", e)))?;
+
+  Ok(result.into())
+}
+
+#[napi]
+pub fn create_cet(
+  local_output: TxOutput,
+  local_payout_serial_id: BigInt,
+  remote_output: TxOutput,
+  remote_payout_serial_id: BigInt,
+  fund_tx_id: String,
+  fund_vout: u32,
+  lock_time: u32,
+) -> Result<Transaction> {
+  let result = ddk_ffi::create_cet(
+    local_output.try_into()?,
+    bigint_to_u64(&local_payout_serial_id)?,
+    remote_output.try_into()?,
+    bigint_to_u64(&remote_payout_serial_id)?,
+    fund_tx_id,
+    fund_vout,
+    lock_time,
+  )
+  .map_err(|e| Error::from_reason(format!("{:?}", e)))?;
+
+  Ok(result.into())
+}
+
+#[napi]
+pub fn create_cets(
+  fund_tx_id: String,
+  fund_vout: u32,
+  local_final_script_pubkey: Buffer,
+  remote_final_script_pubkey: Buffer,
+  outcomes: Vec<DlcOutcome>,
+  lock_time: u32,
+  local_serial_id: BigInt,
+  remote_serial_id: BigInt,
+) -> Result<Vec<Transaction>> {
+  let ffi_outcomes: Result<Vec<ddk_ffi::DlcOutcome>> =
+    outcomes.into_iter().map(TryInto::try_into).collect();
+
+  let result = ddk_ffi::create_cets(
+    fund_tx_id,
+    fund_vout,
+    buffer_to_vec(&local_final_script_pubkey),
+    buffer_to_vec(&remote_final_script_pubkey),
+    ffi_outcomes?,
+    lock_time,
+    bigint_to_u64(&local_serial_id)?,
+    bigint_to_u64(&remote_serial_id)?,
+  )
+  .map_err(|e| Error::from_reason(format!("{:?}", e)))?;
+
+  Ok(result.into_iter().map(Into::into).collect())
+}
+
+#[napi]
+pub fn create_refund_transaction(
+  local_final_script_pubkey: Buffer,
+  remote_final_script_pubkey: Buffer,
+  local_amount: BigInt,
+  remote_amount: BigInt,
+  lock_time: u32,
+  fund_tx_id: String,
+  fund_vout: u32,
+) -> Result<Transaction> {
+  let result = ddk_ffi::create_refund_transaction(
+    buffer_to_vec(&local_final_script_pubkey),
+    buffer_to_vec(&remote_final_script_pubkey),
+    bigint_to_u64(&local_amount)?,
+    bigint_to_u64(&remote_amount)?,
+    lock_time,
+    fund_tx_id,
+    fund_vout,
+  )
+  .map_err(|e| Error::from_reason(format!("{:?}", e)))?;
+
+  Ok(result.into())
+}
+
+#[napi]
+pub fn is_dust_output(output: TxOutput) -> Result<bool> {
+  eprintln!("is_dust_output called with value: {:?}", output.value);
+  let ffi_output = output.try_into()?;
+  Ok(ddk_ffi::is_dust_output(ffi_output))
+}
+
+#[napi]
+pub fn get_change_output_and_fees(
+  params: PartyParams,
+  fee_rate: BigInt,
+) -> Result<ChangeOutputAndFees> {
+  let result = ddk_ffi::get_change_output_and_fees(params.try_into()?, bigint_to_u64(&fee_rate)?)
+    .map_err(|e| Error::from_reason(format!("{:?}", e)))?;
+
+  Ok(result.into())
+}
+
+#[napi]
+pub fn get_total_input_vsize(inputs: Vec<TxInputInfo>) -> Result<u32> {
+  let ffi_inputs: Result<Vec<ddk_ffi::TxInputInfo>> =
+    inputs.into_iter().map(TryInto::try_into).collect();
+
+  Ok(ddk_ffi::get_total_input_vsize(ffi_inputs?))
+}
+
+#[napi]
+pub fn verify_fund_tx_signature(
+  fund_tx: Transaction,
+  signature: Buffer,
+  pubkey: Buffer,
+  txid: String,
+  vout: u32,
+  input_amount: BigInt,
+) -> Result<bool> {
+  let result = ddk_ffi::verify_fund_tx_signature(
+    fund_tx.try_into()?,
+    buffer_to_vec(&signature),
+    buffer_to_vec(&pubkey),
+    txid,
+    vout,
+    bigint_to_u64(&input_amount)?,
+  )
+  .map_err(|e| Error::from_reason(format!("{:?}", e)))?;
+
+  Ok(result)
+}
+
+#[napi]
+pub fn get_raw_funding_transaction_input_signature(
+  funding_transaction: Transaction,
+  privkey: Buffer,
+  prev_tx_id: String,
+  prev_tx_vout: u32,
+  value: BigInt,
+) -> Result<Buffer> {
+  let result = ddk_ffi::get_raw_funding_transaction_input_signature(
+    funding_transaction.try_into()?,
+    buffer_to_vec(&privkey),
+    prev_tx_id,
+    prev_tx_vout,
+    bigint_to_u64(&value)?,
+  )
+  .map_err(|e| Error::from_reason(format!("{:?}", e)))?;
+
+  Ok(vec_to_buffer(result))
+}
+
+#[napi]
+pub fn sign_fund_transaction_input(
+  fund_transaction: Transaction,
+  privkey: Buffer,
+  prev_tx_id: String,
+  prev_tx_vout: u32,
+  value: BigInt,
+) -> Result<Transaction> {
+  let result = ddk_ffi::sign_fund_transaction_input(
+    fund_transaction.try_into()?,
+    buffer_to_vec(&privkey),
+    prev_tx_id,
+    prev_tx_vout,
+    bigint_to_u64(&value)?,
+  )
+  .map_err(|e| Error::from_reason(format!("{:?}", e)))?;
+
+  Ok(result.into())
+}
+
+#[napi]
+pub fn create_cet_adaptor_signature_from_oracle_info(
+  cet: Transaction,
+  oracle_info: OracleInfo,
+  funding_sk: Buffer,
+  funding_script_pubkey: Buffer,
+  total_collateral: BigInt,
+  msgs: Vec<Buffer>,
+) -> Result<AdaptorSignature> {
+  let ffi_oracle_info = oracle_info.into();
+  let ffi_msgs: Vec<Vec<u8>> = msgs.iter().map(buffer_to_vec).collect();
+
+  let result = ddk_ffi::create_cet_adaptor_signature_from_oracle_info(
+    cet.try_into()?,
+    ffi_oracle_info,
+    buffer_to_vec(&funding_sk),
+    buffer_to_vec(&funding_script_pubkey),
+    bigint_to_u64(&total_collateral)?,
+    ffi_msgs,
+  )
+  .map_err(|e| Error::from_reason(format!("{:?}", e)))?;
+
+  Ok(result.into())
+}