release 0.5.0 (#19)

Co-authored-by: Victor Hugo <[email protected]>
Co-authored-by: Victor Hugo Martins <[email protected]>

Author: 3 people

codecov.yml

@@ -1,5 +1,8 @@
 coverage:
   status:
     patch:
+      default:
+        informational: true
+    project:
       default:
         target: 70%

deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@moonlight/moonlight-sdk",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "A privacy-focused toolkit for the Moonlight protocol on Stellar Soroban smart contracts.",
   "license": "MIT",
   "tasks": {

src/privacy-channel/index.ts

@@ -8,19 +8,20 @@ import { StellarDerivator } from "../derivation/stellar/index.ts";
 import type { StellarNetworkId } from "../derivation/stellar/stellar-network-id.ts";
 import {
   type ChannelInvokeMethods,
-  type ChannelReadMethods,
+  ChannelReadMethods,
   ChannelSpec,
 } from "./constants.ts";
 import type { ChannelInvoke, ChannelRead } from "./types.ts";
 import type { xdr } from "@stellar/stellar-sdk";
 import * as E from "./error.ts";
+import type { UTXOPublicKey } from "../core/utxo-keypair-base/types.ts";
+import { Buffer } from "buffer";
 
 export class PrivacyChannel {
   private _client: Contract;
   private _authId: ContractId;
   private _assetId: ContractId;
   private _networkConfig: NetworkConfig;
-  private _derivator: StellarDerivator;
 
   public constructor(
     networkConfig: NetworkConfig,
@@ -38,11 +39,6 @@ export class PrivacyChannel {
     this._authId = authId;
 
     this._assetId = assetId;
-
-    this._derivator = new StellarDerivator().withNetworkAndContract(
-      networkConfig.networkPassphrase as StellarNetworkId,
-      channelId as ContractId,
-    );
   }
 
   //==========================================
@@ -61,11 +57,10 @@ export class PrivacyChannel {
   private require(arg: "_client"): Contract;
   private require(arg: "_authId"): ContractId;
   private require(arg: "_networkConfig"): NetworkConfig;
-  private require(arg: "_derivator"): StellarDerivator;
   private require(arg: "_assetId"): ContractId;
   private require(
-    arg: "_client" | "_authId" | "_networkConfig" | "_derivator" | "_assetId",
-  ): Contract | ContractId | NetworkConfig | StellarDerivator {
+    arg: "_client" | "_authId" | "_networkConfig" | "_assetId",
+  ): Contract | ContractId | NetworkConfig {
     if (this[arg]) return this[arg];
     throw new E.PROPERTY_NOT_SET(arg);
   }
@@ -125,10 +120,13 @@ export class PrivacyChannel {
    *
    * @params None
    * @returns {StellarDerivator} The StellarDerivator instance.
-   * @throws {Error} If the StellarDerivator instance is not set.
+   * @throws {Error} If any of the underlying properties are not set.
    */
   public getDerivator(): StellarDerivator {
-    return this.require("_derivator");
+    return new StellarDerivator().withNetworkAndContract(
+      this.getNetworkConfig().networkPassphrase as StellarNetworkId,
+      this.getChannelId() as ContractId,
+    );
   }
 
   /**
@@ -142,8 +140,28 @@ export class PrivacyChannel {
     return this.getClient().getContractId();
   }
 
+  /**
+   * Returns a function that fetches balances for given UTXO public keys.
+   *
+   * @returns {(publicKeys: Uint8Array[]) => Promise<bigint[]>}
+   */
+  public getBalancesFetcher(): (
+    publicKeys: UTXOPublicKey[],
+  ) => Promise<bigint[]> {
+    const fetchBalances = async (
+      publicKeys: UTXOPublicKey[],
+    ): Promise<bigint[]> => {
+      return await this.read({
+        method: ChannelReadMethods.utxo_balances,
+        methodArgs: { utxos: publicKeys.map((pk) => Buffer.from(pk)) },
+      });
+    };
+
+    return fetchBalances;
+  }
+
   //==========================================
-  // Read / Write Methods
+  // Contract Read / Write Methods
   //==========================================
   //
   //

src/transaction-builder/index.ts

@@ -39,6 +39,7 @@ import type {
 import * as E from "./error.ts";
 import { assert } from "../utils/assert/assert.ts";
 import { assertExtOpsExist } from "./validators/operations.ts";
+import type { PrivacyChannel } from "../privacy-channel/index.ts";
 
 export class MoonlightTransactionBuilder {
   private _create: CreateOperation[] = [];
@@ -75,6 +76,22 @@ export class MoonlightTransactionBuilder {
     this._network = network;
   }
 
+  /**
+   *  Creates a MoonlightTransactionBuilder instance from an existing PrivacyChannel.
+   * @param channelClient - The PrivacyChannel instance to use.
+   * @returns  {MoonlightTransactionBuilder} A MoonlightTransactionBuilder instance pre-configured with the PrivacyChannel's parameters.
+   */
+  static fromPrivacyChannel(
+    channelClient: PrivacyChannel,
+  ): MoonlightTransactionBuilder {
+    return new MoonlightTransactionBuilder({
+      channelId: channelClient.getChannelId(),
+      authId: channelClient.getAuthId(),
+      network: channelClient.getNetworkConfig().networkPassphrase,
+      assetId: channelClient.getAssetId(),
+    });
+  }
+
   //==========================================
   // Meta Requirement Methods
   //==========================================

src/utxo-based-account/index.ts

@@ -2,7 +2,10 @@ import { UTXOKeypair } from "../core/utxo-keypair/index.ts";
 import { UTXOStatus } from "../core/utxo-keypair/types.ts";
 import type { BaseDerivator } from "../derivation/base/index.ts";
 import { UTXOSelectionStrategy } from "./selection-strategy.ts";
-import type { UTXOSelectionResult } from "./types.ts";
+import type {
+  UTXOBasedAccountConstructorArgs,
+  UTXOSelectionResult,
+} from "./types.ts";
 import * as E from "./error.ts";
 import { assert } from "../utils/assert/assert.ts";
 /**
@@ -46,16 +49,7 @@ export class UtxoBasedAccount<
   /**
    * Creates a new UtxoBasedAccount instance
    */
-  constructor(args: {
-    derivator: BaseDerivator<Context, Root, Index>;
-    root: Root;
-    options?: {
-      batchSize?: number;
-      fetchBalances?: (publicKeys: Uint8Array[]) => Promise<bigint[]>;
-      startIndex?: number;
-      maxReservationAgeMs?: number;
-    };
-  }) {
+  constructor(args: UTXOBasedAccountConstructorArgs<Context, Root, Index>) {
     this.root = args.root;
     this.derivator = args.derivator;
     this.derivator.withRoot(this.root);

src/utxo-based-account/types.ts

@@ -1,4 +1,5 @@
 import type { UTXOKeypair } from "../core/utxo-keypair/index.ts";
+import type { BaseDerivator } from "../derivation/base/index.ts";
 
 /**
  * Result of UTXO selection for transfers
@@ -8,3 +9,18 @@ export interface UTXOSelectionResult<Context extends string> {
   totalAmount: bigint;
   changeAmount: bigint;
 }
+
+export type UTXOBasedAccountConstructorArgs<
+  Context extends string,
+  Root extends string,
+  Index extends `${number}`,
+> = {
+  derivator: BaseDerivator<Context, Root, Index>;
+  root: Root;
+  options?: {
+    batchSize?: number;
+    fetchBalances?: (publicKeys: Uint8Array[]) => Promise<bigint[]>;
+    startIndex?: number;
+    maxReservationAgeMs?: number;
+  };
+};

src/utxo-based-account/utxo-based-stellar-account/index.ts

@@ -4,9 +4,43 @@ import type {
   StellarDerivationIndex,
   StellarDerivationRoot,
 } from "../../derivation/stellar/types.ts";
+import type { PrivacyChannel } from "../../privacy-channel/index.ts";
+import type { UTXOBasedAccountConstructorArgs } from "../types.ts";
 
 export class UtxoBasedStellarAccount extends UtxoBasedAccount<
   StellarDerivationContext,
   StellarDerivationRoot,
   StellarDerivationIndex
-> {}
+> {
+  /**
+   * Create a UTXO-based Stellar account handler from a PrivacyChannel instance.
+   *
+   * @param args - The arguments for creating the UTXO-based Stellar account handler.
+   * @param args.channelClient - The PrivacyChannel instance to use.
+   * @param args.root - The root derivation key for the Stellar account.
+   * @param args.options - Additional options for the UTXO-based account handler.
+   * @returns {UtxoBasedStellarAccount} A UTXO-based Stellar account handler.
+   */
+  static fromPrivacyChannel(args: {
+    channelClient: PrivacyChannel;
+    root: StellarDerivationRoot;
+    options?: Omit<
+      UTXOBasedAccountConstructorArgs<
+        StellarDerivationContext,
+        StellarDerivationRoot,
+        StellarDerivationIndex
+      >["options"],
+      "fetchBalances"
+    >;
+  }): UtxoBasedStellarAccount {
+    const { channelClient, root } = args;
+    return new UtxoBasedStellarAccount({
+      derivator: channelClient.getDerivator(),
+      root,
+      options: {
+        ...(args.options ?? {}),
+        fetchBalances: channelClient.getBalancesFetcher(),
+      },
+    });
+  }
+}

test/integration/privacy-channel.integration.test.ts

@@ -31,14 +31,14 @@ import {
   generateNonce,
   generateP256KeyPair,
   MoonlightOperation as op,
-  MoonlightTransactionBuilder,
   PrivacyChannel,
 } from "../../mod.ts";
 
 import { Asset, Keypair } from "@stellar/stellar-sdk";
 
 import { disableSanitizeConfig } from "../utils/disable-sanitize-config.ts";
 import { Server } from "@stellar/stellar-sdk/rpc";
+import { MoonlightTransactionBuilder } from "../../src/transaction-builder/index.ts";
 
 describe(
   "[Testnet - Integration] PrivacyChannel",
@@ -232,14 +232,9 @@ describe(
         const utxoAKeypair = await generateP256KeyPair();
         const utxoBKeypair = await generateP256KeyPair();
 
-        const depositTx = new MoonlightTransactionBuilder({
-          network: networkConfig.networkPassphrase,
-          channelId: channelId,
-          authId: authId,
-          assetId: Asset.native().contractId(
-            networkConfig.networkPassphrase,
-          ) as ContractId,
-        });
+        const depositTx = MoonlightTransactionBuilder.fromPrivacyChannel(
+          channelClient,
+        );
 
         const createOpA = op.create(utxoAKeypair.publicKey, 250n);
         const createOpB = op.create(utxoBKeypair.publicKey, 250n);

test/integration/utxo-based-account.integration.test.ts

@@ -187,14 +187,7 @@ describe(
           root: testRoot,
           options: {
             batchSize: 10,
-            fetchBalances: async (publicKeys: Uint8Array[]) => {
-              return channelClient.read({
-                method: ChannelReadMethods.utxo_balances,
-                methodArgs: {
-                  utxos: publicKeys.map((pk) => Buffer.from(pk)),
-                },
-              });
-            },
+            fetchBalances: channelClient.getBalancesFetcher(),
           },
         });
 
@@ -254,25 +247,11 @@ describe(
         const testRoot = "S-TEST_SECRET_ROOT_3";
         const depositAmount = 500000n; // 0.05 XLM
 
-        // Create a fresh derivator for this test
-        const freshDerivator = new StellarDerivator().withNetworkAndContract(
-          StellarNetworkId.Testnet,
-          channelId,
-        );
-
-        const utxoAccount = new UtxoBasedStellarAccount({
-          derivator: freshDerivator,
+        const utxoAccount = UtxoBasedStellarAccount.fromPrivacyChannel({
+          channelClient,
           root: testRoot,
           options: {
             batchSize: 10,
-            fetchBalances: async (publicKeys: Uint8Array[]) => {
-              return channelClient.read({
-                method: ChannelReadMethods.utxo_balances,
-                methodArgs: {
-                  utxos: publicKeys.map((pk) => Buffer.from(pk)),
-                },
-              });
-            },
           },
         });