fix(wasm): accept rpc-shaped utxo

Author: Hack.bg R&D

Dockerfile

@@ -15,7 +15,7 @@ RUN apt update && apt install -yy curl just git
 ARG ELEMENTS="https://github.com/ElementsProject/elements/releases/download/elements-23.3.1/elements-23.3.1-x86_64-linux-gnu.tar.gz"
 RUN cd /usr/local && curl -Lf "${ELEMENTS}" | tar --strip-components=1 -xz
 # This draws the rest of the owl.
-ARG FADROMA_REF="fdd247c"
+ARG FADROMA_REF="b64fd93"
 ARG FADROMA_URL="https://github.com/hackbg/fadroma"
 RUN git clone --progress -b v3-alpha "${FADROMA_URL}" /fadroma && cd /fadroma && git checkout "${FADROMA_REF}"
 WORKDIR /fadroma

README.md

@@ -253,6 +253,14 @@ The tests run on an automatically managed ephemeral Elements localnet in `elemen
 >The image clones a pinned commit of Fadroma when built;
 >this repo's tests then run in a subdirectory of that.
 
+### Troubleshooting
+
+* `Jet failed` from sanity check (PR#...)
+* `bad-txns-in-ne-out` when inputs/outputs do seem to add up
+  * -> `VerifyAmounts` in Elements `confidential_validation.cpp`  -> oh my...
+  * Use `rpc.listunspent(0, 9999999, [sender])` to get a valid UTXO
+* `min-relay-fee` -> ?
+
 ## Acknowledgments, References, Attribution
 
 This project applies techniques pioneered, described, or otherwise demonstrated

pkg/fadroma_simf.d.ts

@@ -53,7 +53,7 @@ export class Program {
    * Partially-signed redeem transaction without witnesses.
    * For manual signing.
    */
-  redeemPsbt(options: any): any;
+  redeemPsbt(options: any): object;
   /**
    * Produce JSON dict of run-time parameter types.
    */
@@ -85,11 +85,11 @@ export class Pst {
   /**
    * Show [PartiallySignedTransaction]
    */
-  toPset(): any;
+  toPset(): object;
   /**
    * Simplified sign procedure.
    */
-  toSigned(keypair: Keypair): any;
+  toSigned(keypair: Keypair): object;
 }
 
 /**
@@ -109,9 +109,9 @@ export function paramTypes(source: string): object;
 
 export function pst(arg: object): Pst;
 
-export function sendSigned(signer: Keypair, options: any): any;
+export function sendSigned(signer: Keypair, options: any): object;
 
-export function sendUnsigned(options: any): any;
+export function sendUnsigned(options: any): object;
 
 export function sendUnsignedTx(options: any): object;
 

pkg/fadroma_simf.js

@@ -394,7 +394,7 @@ export class Program {
      * Partially-signed redeem transaction without witnesses.
      * For manual signing.
      * @param {any} options
-     * @returns {any}
+     * @returns {object}
      */
     redeemPsbt(options) {
         if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
@@ -497,7 +497,7 @@ export class Pst {
     }
     /**
      * Show [PartiallySignedTransaction]
-     * @returns {any}
+     * @returns {object}
      */
     toPset() {
         if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
@@ -511,7 +511,7 @@ export class Pst {
     /**
      * Simplified sign procedure.
      * @param {Keypair} keypair
-     * @returns {any}
+     * @returns {object}
      */
     toSigned(keypair) {
         if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
@@ -583,7 +583,7 @@ export function pst(arg) {
 /**
  * @param {Keypair} signer
  * @param {any} options
- * @returns {any}
+ * @returns {object}
  */
 export function sendSigned(signer, options) {
     _assertClass(signer, Keypair);
@@ -599,7 +599,7 @@ export function sendSigned(signer, options) {
 
 /**
  * @param {any} options
- * @returns {any}
+ * @returns {object}
  */
 export function sendUnsigned(options) {
     const ret = wasm.sendUnsigned(options);

src/lib.rs

@@ -181,13 +181,13 @@ type Maybe<T> = Result<T, JsError>;
 }
 
 #[wasm_bindgen(js_name = sendSigned)]
-pub fn send_signed (signer: &Keypair, options: &JsValue) -> Maybe<JsValue> {
+pub fn send_signed (signer: &Keypair, options: &JsValue) -> Maybe<Object> {
     let (mut psbt, _) = send_from_js(options, None, None)?;
     Pst(psbt).to_signed(signer)
 }
 
 #[wasm_bindgen(js_name = sendUnsigned)]
-pub fn send_unsigned (options: &JsValue) -> Maybe<JsValue> {
+pub fn send_unsigned (options: &JsValue) -> Maybe<Object> {
     ret_pst(&send_from_js(options, None, None)?.0)
 }
 
@@ -284,16 +284,13 @@ pub fn pst (arg: Object) -> Maybe<Pst> {
     }
     /// Show [PartiallySignedTransaction]
     #[wasm_bindgen(js_name = toPset)]
-    pub fn to_pset (&self) -> Maybe<JsValue> {
+    pub fn to_pset (&self) -> Maybe<Object> {
         ret_pst(&self.0)
     }
     /// Simplified sign procedure.
     #[wasm_bindgen(js_name = toSigned)]
-    pub fn to_signed (&self, keypair: &Keypair) -> Maybe<JsValue> {
-        let signed = sign(&self, keypair)?;
-        let result = ret_pst(&signed.0)?;
-        set!(result, "signedHex", JsValue::from(pset_to_hex(&signed.0)?));
-        Ok(result)
+    pub fn to_signed (&self, keypair: &Keypair) -> Maybe<Object> {
+        ret_pst(&sign(&self, keypair)?.0)
     }
 }
 
@@ -454,7 +451,7 @@ pub fn witness_types (source: JsString) -> Maybe<Object> {
     /// Partially-signed redeem transaction without witnesses.
     /// For manual signing.
     #[wasm_bindgen(js_name = redeemPsbt)]
-    pub fn redeem_psbt (&self, options: &JsValue) -> Maybe<JsValue> {
+    pub fn redeem_psbt (&self, options: &JsValue) -> Maybe<Object> {
         ret_pst(&self.redeem_psbt_utxo(options)?.0)
     }
 
@@ -668,11 +665,11 @@ fn arg_utxos (options: JsValue) -> Maybe<Vec<(OutPoint, TxOut)>> {
 }
 
 fn arg_utxo (options: JsValue) -> Maybe<(OutPoint, TxOut)> {
-    let txid  = get!(options, "txid",      arg_txid)?;
-    let vout  = get!(options, "vout",      arg_vout)?;
-    let recip = get!(options, "recipient", arg_address)?;
-    let asset = get!(options, "asset",     arg_asset_id)?;
-    let value = get!(options, "value",     arg_sats)?;
+    let txid  = get!(options, "txid",    arg_txid)?;
+    let vout  = get!(options, "vout",    arg_vout)?;
+    let recip = get!(options, "address", arg_address)?;
+    let asset = get!(options, "asset",   arg_asset_id)?;
+    let value = get!(options, "amount",  arg_sats)?;
     Ok((OutPoint { txid, vout }, TxOut {
         script_pubkey: recip.script_pubkey(),
         value: TxValue::Explicit(value),
@@ -700,7 +697,7 @@ fn arg_sats (input: JsValue) -> Maybe<u64> {
         warn!("Number -> sats (u64): * 10^8; use BigInt to avoid precision issues");
         try_!("Number -> sats (u64)": f64::try_from(input).map(|x|(x * 100000000.0) as u64))
     } else if JsString::is_type_of(&input) {
-        warn!("String -> sats (u64): use BigInt to avoid typing issues");
+        warn!("String -> sats (u64): use BigInt to avoid type issues");
         try_debug!("String -> sats (u64)": u64::from_str(&input.as_string().unwrap_or_default()))
     } else {
         return err!("sats: received {:?}: need integer", input.js_typeof())
@@ -755,9 +752,11 @@ fn ret_tx (tx: &Transaction) -> Maybe<Object> {
     })
 }
 
-fn ret_pst (psbt: &PartiallySignedTransaction) -> Maybe<JsValue> {
-    match JSON::parse(serde_json::to_string(&psbt)?.as_str()) {
-        Ok(psbt) => Ok(psbt),
-        Err(_)   => err!("failed to deserialize interim psbt")
-    }
+fn ret_pst (pst: &PartiallySignedTransaction) -> Maybe<Object> {
+    Ok(obj! {
+        "global"  = try_!("pst: serialize global":  JSON::parse(serde_json::to_string(&pst.global)?.as_str()))?,
+        "inputs"  = try_!("pst: serialize inputs":  JSON::parse(serde_json::to_string(&pst.inputs())?.as_str()))?,
+        "outputs" = try_!("pst: serialize outputs": JSON::parse(serde_json::to_string(&pst.outputs())?.as_str()))?,
+        "hex"     = JsValue::from(pset_to_hex(&pst)?),
+    })
 }

src/sdk.ts

@@ -70,6 +70,15 @@ export async function Keypair (secret: Uint8Array): Promise<Keypair> {
   return keypair(secret)
 }
 
+/** Wrap a [Keypair] as a Signer. */
+export async function Signer (secret: Uint8Array) {
+  const { pubECDSA } = await import('npm:@scure/btc-signer/utils.js');
+  return {
+    keypair:  await Keypair(secret), 
+    pubEcdsa: pubECDSA(secret),
+  }
+}
+
 /** Load [Wasm] with default settings and create a [Compiler]. */
 export async function Compiler (...args: Parameters<Wasm['compiler']>) {
   const { compiler } = await Wasm();