@hsuite/smart-engines-sdk 3.0.0 → 3.0.2

package/CHANGELOG.md

@@ -18,3 +18,14 @@
 ```
 npm publish --access=public
 ```
+
+## 3.0.1 — 2026-05-11
+
+**Documentation-only fix.** No code changes.
+
+### Fixed
+- README rewritten end-to-end. The 3.0.0 README documented a non-existent
+  `apiKey` connect flow and Hedera-centric examples that contradicted the
+  XRPL-canonical architecture. The new README shows the actual Web3
+  challenge-response auth pattern, all BaaS sub-clients, the NestJS
+  integration, resilience primitives, and accurate peer-dep guidance.

package/README.md

@@ -1,373 +1,342 @@
 # @hsuite/smart-engines-sdk
 
-Type-safe client SDK for Smart Engines multi-chain infrastructure. Build decentralized apps across Hedera, XRPL, Ethereum, Polygon, Solana, Polkadot, Stellar, and Bitcoin.
-
-## Installation
+Client SDK for the [Smart Engines V3](https://hsuite.finance) multi-chain
+platform. Build smart-apps and smart-agents that authenticate via Web3
+challenge-response, talk to the network's BaaS surface (database, storage,
+messaging, functions, deployment), and execute chain operations across
+Hedera, XRPL, Polkadot, Solana, Stellar, EVM, and Bitcoin.
 
 ```bash
-yarn add @hsuite/smart-engines-sdk
-# or
 npm install @hsuite/smart-engines-sdk
 ```
 
-## Quick Start
+Plus the peer deps your app actually uses:
 
-```typescript
-import { SmartEngineClient } from '@hsuite/smart-engines-sdk';
+```bash
+npm install xrpl                 # required — XRPL is canonical for auth
+npm install @hashgraph/sdk       # only if your app does Hedera-side ops
+npm install @nestjs/common @nestjs/core   # only if you use the NestJS integration
+npm install zod                  # peer (likely transitive in your app already)
+```
 
-// Connect to a validator
-const client = new SmartEngineClient({
-  baseUrl: 'https://v3-testnet-sn1.hsuite.network',
-  apiKey: 'your-api-key',
-});
+---
 
-// Check health
-const health = await client.getHealth();
-console.log(health.status); // 'ok'
-```
+## Quick start — Web3 auth + register a smart-app
 
-## Auto-Discovery with Authentication
+The canonical smart-app bootstrap flow:
 
-Connect to the network automatically via HCS registry:
+```ts
+import { BaasClient } from '@hsuite/smart-engines-sdk';
+import { Wallet } from 'xrpl';
+import { sign as xrplSign } from 'ripple-keypairs';
 
-```typescript
-import { SmartEngineClient } from '@hsuite/smart-engines-sdk';
-import { PrivateKey } from '@hashgraph/sdk';
+// 1. Your XRPL wallet (real production: load XRPL_SEED from env / secret store)
+const wallet = Wallet.fromSeed(process.env.XRPL_SEED!);
 
-const privateKey = PrivateKey.fromString(process.env.HEDERA_PRIVATE_KEY!);
+// 2. Construct the BaaS client
+const baas = new BaasClient({
+  hostUrl: 'https://v3-testnet-gateway.hsuite.network',
+  appId: 'pending',          // will be replaced after register()
+  pathPrefix: '/host',       // gateway routes /host/* → smart-host
+});
 
