chore(sdk): remove redundant definitions

Author: Hack.bg R&D

src/sdk.ts

@@ -13,43 +13,6 @@ import type {
 
 /** Instance of SimplicityHL WASM module. */
 export type Wasm = InitOutput;
-
-/** WASM instance of keypair. */
-export type Keypair = WasmKeypair;
-
-/** SimplicityHL compiler instance configured for specific chain. */
-export type Compiler = WasmCompiler;
-
-/** Collection of SimplicityHL program argument types (template parameters or witness values). */
-export type ArgTypes = Record<string, string>;
-
-/** Collection of SimplicityHL program arguments with values (template parameters or witness values). */
-export type Args = Record<string, Arg>;
-
-/** SimplicityHL program argument (template parameter or witness value). */
-export type Arg = { type: string, value: unknown };
-
-/** SimplicityHL program compiler for specific chain and parameters. */
-export type Program = WasmProgram & {
-  rpcCommit: Fn,
-  rpcRedeem: Fn,
-};
-
-/** Parameters for commit transaction. */
-export type Call = { previous: unknown, amount: Num, fee: Num };
-
-/** Parameters for commit transaction. */
-export type Commit = Call & { from: string };
-
-/** Parameters for redeem transaction. */
-export type Redeem = Call & { recipient: string, witness?: Args };
-
-/** Connection to Elements RPC for sending and signing transactions. */
-export type Connect = (Log & Partial<Pick<Bitcoin, 'rpc'|'rest'>>) & {
-  send? (hex: Uint8Array): Fn.Async<unknown>
-  sign? (hex: Uint8Array): Fn.Async<Uint8Array>
-};
-
 /** Load SimplicityHL WASM module. */
 export async function Wasm ({
   wasm = process.env['FADROMA_SIMF_WASM'] || import.meta.resolve('../pkg/fadroma_simf_bg.wasm') as string|URL|object,
@@ -64,27 +27,63 @@ export async function Wasm ({
   return wrap;
 }
 
+/** WASM instance of keypair. */
+export type Keypair = WasmKeypair;
 /** Load [Wasm] with default settings and create a [WasmKeypair]. */
 export async function Keypair (secret: Uint8Array) {
   const { keypair } = await Wasm();
   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),
-  }
-}
-
+/** SimplicityHL compiler instance configured for specific chain. */
+export type Compiler = WasmCompiler;
 /** Load [Wasm] with default settings and create a [Compiler]. */
 export async function Compiler (...args: Parameters<Wasm['compiler']>) {
   const { compiler } = await Wasm();
   return compiler(...args)
 }
 
+/** Collection of SimplicityHL program argument types (template parameters or witness values). */
+export type ArgTypes = Record<string, string>;
+
+/** Collection of SimplicityHL program arguments with values (template parameters or witness values). */
+export type Args = Record<string, Arg>;
+
+/** SimplicityHL program argument (template parameter or witness value). */
+export type Arg = { type: string, value: unknown };
+/** Format a `{ type, value }` pair as used to pass `param` and `witness` values. */
+export function Arg (type: string, value?: unknown) {
+  return { type, value }
+}
+/** SimplicityHL program argument constructors.
+  *
+  * TODO: Fully cover https://github.com/BlockstreamResearch/SimplicityHL/blob/master/src/types.rs#L815 */
+export namespace Arg {
+  /** Literal 256-bit number. */
+  export const U256      = defU256('U256');
+  /** SimplicityHL signature field (32 bytes). */
+  export const Signature = defU256('Signature');
+  /** SimplicityHL public key field (32 bytes). */
+  export const Pubkey    = defU256('Pubkey');
+  /** SimplicityHL message field (32 bytes). */
+  export const Message   = defU256('Message');
+
+  /** Name-tagged 32-byte array, equivalent to U256. */
+  function defU256 (type: string) {
+    /** Construct the given kind of U256-like. */
+    return Fn.Name(type, function defineU256 (
+      value: Uint8Array<ArrayBufferLike> = new Uint8Array(new Array(32).fill(0))
+    ) {
+      return { type, value: '0x'+Base16.encode(value) }
+    });
+  }
+}
+
+/** SimplicityHL program compiler for specific chain and parameters. */
+export type Program = WasmProgram & {
+  rpcCommit: Fn,
+  rpcRedeem: Fn,
+};
 /** Load WASM with default settings, create [Compiler], and compile program.
   *
   * Example:
@@ -123,60 +122,8 @@ export async function Program (source: string, {
   const program = compiler.compile(source, { args, chain });
   // Inspect WASM program descriptor, receiving the P2TR.
   const fields = (program as unknown as { toJSON (): Program }).toJSON();
-  // Deserialize args (FIXME? do this on the rust side)
-  if (typeof fields.args === 'string') fields.args = JSON.parse(fields.args as unknown as string);
   // Manually attach properties and methods:
-  return Object.assign(program, fields, {
-    async rpcCommit ({
-      rest = missing('rest'), rpc = missing('rpc'), ...options
-    }: Connect & Commit) {
-      const tx = program.commitTx(options);
-      return await rest.tx(await rpc!.sendrawtransaction(tx.hex));
-    },
-    async rpcRedeem ({
-      rest = missing('rest'), rpc = missing('rpc'), ...options
-    }: Connect & Redeem) {
-      const tx = program.redeemTx(options);
-      return await rest.tx(await rpc.sendrawtransaction(tx.hex));
-    }
-  });
-}
-
-/** Format a `{ type, value }` pair as used to pass `param` and `witness` values. */
-export function Arg (type: string, value?: unknown) {
-  return { type, value }
+  return Object.assign(program, fields);
 }
 
-/** SimplicityHL program argument constructors.
-  *
-  * TODO: Fully cover https://github.com/BlockstreamResearch/SimplicityHL/blob/master/src/types.rs#L815 */
-export namespace Arg {
-  /** Literal 256-bit number. */
-  export const U256      = defU256('U256');
-  /** SimplicityHL signature field (32 bytes). */
-  export const Signature = defU256('Signature');
-  /** SimplicityHL public key field (32 bytes). */
-  export const Pubkey    = defU256('Pubkey');
-  /** SimplicityHL message field (32 bytes). */
-  export const Message   = defU256('Message');
-
-  /** Name-tagged 32-byte array, equivalent to U256. */
-  function defU256 (type: string) {
-    /** Construct the given kind of U256-like. */
-    return Fn.Name(type, function defineU256 (
-      value: Uint8Array<ArrayBufferLike> = new Uint8Array(new Array(32).fill(0))
-    ) {
-      return { type, value: '0x'+Base16.encode(value) }
-    });
-  }
-}
-
-/** Partially signed transaction from SimplicityHL WASM module. */
-export interface Transaction {
-  input: unknown[]
-  output: unknown[]
-  version: unknown
-  lock_time: { block: number }|{ seconds: number }
-};
-
 export type * from './pkg/fadroma_simf.d.ts';

src/test.ts

@@ -2,9 +2,9 @@
 import { deepStrictEqual as equal, rejects, throws, ok } from 'node:assert';
 import { Base16, Fn, Test, Run, sleep } from '../../../library/index.ts';
 import Btc, { Rpc, LiquidTestnet, ElementsRegtest } from '../../Bitcoin/index.ts';
-import { Signer, Program, Wasm, Arg, Args } from './sdk.ts';
+import * as SimplicityHL from './sdk.ts';
 const { is, has } = Test;
-const { sendSigned, keypair } = await Wasm();
+const { sendSigned, keypair } = await SimplicityHL.Wasm();
 
 const keypair1 = keypair(new Uint8Array(Array(32).fill(8)));
 const keypair2 = keypair(new Uint8Array(Array(32).fill(9)));
@@ -14,7 +14,7 @@ export default Test(import.meta, 'SimplicityHL', TestWasm(), TestOnLocalnet(), T
 
 // Check that the API entrypoints are present on the WASM module:
 export function TestWasm() {
-  return Test('WASM', () => Wasm(),
+  return Test('WASM', () => SimplicityHL.Wasm(),
     has('paramTypes',     is('function')),
     has('witnessTypes',   is('function')),
     has('compiler',       is('function')),
@@ -80,10 +80,10 @@ export function TestOnLocalnet () {
         argTypes: { PK: "u256" },
         witTypes: { SIG: "[u8; 64]" },
         provideArgs: () => ({
-          PK: Arg.Pubkey(keypair1.xOnlyPublicKey())
+          PK: SimplicityHL.Arg.Pubkey(keypair1.xOnlyPublicKey())
         }),
         provideWits: (sighash: Uint8Array<ArrayBufferLike>) => ({
-          SIG: Arg.Signature(keypair1.signSchnorr(sighash)),
+          SIG: SimplicityHL.Arg.Signature(keypair1.signSchnorr(sighash)),
         }),
         fee: 2.7e-7, })),
     // Shutdown the localnet.
@@ -176,7 +176,7 @@ function TestProgram (name: string, src: string, {
   argTypes    = {} as Record<string, string>,
   witTypes    = {} as Record<string, string>,
   /** Function that provides parameter data. */
-  provideArgs = null as null|Fn.Returns<Fn.Async<Args>>,
+  provideArgs = null as null|Fn.Returns<Fn.Async<SimplicityHL.Args>>,
   /** Function that provides witness data. */
   provideWits = null as null|Fn<[Uint8Array<ArrayBufferLike>], Fn.Async<object>>,
 } = {}) {
@@ -194,14 +194,19 @@ function TestProgram (name: string, src: string, {
     const args = provideArgs ? await provideArgs() : undefined;
 
     // Ok, compile this program for this chain with these arguments.
-    const prog = await Program(src, { chain: ID, genesis, args });
+    const prog = await SimplicityHL.Program(src, { chain: chain.ID, genesis, args });
 
     // Check against expected program address, if provided.
     if (p2tr) equal(prog.p2tr, p2tr);
 
     // Fund program from deployer:
     // TODO: Use sendSigned
-    const id = await rpc.sendtoaddress(p2tr, String(1));
+    const commitAmount = 1_00000000n;
+    const commitTxid = await SimplicityHL.Spend()
+      .input(chain.findUtxo(keypair1, commitAmount).keypair1)
+      .output(p2tr, commitAmount)
+      .fee(fee)
+      .broadcast(chain);
 
     // Create local spender wallet and import it to RPC:
     const recipient = P2WPKH(keypair1.publicKey()).address;