@hsuite/native-connect-client 1.0.0

package/tests/realnet-session.spec.ts

@@ -0,0 +1,303 @@
+/**
+ * @e2e Session-based realnet tests (env-gated)
+ * @compodoc
+ * Scaffolding for session approval and sign/submit flows against Hedera/XRPL testnets using
+ * SDK session controllers. These tests are gated by environment variables and remain skipped
+ * unless secrets are provided. Full implementation composes unsigned payloads via adapters,
+ * approves a session, signs via SessionFlowController, then submits.
+ *
+ * Hedera env:
+ * - HEDERA_TESTNET_ACCOUNT_ID
+ * - HEDERA_TESTNET_PUBLIC_KEY
+ * - HEDERA_TESTNET_PRIVATE_KEY
+ *
+ * XRPL env:
+ * - XRPL_TESTNET_ADDRESS
+ * - XRPL_TESTNET_SECRET (family seed starting with 's')
+ */
+import { describe, it, expect } from 'vitest';
+import {
+  WalletCore,
+  LedgerRegistry,
+  SessionManager,
+  CryptoService,
+  SessionFlowController,
+} from '@hsuite/native-connect-sdk';
+
+const haveHedera = Boolean(
+  process.env.HEDERA_TESTNET_ACCOUNT_ID &&
+    process.env.HEDERA_TESTNET_PUBLIC_KEY &&
+    process.env.HEDERA_TESTNET_PRIVATE_KEY,
+);
+const haveXrpl = Boolean(process.env.XRPL_TESTNET_ADDRESS && process.env.XRPL_TESTNET_SECRET);
+
+(haveHedera || haveXrpl ? describe : describe.skip)(
+  'Realnet session-based flows (env-gated)',
+  () => {
+    it('Hedera: approve session, sign native transfer, attempt submit (optional)', async () => {
+      if (!haveHedera) return; // skip when not configured
+      const registry = new LedgerRegistry({
+        context: {
+          secureRandom: (n) => crypto.getRandomValues(new Uint8Array(n)),
+          httpClient: {
+            async get() {
+              return {} as unknown as never;
+            },
+            async post() {
+              return {} as unknown as never;
+            },
+          },
+        },
+      });
+      const sessionManager = new SessionManager();
+      const mem = new Map<string, Uint8Array>();
+      const secureMemory = {
+        async store(id?: string, value?: Uint8Array) {
+          if (id && value) mem.set(id, value);
+        },
+        async retrieve(id?: string) {
+          return id ? mem.get(id) : undefined;
+        },
+        async remove(id?: string) {
+          if (id) mem.delete(id);
+        },
+        async clear() {
+          mem.clear();
+        },
+      };
+      const sessionFlow = new SessionFlowController({ registry, sessionManager, secureMemory });
+      const wallet = new WalletCore({
+        registry,
+        sessionManager,
+        keyVault: {
+          async storeSeed() {
+            return { id: 'seed' } as never;
+          },
+          async listSeeds() {
+            return [] as never;
+          },
+          async storeKey() {},
+          async listKeys() {
+            return [] as never;
+          },
+          async getConfig() {
+            return undefined as never;
+          },
+          async setConfig() {},
+          async createRecoveryBundle() {
+            throw new Error('no-op');
+          },
+          async deleteRecoveryBundle() {},
+          async listRecoveryBundles() {
+            return [] as never;
+          },
+        } as never,
+        crypto: new CryptoService(),
+        secureMemory,
+      });
+
+      const { HederaLedgerAdapter } = await import('../../ledger-hedera/dist/index.js');
+      await wallet.registerLedger(new HederaLedgerAdapter());
+
+      // Import private key into secure memory (store under address and publicKey aliases)
+      await wallet.importPrivateKey({
+        ledgerId: 'hedera',
+        networkId: 'hedera:testnet',
+        address: process.env.HEDERA_TESTNET_ACCOUNT_ID!,
+        publicKey: process.env.HEDERA_TESTNET_PUBLIC_KEY!,
+        privateKey: new TextEncoder().encode(process.env.HEDERA_TESTNET_PRIVATE_KEY!),
+        metadata: { label: 'HBAR Realnet' },
+      } as never);
+
+      const sessionId = await sessionFlow.create({
+        appId: 'realnet-suite',
+        appName: 'Realnet Suite',
+        ledgerId: 'hedera',
+        networkId: 'hedera:testnet',
+        nonce: crypto.randomUUID(),
+        timestamp: Date.now(),
+        permissions: ['sign', 'submit'],
+        purpose: [],
+      } as never);
+
+      await sessionFlow.approve(sessionId, [
+        {
+          ledgerId: 'hedera',
+          networkId: 'hedera:testnet',
+          address: process.env.HEDERA_TESTNET_ACCOUNT_ID!,
+          publicKey: process.env.HEDERA_TESTNET_PUBLIC_KEY!,
+          metadata: {},
+        },
+      ]);
+
+      // Compose unsigned native transfer
+      const adapter = registry.get('hedera')!.adapter as unknown as {
+        composeTransferNative: (p: {
+          from: { address: string; ledgerId: string; networkId: string };
+          to: string;
+          amount: string;
+        }) => Promise<Uint8Array>;
+      };
+      const unsigned = await adapter.composeTransferNative({
+        from: {
+          ledgerId: 'hedera',
+          networkId: 'hedera:testnet',
+          address: process.env.HEDERA_TESTNET_ACCOUNT_ID!,
+        },
+        to: process.env.HEDERA_TESTNET_ACCOUNT_ID!,
+        amount: '1',
+      });
+
+      const result = await sessionFlow.sign(sessionId, {
+        ledgerId: 'hedera',
+        networkId: 'hedera:testnet',
+        accountAddress: process.env.HEDERA_TESTNET_PUBLIC_KEY!,
+        payload: unsigned,
+      } as never);
+      expect(result.signature.length).toBeGreaterThan(0);
+
+      // Submit; accept invalid signature temporarily
+      const signedBytes = Uint8Array.from(Buffer.from(result.signature, 'hex'));
+      const submission = await sessionFlow
+        .submit(sessionId, {
+          ledgerId: 'hedera',
+          networkId: 'hedera:testnet',
+          accountAddress: process.env.HEDERA_TESTNET_ACCOUNT_ID!,
+          payload: signedBytes,
+        } as never)
+        .then((h) => String(h))
+        .catch((e) => String(e?.message ?? e));
+      expect(typeof submission).toBe('string');
+    });
+
+    it('XRPL: approve session, trustline compose→sign→submit (optional)', async () => {
+      if (!haveXrpl) return; // skip when not configured
+      const registry = new LedgerRegistry({
+        context: {
+          secureRandom: (n) => crypto.getRandomValues(new Uint8Array(n)),
+          httpClient: {
+            async get() {
+              return {} as unknown as never;
+            },
+            async post() {
+              return {} as unknown as never;
+            },
+          },
+        },
+      });
+      const sessionManager = new SessionManager();
+      const mem = new Map<string, Uint8Array>();
+      const secureMemory = {
+        async store(id?: string, value?: Uint8Array) {
+          if (id && value) mem.set(id, value);
+        },
+        async retrieve(id?: string) {
+          return id ? mem.get(id) : undefined;
+        },
+        async remove(id?: string) {
+          if (id) mem.delete(id);
+        },
+        async clear() {
+          mem.clear();
+        },
+      };
+      const sessionFlow = new SessionFlowController({ registry, sessionManager, secureMemory });
+      const wallet = new WalletCore({
+        registry,
+        sessionManager,
+        keyVault: {
+          async storeSeed() {
+            return { id: 'seed' } as never;
+          },
+          async listSeeds() {
+            return [] as never;
+          },
+          async storeKey() {},
+          async listKeys() {
+            return [] as never;
+          },
+          async getConfig() {
+            return undefined as never;
+          },
+          async setConfig() {},
+          async createRecoveryBundle() {
+            throw new Error('no-op');
+          },
+          async deleteRecoveryBundle() {},
+          async listRecoveryBundles() {
+            return [] as never;
+          },
+        } as never,
+        crypto: new CryptoService(),
+        secureMemory,
+      });
+
+      const { XrplLedgerAdapter } = await import('../../ledger-xrpl/dist/index.js');
+      await wallet.registerLedger(new XrplLedgerAdapter());
+
+      // Import XRPL secret as UTF-8 bytes under the account address
+      await wallet.importPrivateKey({
+        ledgerId: 'xrpl',
+        networkId: 'xrpl:testnet',
+        address: process.env.XRPL_TESTNET_ADDRESS!,
+        publicKey: '',
+        privateKey: new TextEncoder().encode(process.env.XRPL_TESTNET_SECRET!),
+        metadata: { label: 'XRP Realnet' },
+      } as never);
+
+      const sessionId = await sessionFlow.create({
+        appId: 'realnet-suite',
+        appName: 'Realnet Suite',
+        ledgerId: 'xrpl',
+        networkId: 'xrpl:testnet',
+        nonce: crypto.randomUUID(),
+        timestamp: Date.now(),
+        permissions: ['sign', 'submit'],
+        purpose: [],
+      } as never);
+      await sessionFlow.approve(sessionId, [
+        {
+          ledgerId: 'xrpl',
+          networkId: 'xrpl:testnet',
+          address: process.env.XRPL_TESTNET_ADDRESS!,
+          publicKey: '',
+          metadata: {},
+        },
+      ]);
+
+      const adapter = registry.get('xrpl')!.adapter as unknown as {
+        composeEnableAsset: (p: {
+          kind: 'fungible';
+          account: { address: string; ledgerId: string; networkId: string };
+          ref: { symbol: string; issuer: string };
+        }) => Promise<Uint8Array>;
+      };
+      const unsigned = await adapter.composeEnableAsset({
+        kind: 'fungible',
+        account: {
+          ledgerId: 'xrpl',
+          networkId: 'xrpl:testnet',
+          address: process.env.XRPL_TESTNET_ADDRESS!,
+        },
+        ref: { symbol: 'USD', issuer: 'rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe' },
+      });
+
+      const signed = await sessionFlow.sign(sessionId, {
+        ledgerId: 'xrpl',
+        networkId: 'xrpl:testnet',
+        accountAddress: process.env.XRPL_TESTNET_ADDRESS!,
+        payload: unsigned,
+      } as never);
+      expect(signed.signature.length).toBeGreaterThan(0);
+
+      const signedBytes = Uint8Array.from(Buffer.from(signed.signature, 'hex'));
+      const hash = await sessionFlow.submit(sessionId, {
+        ledgerId: 'xrpl',
+        networkId: 'xrpl:testnet',
+        accountAddress: process.env.XRPL_TESTNET_ADDRESS!,
+        payload: signedBytes,
+      } as never);
+      expect(typeof hash).toBe('string');
+    });
+  },
+);