-const { client, validator, session } = await SmartEngineClient.connectToNetwork({
-  network: 'testnet',
-  registryTopicId: process.env.REGISTRY_TOPIC_ID!,
-  chain: 'hedera',
-  address: process.env.HEDERA_ACCOUNT_ID!,
-  publicKey: privateKey.publicKey.toStringRaw(),
-  signFn: (challenge) => {
-    const sig = privateKey.sign(Buffer.from(challenge));
-    return Buffer.from(sig).toString('hex');
+// 3. Authenticate via Web3 challenge-response
+//    Cluster verifies with ripple-keypairs.verify(messageHex.toUpperCase(), signature, publicKey)
+await baas.authenticate({
+  chain: 'xrpl',
+  walletAddress: wallet.address,
+  publicKey: wallet.publicKey,
+  signFn: (message) => {
+    const messageHex = Buffer.from(message, 'utf-8').toString('hex').toUpperCase();
+    return xrplSign(messageHex, wallet.privateKey);
   },
 });
 
-console.log(`Connected to ${validator.operator} at ${validator.endpoint}`);
-console.log(`Session expires: ${session.expiresAt}`);
-```
-
-## API Reference
+// 4. Register a free_testnet smart-app (no HSUITE deposit on testnet; cluster runs DKG)
+const app = await baas.register({
+  name: 'My Smart App',
+  services: ['database', 'storage', 'messaging', 'functions'],
+});
 
-### Account Operations
+console.log(`Registered smart-app ${app.appId} — status: ${app.status}`);
+baas.setAppId(app.appId);
+```
 
-```typescript
-// Create account
-const account = await client.createAccount({
-  chain: 'hedera',
-  initialBalance: '10',
-  validatorTimestamp: '1766490325.123456789',
-  validatorTopicId: '0.0.98765',
-});
-console.log(`Account: ${account.accountId}`);
+**Why XRPL?** Per the Smart Engines V3 architecture, XRPL is canonical for
+smart-app authentication and registration. The cluster's validator/host pods
+pay their own HCS fees from pod-local operator accounts; smart-apps never
+need Hedera credentials for the framework. Smart-apps can still target any
+chain (Hedera, Solana, …) for their own *business logic* — that's separate
+from the dev wallet used to authenticate.
 
-// Get account info
-const info = await client.getAccountInfo('hedera', '0.0.12345');
+**Faster bootstrap?** Use the [`@hsuite/smart-engines-cli`](https://www.npmjs.com/package/@hsuite/smart-engines-cli) — `hsuite init` generates a fresh XRPL wallet + funds it via the testnet faucet + writes `.env.local`, then `hsuite subscribe` registers the smart-app in one command.
 
-// Get balance (native + tokens)
-const balance = await client.getBalance('hedera', '0.0.12345');
-console.log(`Balance: ${balance.balance} | Tokens: ${balance.tokens.length}`);
-```
+---
 
-### Token Operations
+## Available clients
 
-```typescript
-// Create a fungible token
-const token = await client.createToken({
-  chain: 'hedera',
-  name: 'My Token',
-  symbol: 'MTK',
-  decimals: 8,
-  initialSupply: '1000000',
-  type: 'fungible',
-  validatorTimestamp: '1766490325.123456789',
-  validatorTopicId: '0.0.98765',
-  capabilities: {
-    mintable: true,
-    burnable: true,
-    pausable: true,
-    restrictable: true,
-    compliant: true,
-    wipeable: true,
-  },
-});
-console.log(`Token: ${token.tokenId}`);
+| Client | Purpose |
+|---|---|
+| `BaasClient` | Authentication + database + storage + functions + messaging + deployment + agents |
+| `SmartEngineClient` | Chain operations: account create, token create / mint / burn / freeze / wipe, transfers, HCS topics, TSS, IPFS |
+| `SmartGatewayClient` | Gateway operations: routing, domains, DNS |
+| `ValidatorAuthClient` | Standalone Web3 challenge-response auth (lower-level than `BaasClient.authenticate`) |
+| `ValidatorDiscoveryClient` | HCS-registry-based validator discovery |
+| `TSSClient`, `IPFSClient`, `TransactionsClient`, `SettlementClient`, `SnapshotsClient` | Direct sub-client access for advanced flows |
+| `MirrorNodeClient` | Hedera mirror-node helper (when your app does Hedera-side queries) |
 
-// Mint additional tokens
-await client.mintToken({
-  chain: 'hedera',
-  tokenId: token.tokenId,
-  amount: '500000',
-});
+All clients accept the same `pathPrefix: '/host'` option when consumed via
+the cluster gateway. Set `pathPrefix: ''` for direct host access.
 
-// Burn tokens
-await client.burnToken({
-  chain: 'hedera',
-  tokenId: token.tokenId,
-  amount: '100',
-});
+---
 
-// Get token info
-const tokenInfo = await client.getTokenInfo('hedera', token.tokenId);
-console.log(`Supply: ${tokenInfo.totalSupply}`);
-console.log(`Capabilities:`, tokenInfo.capabilities);
-```
+## BaaS sub-clients
 
-### Token Management (Universal Actions)
+Once authenticated, every BaaS sub-client is reachable from a single
+`BaasClient` instance:
 
-```typescript
-// Pause all operations on a token
-await client.pauseToken({ chain: 'hedera', tokenId: '0.0.123' });
-await client.unpauseToken({ chain: 'hedera', tokenId: '0.0.123' });
+### Database (Merkle-anchored key-value store)
 
-// Freeze/unfreeze an account
-await client.restrictAccount({ chain: 'hedera', tokenId: '0.0.123', accountId: '0.0.456' });
-await client.unrestrictAccount({ chain: 'hedera', tokenId: '0.0.123', accountId: '0.0.456' });
+```ts
+const record = await baas.db.insert('users', { name: 'Alice', role: 'developer' });
+// → { document, stateTransition: { merkleProof, stateRoot, ... } }
 
-// KYC grant/revoke
-await client.enableCompliance({ chain: 'hedera', tokenId: '0.0.123', accountId: '0.0.456' });
-await client.disableCompliance({ chain: 'hedera', tokenId: '0.0.123', accountId: '0.0.456' });
+const found = await baas.db.find('users', { role: 'developer' });
+// → { documents: [...], count }
 
-// Wipe tokens from account (compliance action)
-await client.wipeFromAccount({ chain: 'hedera', tokenId: '0.0.123', accountId: '0.0.456', amount: '100' });
+const updated = await baas.db.update('users', record.document._id, { role: 'admin' });
+await baas.db.delete('users', record.document._id);
 ```
 
-### Transaction Operations
+Every write returns a cryptographic state-transition proof anchored on-chain — verifiable without re-reading the DB.
 
-```typescript
-// Transfer native currency
-const tx = await client.transfer({
-  chain: 'hedera',
-  from: '0.0.12345',
-  to: '0.0.67890',
-  amount: '5.0',
-});
-console.log(`TX: ${tx.transactionId} Status: ${tx.status}`);
+### Storage (IPFS-backed)
 
-// Get transaction details
-const details = await client.getTransaction('hedera', tx.transactionId);
+```ts
+const upload = await baas.storage.upload(file, 'avatar.png');
+// → { fileId, cid, url: 'ipfs://bafy…', size }
 
-// Get receipt
-const receipt = await client.getTransactionReceipt('hedera', tx.transactionId);
+const files = await baas.storage.list();
+const usage = await baas.storage.getUsage();
 ```
 
-### Multi-Chain Examples
+### Messaging (pub/sub channels)
 
-The same API works across all supported chains:
+```ts
+await baas.messaging.publish('events', { type: 'user.created', userId: '...' });
+const sub = await baas.messaging.subscribe('events');
+```
 
-```typescript
-// Create accounts on different chains
-const hederaAccount = await client.createAccount({ chain: 'hedera', initialBalance: '10', ... });
-const xrplAccount = await client.createAccount({ chain: 'xrpl', initialBalance: '25', ... });
-const ethAccount = await client.createAccount({ chain: 'ethereum', initialBalance: '0.1', ... });
-const solAccount = await client.createAccount({ chain: 'solana', initialBalance: '1', ... });
+### Functions (verifiable compute)
 
-// Check balances across chains
-const chains = ['hedera', 'xrpl', 'ethereum', 'solana', 'polkadot', 'stellar', 'bitcoin'];
-for (const chain of chains) {
-  const caps = await client.getChainCapabilities(chain);
-  console.log(`${chain}: tokens=${caps.hasTokens} nfts=${caps.hasNFTs} dex=${caps.hasDEX}`);
-}
+```ts
+const fn = await baas.functions.deploy({
+  name: 'compute-hash',
+  runtime: 'node20',
+  trigger: 'http',
+  code: '...',           // your function source
+});
 
-// Query capabilities
-const allCaps = await client.getAllCapabilities();
+const result = await baas.functions.invoke(fn.functionId, { input: '...' });
+// Cluster runs in isolated sandboxes across the validator quorum;
+// 2-of-3 TSS consensus required before result is signed.
 ```
 
-### Consensus Messaging (Hedera HCS)
+### Smart Agents (autonomous workers)
+
+```ts
+const agent = await baas.agents.register({
+  name: 'Trading Bot',
+  capabilities: ['trade', 'withdraw'],
+  rules: {
+    maxTradeAmount: '1000',
+    allowedPairs: ['HBAR/USDC'],
+    dailyLimit: '5000',
+    requireApprovalAbove: '10000',
+  },
+});
+
+// Rules are pinned to HCS and enforced by the validator quorum.
+// Every agent action is rules-checked, TSS-signed, then submitted on chain.
 
-```typescript
-// Submit message to HCS topic
-const result = await client.submitMessage('hedera', '0.0.98765', JSON.stringify({
-  type: 'governance.proposal',
-  data: { title: 'Increase validator cap', description: '...' },
-}));
-console.log(`Sequence: ${result.sequenceNumber}`);
+await baas.agents.fund(agent.agentId,  { chain: 'hedera', amount: '500' });
+await baas.agents.trade(agent.agentId, { chain: 'hedera', pair: 'HBAR/USDC', side: 'buy', amount: '100' });
+await baas.agents.pause(agent.agentId);
+await baas.agents.resume(agent.agentId);
+const events = await baas.agents.getEvents(agent.agentId);
 ```
 
-### Validator Management
-
-```typescript
-// List validator templates
-const templates = await client.validators.listTemplates();
+### Deployment
 
-// Check validator health
-const health = await client.validators.getHealth();
+```ts
+const deployment = await baas.deployment.create({
+  name: 'My Smart App v2',
+  services: ['database', 'storage', 'messaging'],
+  config: { /* app-specific */ },
+});
 
-// Get validator info
-const validatorInfo = await client.validators.getInfo();
+const apps = await baas.deployment.list();
+const info = await baas.deployment.get(appId);
+await baas.deployment.suspend(appId);
+await baas.deployment.resume(appId);
 ```
 
-### Subscription Management
+---
 
-```typescript
-// Check subscription status
-const status = await client.subscription.getStatus('my-app-id');
+## Chain operations via `SmartEngineClient`
 
-// Request subscription (deposits HSUITE tokens)
-const sub = await client.subscription.request({
-  appId: 'my-app',
-  developerAccountId: '0.0.12345',
-  chain: 'hedera',
-  selectedTier: 'starter',
-  selectedNetworks: ['hedera'],
-});
-console.log(`Deposit to: ${sub.depositWallet} Amount: ${sub.amount}`);
-```
+For direct chain operations independent of BaaS — e.g., a custodial backend
+that creates accounts and tokens on behalf of users:
 
-### BaaS (Backend-as-a-Service)
+```ts
+import { SmartEngineClient } from '@hsuite/smart-engines-sdk';
 
-```typescript
-import { BaasClient } from '@hsuite/smart-engines-sdk';
+const client = new SmartEngineClient({
+  baseUrl: 'https://v3-testnet-gateway.hsuite.network',
+  // Auth via authToken (set after the Web3 challenge flow):
+  authToken: '<jwt-from-validator-auth-verify>',
+});
 
-const baas = new BaasClient({
-  hostUrl: 'https://host.hsuite.network',
-  appId: 'my-app-id',
+// Create an account on any supported chain
+const account = await client.createAccount({
   chain: 'hedera',
+  initialBalance: '10',
+  validatorTimestamp: '...',
+  validatorTopicId: '0.0.98765',
 });
 
-// Authenticate with wallet
-await baas.authenticate({
-  address: '0.0.12345',
-  signFn: async (challenge) => privateKey.sign(Buffer.from(challenge)).toString('hex'),
+// Create a fungible token
+const token = await client.createToken({
+  chain: 'hedera',
+  name: 'My Token', symbol: 'MTK',
+  decimals: 8, initialSupply: '1000000',
+  type: 'fungible',
+  capabilities: { mintable: true, burnable: true, pausable: true, restrictable: true, compliant: true, wipeable: true },
+  validatorTimestamp: '...', validatorTopicId: '0.0.98765',
 });
 
-// Database operations (with Merkle proofs)
-const doc = await baas.database.insert('users', { name: 'Alice', role: 'admin' });
-const users = await baas.database.find('users', { role: 'admin' });
-const proof = await baas.database.getProof('users', doc.id); // Merkle proof
-
-// Storage (IPFS-backed)
-const file = await baas.storage.upload('data.json', Buffer.from(JSON.stringify(data)));
-const download = await baas.storage.download(file.fileId);
-
-// Serverless functions (Ed25519 code signing required)
-await baas.functions.deploy({
-  name: 'process-payment',
-  runtime: 'nodejs',
-  signedCode: { code, signature, publicKey, timestamp, hash },
+// Transfer
+const tx = await client.transfer({
+  chain: 'hedera', from: '0.0.1', to: '0.0.2', amount: '1.5',
+  validatorTimestamp: '...', validatorTopicId: '0.0.98765',
 });
-const result = await baas.functions.invoke('process-payment', { amount: 100 });
 
-// Real-time messaging
-await baas.messaging.publish('notifications', { type: 'payment', amount: 100 });
-```
+// Balance + info
+const balance = await client.getBalance('hedera', '0.0.12345');
+const info = await client.getAccountInfo('hedera', '0.0.12345');
 
-## Error Handling
+// HCS topic ops, IPFS pinning, TSS signing — all available via sub-clients
+await client.tss.signMPC({ chain: 'hedera', entityId: '...', transactionBytes: '0x...' });
+await client.ipfs.upload(file, 'document.pdf');
+await client.transactions.prepareTransfer({ chain: 'xrpl', from: '...', to: '...', amount: '100' });
+```
 
-All errors are instances of `SmartEngineError` with structured error codes:
+---
 
-```typescript
-import { SmartEngineError, ErrorCode } from '@hsuite/smart-engines-sdk';
+## NestJS integration
 
-try {
-  await client.transfer({ chain: 'hedera', from: '0.0.1', to: '0.0.2', amount: '999999' });
-} catch (error) {
-  if (error instanceof SmartEngineError) {
-    console.log(`Code: ${error.code}`);          // e.g., 'INSUFFICIENT_BALANCE'
-    console.log(`Status: ${error.statusCode}`);   // e.g., 400
-    console.log(`Retryable: ${error.isRetryable}`); // e.g., false
-    console.log(`Context:`, error.context);       // e.g., { chain: 'hedera' }
-
-    switch (error.code) {
-      case ErrorCode.INSUFFICIENT_BALANCE:
-        console.log('Not enough funds');
-        break;
-      case ErrorCode.CHAIN_CONNECTION_ERROR:
-        console.log('Network issue — will retry');
-        if (error.isRetryable) { /* retry logic */ }
-        break;
-      case ErrorCode.RATE_LIMIT_EXCEEDED:
-        console.log('Too many requests — back off');
-        break;
-    }
-  }
-}
-```
-
-### Error Codes
-
-| Code | Description | Retryable |
-|------|-------------|-----------|
-| `INSUFFICIENT_BALANCE` | Not enough native or token balance | No |
-| `INVALID_ACCOUNT_ID` | Account doesn't exist or is deleted | No |
-| `CHAIN_CONNECTION_ERROR` | Network/RPC connectivity issue | Yes |
-| `CHAIN_TIMEOUT` | Request timed out | Yes |
-| `RATE_LIMIT_EXCEEDED` | Too many requests | Yes |
-| `INVALID_TRANSACTION` | Malformed or invalid transaction | No |
-| `TRANSACTION_FAILED` | Transaction executed but failed | No |
-| `CONTRACT_REVERT` | Smart contract execution reverted | No |
-| `TOKEN_NOT_ASSOCIATED` | Token not associated to account (Hedera) | No |
-| `TRUST_LINE_REQUIRED` | Trust line needed (XRPL/Stellar) | No |
-| `INVALID_SIGNATURE` | Bad signature on transaction | No |
-
-## NestJS Integration
-
-```typescript
+```ts
+// app.module.ts
 import { Module } from '@nestjs/common';
-import { SmartEngineModule } from '@hsuite/smart-engines-sdk';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { SmartEngineModule } from '@hsuite/smart-engines-sdk/nestjs';
 
 @Module({
   imports: [
-    SmartEngineModule.forRoot({
-      baseUrl: 'https://v3-testnet-sn1.hsuite.network',
-      apiKey: process.env.SMART_ENGINE_API_KEY,
+    ConfigModule.forRoot({ isGlobal: true }),
+    SmartEngineModule.forRootAsync({
+      imports: [ConfigModule],
+      useFactory: (config: ConfigService) => ({
+        baseUrl: config.get('VALIDATOR_URL')!,
+        timeout: 30000,
+        testConnection: true,
+        autoReconnect: true,
+        reconnectInterval: 5000,
+      }),
+      inject: [ConfigService],
+      isGlobal: true,
     }),
   ],
 })
 export class AppModule {}
 ```
 
-Then inject:
+Inject the `SmartEngineService` into your controllers / services for typed
+access to `client.getHealth() / client.createAccount() / ...`.
+
+---
+
+## Resilience primitives
+
+The SDK ships circuit-breaker, rate-limiter, and retry primitives used
+internally — exposed for app-level use too:
+
+```ts
+import { CircuitBreaker, RateLimiter, retryWithBackoff } from '@hsuite/smart-engines-sdk';
+
+const breaker = new CircuitBreaker({ failureThreshold: 5, resetTimeoutMs: 30_000 });
+const result = await breaker.execute(() => someFlakyOperation());
+
+const limiter = new RateLimiter({ maxRequests: 60, windowMs: 60_000 });
+if (limiter.isAllowed(walletAddress)) { /* proceed */ }
+
+const value = await retryWithBackoff(
+  () => someTransientCall(),
+  { maxRetries: 3, initialDelayMs: 200, backoffMultiplier: 2 },
+);
+```
 
-```typescript
-import { Injectable } from '@nestjs/common';
-import { SmartEngineService } from '@hsuite/smart-engines-sdk';
+---
 
-@Injectable()
-export class PaymentService {
-  constructor(private readonly smartEngine: SmartEngineService) {}
+## Error handling
 
-  async processPayment(from: string, to: string, amount: string) {
-    return this.smartEngine.client.transfer({
-      chain: 'hedera',
-      from,
-      to,
-      amount,
-    });
+```ts
+import { SmartEngineError, ErrorCode, UnsupportedCapabilityError, BaasError } from '@hsuite/smart-engines-sdk';
+
+try {
+  await client.createToken({ chain: 'xrpl', name: 'X', symbol: 'X', type: 'fungible', /* ... */ capabilities: { wipeable: true } });
+} catch (err) {
+  if (err instanceof UnsupportedCapabilityError) {
+    console.error(`${err.capability} not supported on ${err.chain}; alternatives:`, err.alternatives);
+  } else if (err instanceof SmartEngineError && err.code === ErrorCode.RATE_LIMIT_EXCEEDED) {
+    // back off + retry
+  } else if (err instanceof BaasError) {
+    console.error('BaaS request failed:', err.statusCode, err.details);
   }
 }
 ```
 
-### Async configuration:
+---
 
-```typescript
-SmartEngineModule.forRootAsync({
-  useFactory: (config: ConfigService) => ({
-    baseUrl: config.get('VALIDATOR_URL'),
-    apiKey: config.get('API_KEY'),
-  }),
-  inject: [ConfigService],
-});
-```
+## Peer dependencies
+
+| Package | Required? | When |
+|---|---|---|
+| `xrpl` | required | Web3 auth signing (`Wallet.fromSeed`, `wallet.publicKey`, etc.) |
+| `zod` | required | Schema validation (request/response shapes) |
+| `@nestjs/common` + `@nestjs/core` | optional | Only if you import from `@hsuite/smart-engines-sdk/nestjs` |
+| `@hashgraph/sdk` | optional | Only if your app does Hedera-side business logic |
+
+`ripple-keypairs` is a transitive dep of `xrpl` — no separate install needed.
 
-## Supported Chains
+---
+
+## Bundle
+
+The SDK is a single 134 KB CJS bundle with workspace-only primitives
+vendored in. Single-file `.d.ts` (84 KB) for full type ergonomics.
+
+```
+@hsuite/smart-engines-sdk@3.0.0
+  dist/index.js              134 KB    — main bundle
+  dist/index.d.ts             84 KB    — types
+  dist/nestjs/index.js       104 KB    — NestJS integration
+  dist/nestjs/index.d.ts      64 KB
+```
 
-| Chain | Account Ops | Tokens | NFTs | Messaging | DEX | Multi-Sig |
-|-------|------------|--------|------|-----------|-----|-----------|
-| Hedera | ✅ | ✅ HTS | ✅ | ✅ HCS | — | ✅ TSS |
-| XRPL | ✅ | ✅ Trust Lines | ✅ XLS-20 | — | ✅ Native | ✅ SignerList |
-| Ethereum | ✅ | ✅ ERC-20 | — | — | — | ✅ Safe |
-| Polygon | ✅ | ✅ ERC-20 | — | — | — | ✅ Safe |
-| Solana | ✅ | ✅ SPL | ✅ Metaplex | — | — | ✅ Squads |
-| Polkadot | ✅ | ✅ Assets | — | — | — | — |
-| Stellar | ✅ | ✅ Assets | — | — | ✅ SDEX | — |
-| Bitcoin | ✅ | — | — | — | — | — |
+---
 
 ## License
 
-Proprietary — HSuite Trust
+MIT. Built on the Smart Engines V3 architecture
+([github.com/HSuiteNetwork/smart-engines-multichain](https://github.com/HSuiteNetwork/smart-engines-multichain)).