@t402/wdk 2.5.0 → 2.6.0

package/dist/cjs/adapters/index.d.ts

@@ -1,5 +1,202 @@
 export { WDKTonSignerAdapter, createWDKTonSigner } from './ton-adapter.js';
 export { WDKSvmSignerAdapter, createWDKSvmSigner } from './svm-adapter.js';
 export { WDKTronSignerAdapter, createWDKTronSigner } from './tron-adapter.js';
-import '../types-C1S0k-2w.js';
+import '../types-BwK8Xgvg.js';
 import 'viem';
+
+/**
+ * Spark (Bitcoin L2) Signer Adapter for WDK
+ *
+ * Wraps a Spark wallet account to implement T402's payment signing interface.
+ * Spark is a Bitcoin L2 built on the Spark SDK (@buildonspark/spark-sdk).
+ */
+/**
+ * SparkWalletAccount interface (matches @buildonspark/spark-sdk)
+ */
+interface SparkWalletAccount {
+    getAddress(): Promise<string>;
+    getBalance(): Promise<bigint>;
+    sendTransaction(params: {
+        to: string;
+        amount: bigint;
+    }): Promise<{
+        hash: string;
+    }>;
+    signMessage(message: string | Uint8Array): Promise<string>;
+}
+/**
+ * WDKSparkSignerAdapter - Adapts a Spark wallet account for T402 payments
+ *
+ * @example
+ * ```typescript
+ * const adapter = await createWDKSparkSigner(sparkAccount);
+ *
+ * // Use with T402 client
+ * const client = createT402HTTPClient({
+ *   signers: [{ scheme: 'exact', network: 'spark:mainnet', signer: adapter }]
+ * });
+ * ```
+ */
+declare class WDKSparkSignerAdapter {
+    private _account;
+    private _address;
+    private _initialized;
+    constructor(account: SparkWalletAccount);
+    /**
+     * Get the wallet address
+     * @throws Error if not initialized
+     */
+    get address(): string;
+    /**
+     * Check if the adapter is initialized
+     */
+    get isInitialized(): boolean;
+    /**
+     * Initialize the adapter by fetching the address
+     * Must be called before using the signer
+     */
+    initialize(): Promise<void>;
+    /**
+     * Sign a message using the Spark wallet
+     * @param message - Message to sign (string or bytes)
+     * @returns Signature string
+     */
+    signMessage(message: string | Uint8Array): Promise<string>;
+    /**
+     * Get the wallet balance in satoshis
+     */
+    getBalance(): Promise<bigint>;
+    /**
+     * Send a transaction via the Spark network
+     * @param params - Transaction parameters
+     * @returns Transaction result with hash
+     */
+    sendTransaction(params: {
+        to: string;
+        amount: bigint;
+    }): Promise<{
+        hash: string;
+    }>;
+}
+/**
+ * Create an initialized WDK Spark signer
+ *
+ * @param account - Spark wallet account from @buildonspark/spark-sdk
+ * @returns Initialized WDKSparkSignerAdapter
+ *
+ * @example
+ * ```typescript
+ * import { T402WDK } from '@t402/wdk';
+ *
+ * const wallet = new T402WDK(seedPhrase, config);
+ * const sparkSigner = await wallet.getSparkSigner();
+ *
+ * // Use with T402 client
+ * const client = createT402HTTPClient({
+ *   signers: [{ scheme: 'exact', network: 'spark:mainnet', signer: sparkSigner }]
+ * });
+ * ```
+ */
+declare function createWDKSparkSigner(account: SparkWalletAccount): Promise<WDKSparkSignerAdapter>;
+
+/**
+ * Bitcoin (BTC) On-Chain Signer Adapter for WDK
+ *
+ * Wraps a Tether WDK Bitcoin account to implement T402's payment signing interface.
+ * This allows WDK-managed Bitcoin wallets to be used for T402 payments.
+ */
+/**
+ * WDKBtcAccount interface (matches @tetherto/wdk-wallet-btc)
+ */
+interface WDKBtcAccount {
+    getAddress(): Promise<string>;
+    getBalance(): Promise<bigint>;
+    sendTransaction(params: {
+        to: string;
+        amount: bigint;
+        fee?: bigint;
+    }): Promise<string>;
+    signMessage(message: string): Promise<string>;
+    signPsbt(psbt: Uint8Array): Promise<Uint8Array>;
+}
+/**
+ * WDKBtcSignerAdapter - Adapts a WDK Bitcoin account for T402 payments
+ *
+ * @example
+ * ```typescript
+ * const adapter = await createWDKBtcSigner(wdkBtcAccount);
+ *
+ * // Use with T402 client
+ * const client = createT402HTTPClient({
+ *   signers: [{ scheme: 'exact', network: 'bip122:000000000019d6689c085ae165831e93', signer: adapter }]
+ * });
+ * ```
+ */
+declare class WDKBtcSignerAdapter {
+    private _account;
+    private _address;
+    private _initialized;
+    constructor(account: WDKBtcAccount);
+    /**
+     * Get the wallet address
+     * @throws Error if not initialized
+     */
+    get address(): string;
+    /**
+     * Check if the adapter is initialized
+     */
+    get isInitialized(): boolean;
+    /**
+     * Initialize the adapter by fetching the address
+     * Must be called before using the signer
+     */
+    initialize(): Promise<void>;
+    /**
+     * Sign a message using the Bitcoin wallet
+     * @param message - Message string to sign
+     * @returns Signature string
+     */
+    signMessage(message: string): Promise<string>;
+    /**
+     * Sign a Partially Signed Bitcoin Transaction (PSBT)
+     * @param psbt - PSBT bytes to sign
+     * @returns Signed PSBT bytes
+     */
+    signPsbt(psbt: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Get the wallet balance in satoshis
+     */
+    getBalance(): Promise<bigint>;
+    /**
+     * Send a Bitcoin transaction
+     * @param params - Transaction parameters
+     * @returns Transaction hash
+     */
+    sendTransaction(params: {
+        to: string;
+        amount: bigint;
+        fee?: bigint;
+    }): Promise<string>;
+}
+/**
+ * Create an initialized WDK Bitcoin signer
+ *
+ * @param account - WDK Bitcoin account from @tetherto/wdk-wallet-btc
+ * @returns Initialized WDKBtcSignerAdapter
+ *
+ * @example
+ * ```typescript
+ * import { T402WDK } from '@t402/wdk';
+ *
+ * const wallet = new T402WDK(seedPhrase, config);
+ * const btcSigner = await wallet.getBtcSigner();
+ *
+ * // Use with T402 client
+ * const client = createT402HTTPClient({
+ *   signers: [{ scheme: 'exact', network: 'bip122:000000000019d6689c085ae165831e93', signer: btcSigner }]
+ * });
+ * ```
+ */
+declare function createWDKBtcSigner(account: WDKBtcAccount): Promise<WDKBtcSignerAdapter>;
+
+export { WDKBtcSignerAdapter, WDKSparkSignerAdapter, createWDKBtcSigner, createWDKSparkSigner };

package/dist/cjs/adapters/index.js

@@ -30,9 +30,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/adapters/index.ts
 var adapters_exports = {};
 __export(adapters_exports, {
+  WDKBtcSignerAdapter: () => WDKBtcSignerAdapter,
+  WDKSparkSignerAdapter: () => WDKSparkSignerAdapter,
   WDKSvmSignerAdapter: () => WDKSvmSignerAdapter,
   WDKTonSignerAdapter: () => WDKTonSignerAdapter,
   WDKTronSignerAdapter: () => WDKTronSignerAdapter,
+  createWDKBtcSigner: () => createWDKBtcSigner,
+  createWDKSparkSigner: () => createWDKSparkSigner,
   createWDKSvmSigner: () => createWDKSvmSigner,
   createWDKTonSigner: () => createWDKTonSigner,
   createWDKTronSigner: () => createWDKTronSigner
@@ -259,6 +263,7 @@ var WDKTronSignerAdapter = class {
   _address = null;
   _initialized = false;
   _rpcUrl;
+  _energyProvider = null;
   constructor(account, rpcUrl = "https://api.trongrid.io") {
     if (!account) {
       throw new Error("WDK TRON account is required");
@@ -360,6 +365,106 @@ var WDKTronSignerAdapter = class {
       );
     }
   }
+  /**
+   * Estimate the energy required for a TRC20 transfer.
+   *
+   * Uses the `wallet/triggerconstantcontract` API to simulate the transfer
+   * and return the energy/bandwidth requirements.
+   *
+   * @param params - Transaction parameters to simulate
+   * @returns Energy estimation result
+   */
+  async estimateEnergy(params) {
+    if (!this._address) {
+      throw new Error("TRON signer not initialized. Call initialize() first.");
+    }
+    const functionSelector = "transfer(address,uint256)";
+    const toAddressHex = this.addressToHex(params.to).slice(2).padStart(64, "0");
+    const amountHex = BigInt(params.amount).toString(16).padStart(64, "0");
+    const parameter = toAddressHex + amountHex;
+    try {
+      const response = await fetch(`${this._rpcUrl}/wallet/triggerconstantcontract`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          owner_address: this.addressToHex(this._address),
+          contract_address: this.addressToHex(params.contractAddress),
+          function_selector: functionSelector,
+          parameter
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`Energy estimation failed: ${response.status}`);
+      }
+      const result = await response.json();
+      if (result.result?.code && result.result.code !== "SUCCESS") {
+        throw new Error(`Energy estimation failed: ${result.result.message ?? result.result.code}`);
+      }
+      const energyRequired = (result.energy_used ?? 0) + (result.energy_penalty ?? 0);
+      const resourceResponse = await fetch(`${this._rpcUrl}/wallet/getaccountresource`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          address: this.addressToHex(this._address)
+        })
+      });
+      let energyAvailable = 0;
+      if (resourceResponse.ok) {
+        const resources = await resourceResponse.json();
+        energyAvailable = (resources.EnergyLimit ?? 0) - (resources.EnergyUsed ?? 0);
+      }
+      const bandwidthRequired = 350;
+      const trxCostIfNoEnergy = BigInt(Math.max(0, energyRequired - energyAvailable)) * 420n;
+      return {
+        energyRequired,
+        energyAvailable,
+        trxCostIfNoEnergy,
+        bandwidthRequired
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to estimate energy: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Sign a TRC20 transfer with dynamic fee limit estimation.
+   *
+   * Instead of using a hardcoded 100 TRX fee limit, estimates the actual
+   * energy cost and adds a 20% margin.
+   *
+   * @param params - Transaction parameters
+   * @returns Hex-encoded signed transaction
+   */
+  async signTransactionWithEstimation(params) {
+    if (!params.feeLimit) {
+      const estimate = await this.estimateEnergy(params);
+      const estimatedFee = estimate.trxCostIfNoEnergy;
+      const feeWithMargin = estimatedFee + estimatedFee * 20n / 100n;
+      const feeLimitSun = Number(
+        feeWithMargin < 10000000n ? 10000000n : feeWithMargin > 150000000n ? 150000000n : feeWithMargin
+      );
+      return this.signTransaction({ ...params, feeLimit: feeLimitSun });
+    }
+    return this.signTransaction(params);
+  }
+  /**
+   * Register an external energy delegation provider.
+   *
+   * Energy providers can delegate bandwidth and energy to this account
+   * to reduce TRX costs for TRC20 transfers.
+   *
+   * @param provider - Energy delegation provider
+   */
+  registerEnergyProvider(provider) {
+    this._energyProvider = provider;
+  }
+  /**
+   * Get the registered energy provider, if any
+   */
+  getEnergyProvider() {
+    return this._energyProvider;
+  }
   /**
    * Build a TRC20 transfer transaction
    */
@@ -443,11 +548,161 @@ async function createWDKTronSigner(account, rpcUrl) {
   await adapter.initialize();
   return adapter;
 }
+
+// src/adapters/spark-adapter.ts
+var WDKSparkSignerAdapter = class {
+  _account;
+  _address = null;
+  _initialized = false;
+  constructor(account) {
+    if (!account) {
+      throw new Error("Spark wallet account is required");
+    }
+    this._account = account;
+  }
+  /**
+   * Get the wallet address
+   * @throws Error if not initialized
+   */
+  get address() {
+    if (!this._address) {
+      throw new Error(
+        "Spark signer not initialized. Call initialize() first or use createWDKSparkSigner()."
+      );
+    }
+    return this._address;
+  }
+  /**
+   * Check if the adapter is initialized
+   */
+  get isInitialized() {
+    return this._initialized;
+  }
+  /**
+   * Initialize the adapter by fetching the address
+   * Must be called before using the signer
+   */
+  async initialize() {
+    if (this._initialized) {
+      return;
+    }
+    this._address = await this._account.getAddress();
+    this._initialized = true;
+  }
+  /**
+   * Sign a message using the Spark wallet
+   * @param message - Message to sign (string or bytes)
+   * @returns Signature string
+   */
+  async signMessage(message) {
+    return this._account.signMessage(message);
+  }
+  /**
+   * Get the wallet balance in satoshis
+   */
+  async getBalance() {
+    return this._account.getBalance();
+  }
+  /**
+   * Send a transaction via the Spark network
+   * @param params - Transaction parameters
+   * @returns Transaction result with hash
+   */
+  async sendTransaction(params) {
+    return this._account.sendTransaction(params);
+  }
+};
+async function createWDKSparkSigner(account) {
+  const adapter = new WDKSparkSignerAdapter(account);
+  await adapter.initialize();
+  return adapter;
+}
+
+// src/adapters/btc-adapter.ts
+var WDKBtcSignerAdapter = class {
+  _account;
+  _address = null;
+  _initialized = false;
+  constructor(account) {
+    if (!account) {
+      throw new Error("WDK Bitcoin account is required");
+    }
+    this._account = account;
+  }
+  /**
+   * Get the wallet address
+   * @throws Error if not initialized
+   */
+  get address() {
+    if (!this._address) {
+      throw new Error(
+        "Bitcoin signer not initialized. Call initialize() first or use createWDKBtcSigner()."
+      );
+    }
+    return this._address;
+  }
+  /**
+   * Check if the adapter is initialized
+   */
+  get isInitialized() {
+    return this._initialized;
+  }
+  /**
+   * Initialize the adapter by fetching the address
+   * Must be called before using the signer
+   */
+  async initialize() {
+    if (this._initialized) {
+      return;
+    }
+    this._address = await this._account.getAddress();
+    this._initialized = true;
+  }
+  /**
+   * Sign a message using the Bitcoin wallet
+   * @param message - Message string to sign
+   * @returns Signature string
+   */
+  async signMessage(message) {
+    return this._account.signMessage(message);
+  }
+  /**
+   * Sign a Partially Signed Bitcoin Transaction (PSBT)
+   * @param psbt - PSBT bytes to sign
+   * @returns Signed PSBT bytes
+   */
+  async signPsbt(psbt) {
+    return this._account.signPsbt(psbt);
+  }
+  /**
+   * Get the wallet balance in satoshis
+   */
+  async getBalance() {
+    return this._account.getBalance();
+  }
+  /**
+   * Send a Bitcoin transaction
+   * @param params - Transaction parameters
+   * @returns Transaction hash
+   */
+  async sendTransaction(params) {
+    return this._account.sendTransaction(params);
+  }
+};
+async function createWDKBtcSigner(account) {
+  const adapter = new WDKBtcSignerAdapter(account);
+  await adapter.initialize();
+  return adapter;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  WDKBtcSignerAdapter,
+  WDKSparkSignerAdapter,
   WDKSvmSignerAdapter,
   WDKTonSignerAdapter,
   WDKTronSignerAdapter,
+  createWDKBtcSigner,
+  createWDKSparkSigner,
   createWDKSvmSigner,
   createWDKTonSigner,
   createWDKTronSigner