package/tests/signing-harness.spec.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest';
+import { RpcRouter, setLogSink, type LogEvent, getLogSink } from '@hsuite/native-connect-sdk';
+import { SigningHarness } from '../src/harness/signing-harness';
+
+describe('SigningHarness', () => {
+  it('responds with simulated signature', async () => {
+    const previousSink = getLogSink();
+    const events: LogEvent[] = [];
+    setLogSink((event) => {
+      events.push(event);
+    });
+
+    const router = new RpcRouter();
+    router.register('ledger/sign', async () => ({
+      signature: 'demo',
+      payloadHash: 'hash',
+      publicKey: 'key',
+      algorithm: 'ed25519',
+    }));
+
+    const harness = new SigningHarness(router);
+    const response = await harness.send({
+      jsonrpc: '2.0',
+      id: '11111111-1111-1111-1111-111111111111',
+      method: 'ledger/sign',
+      params: {
+        ledgerId: 'xrpl',
+        networkId: 'xrpl:testnet',
+        accountAddress: 'r123',
+        payload: 'ABC=',
+      },
+      timestamp: Date.now(),
+    });
+
+    expect(response).toMatchObject({ id: '11111111-1111-1111-1111-111111111111', jsonrpc: '2.0' });
+    expect(events.some((event) => event.scope?.includes('ReferenceClient'))).toBe(true);
+
+    harness.destroy();
+    setLogSink(previousSink);
+  });
+});

package/tsconfig.build.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "exclude": ["src/**/*.spec.ts", "tests/**/*", "vitest.config.ts"],
+  "references": [{ "path": "../native-wallet-sdk" }, { "path": "../types" }]
+}