@hsuite/smart-engines-sdk 3.1.0 → 3.2.0

package/dist/nestjs/index.d.ts

@@ -1015,6 +1015,7 @@ declare class IPFSClient {
 	getStatus(): Promise<IpfsStatusResponse>;
 	getStorageUsage(): Promise<IpfsStorageUsageResponse>;
 }
+export type SecurityMode = "none" | "partial" | "full";
 export type PreparedTransaction = {
 	success?: boolean;
 	transactionBytes: string;
@@ -1030,135 +1031,267 @@ export type PreparedTransaction = {
 };
 export type PrepareTransferRequest = {
 	chain: ChainType;
-	payerAccountId: string;
+	payerAccountId?: string;
 	from: string;
 	to: string;
 	amount: string;
 	tokenId?: string;
 	entityId?: string;
 	memo?: string;
+	securityMode?: SecurityMode;
+	appOwnerPublicKey?: string;
+	ss58Format?: number;
 };
 export type PrepareNftMintRequest = {
 	chain: ChainType;
-	payerAccountId: string;
-	tokenId: string;
-	metadata: string | string[];
+	payerAccountId?: string;
+	tokenId?: string;
+	metadata?: string | string[];
 	entityId?: string;
+	securityMode?: SecurityMode;
+	appOwnerPublicKey?: string;
+	ss58Format?: number;
+	collection?: number;
+	item?: number;
+	mintTo?: string;
+	witnessData?: unknown;
+	recipient?: string;
+	collectionMint?: string;
+	name?: string;
+	symbol?: string;
+	uri?: string;
+	sellerFeeBasisPoints?: number;
+	mintAuthority?: string;
 };
 export type PrepareNftBurnRequest = {
 	chain: ChainType;
-	payerAccountId: string;
-	tokenId: string;
-	serialNumber: number;
+	payerAccountId?: string;
+	tokenId?: string;
+	serialNumber?: number;
 	entityId?: string;
+	securityMode?: SecurityMode;
+	appOwnerPublicKey?: string;
+	ss58Format?: number;
+	collection?: number;
+	item?: number;
+	mint?: string;
+	owner?: string;
 };
 export type PrepareNftTransferRequest = {
 	chain: ChainType;
-	payerAccountId: string;
-	tokenId: string;
-	serialNumber: number;
-	fromAccountId: string;
-	toAccountId: string;
+	payerAccountId?: string;
+	tokenId?: string;
+	serialNumber?: number;
+	fromAccountId?: string;
+	toAccountId?: string;
 	entityId?: string;
+	securityMode?: SecurityMode;
+	appOwnerPublicKey?: string;
+	ss58Format?: number;
+	collection?: number;
+	item?: number;
+	dest?: string;
+	mint?: string;
+	fromOwner?: string;
+	toOwner?: string;
 };
 export type PrepareTokenCreateRequest = {
-	chain: "hedera";
-	payerAccountId: string;
-	name: string;
-	symbol: string;
-	decimals: number;
-	initialSupply: string;
-	treasuryAccountId: string;
-	entityId: string;
+	chain: ChainType;
+	payerAccountId?: string;
+	name?: string;
+	symbol?: string;
+	decimals?: number;
+	initialSupply?: string;
+	treasuryAccountId?: string;
+	entityId?: string;
 	memo?: string;
 	tokenType?: "FUNGIBLE_COMMON" | "NON_FUNGIBLE_UNIQUE";
+	securityMode?: SecurityMode;
+	appOwnerPublicKey?: string;
 	supplyKey?: string;
 	adminKey?: string;
 	pauseKey?: string;
 	freezeKey?: string;
 	kycKey?: string;
 	wipeKey?: string;
+	mintAuthority?: string;
+	assetId?: number;
+	admin?: string;
+	minBalance?: string;
+	assetName?: string;
+	noneOwnerVkeyHex?: string;
+	initialRecipient?: string;
 };
 export type PrepareTokenMintRequest = {
 	chain: ChainType;
-	payerAccountId: string;
-	tokenId: string;
+	payerAccountId?: string;
+	tokenId?: string;
 	amount: string;
 	recipientAccountId?: string;
 	entityId?: string;
+	securityMode?: SecurityMode;
+	appOwnerPublicKey?: string;
+	assetId?: number;
+	beneficiary?: string;
+	appOwnerVkeyHex?: string;
+	noneOwnerVkeyHex?: string;
+	destination?: string;
 };
 export type PrepareTokenBurnRequest = {
-	chain: "hedera";
-	payerAccountId: string;
-	tokenId: string;
+	chain: ChainType;
+	payerAccountId?: string;
+	tokenId?: string;
 	amount: string;
-	entityId: string;
+	entityId?: string;
+	securityMode?: SecurityMode;
+	appOwnerPublicKey?: string;
+	assetId?: number;
+	who?: string;
+	appOwnerVkeyHex?: string;
+	noneOwnerVkeyHex?: string;
+	source?: string;
 };
-export type PrepareTokenAssociationRequest = {
-	chain: "hedera";
-	payerAccountId: string;
+export type PrepareTokenAssociateRequest = {
+	chain: ChainType;
+	payerAccountId?: string;
 	accountId: string;
 	tokenIds: string[];
-	entityId: string;
+	entityId?: string;
+	owner?: string;
+};
+export type PrepareTokenPauseRequest = {
+	chain: ChainType;
+	payerAccountId?: string;
+	tokenId?: string;
+	assetId?: number;
+	entityId?: string;
+	securityMode?: SecurityMode;
+	appOwnerPublicKey?: string;
+	ss58Format?: number;
+	currentAuthority?: string;
+	newMintAuthority?: string | null;
+	memo?: string;
+};
+export type PrepareTokenUnpauseRequest = PrepareTokenPauseRequest;
+export type PrepareTokenRestrictRequest = {
+	chain: ChainType;
+	payerAccountId?: string;
+	tokenId?: string;
+	accountId?: string;
+	entityId?: string;
+	securityMode?: SecurityMode;
+	appOwnerPublicKey?: string;
+	ss58Format?: number;
+	assetId?: number;
+	who?: string;
+	account?: string;
+	freezeAuthority?: string;
+	memo?: string;
+};
+export type PrepareTokenUnrestrictRequest = PrepareTokenRestrictRequest;
+export type TransactionInfoResponse = {
+	model?: string;
+	description?: string;
+	principles?: string[];
+	supportedChains: string[];
+	responseFormat?: Record<string, string>;
 };
 export type PrepareTopicCreateRequest = {
-	chain: "hedera";
-	payerAccountId: string;
+	payerAccountId?: string;
 	memo?: string;
 	adminKeyRequired?: boolean;
 	submitKeyRequired?: boolean;
 	entityId: string;
 };
 export type PrepareTopicMessageRequest = {
-	chain: "hedera";
-	payerAccountId: string;
+	payerAccountId?: string;
 	topicId: string;
 	message: string | Record<string, unknown>;
 	entityId: string;
 };
-export type PrepareTokenPauseRequest = {
-	chain: "hedera";
-	payerAccountId: string;
-	tokenId: string;
-	entityId: string;
-	memo?: string;
-};
-export type PrepareTokenUnpauseRequest = PrepareTokenPauseRequest;
-export type PrepareTokenRestrictRequest = {
-	chain: "hedera";
-	payerAccountId: string;
+export type PrepareTokenComplianceEnableRequest = {
+	payerAccountId?: string;
 	tokenId: string;
 	accountId: string;
 	entityId: string;
+	securityMode?: SecurityMode;
+	appOwnerPublicKey?: string;
 	memo?: string;
 };
-export type PrepareTokenUnrestrictRequest = PrepareTokenRestrictRequest;
-export type PrepareTokenComplianceEnableRequest = PrepareTokenRestrictRequest;
-export type PrepareTokenComplianceDisableRequest = PrepareTokenRestrictRequest;
+export type PrepareTokenComplianceDisableRequest = PrepareTokenComplianceEnableRequest;
 export type PrepareTokenWipeRequest = {
-	chain: "hedera";
-	payerAccountId: string;
+	payerAccountId?: string;
 	tokenId: string;
 	accountId: string;
 	amount: string;
 	entityId: string;
 	memo?: string;
 };
+declare class HederaTransactionsClient {
+	private readonly http;
+	constructor(http: HttpClient);
+	prepareTopicCreate(request: PrepareTopicCreateRequest): Promise<PreparedTransaction>;
+	prepareTopicMessage(request: PrepareTopicMessageRequest): Promise<PreparedTransaction>;
+	prepareTokenComplianceEnable(request: PrepareTokenComplianceEnableRequest): Promise<PreparedTransaction>;
+	prepareTokenComplianceDisable(request: PrepareTokenComplianceDisableRequest): Promise<PreparedTransaction>;
+	prepareTokenWipe(request: PrepareTokenWipeRequest): Promise<PreparedTransaction>;
+}
 export type PrepareTrustLineRequest = {
-	chain: "xrpl";
-	accountAddress: string;
+	accountAddress?: string;
+	payerAccountId?: string;
 	currency: string;
 	issuerAddress: string;
 	limit?: string;
 	entityId: string;
 };
-export type TransactionInfoResponse = {
-	model?: string;
-	description?: string;
-	principles?: string[];
-	supportedChains: string[];
-	responseFormat?: Record<string, string>;
+declare class XrplTransactionsClient {
+	private readonly http;
+	constructor(http: HttpClient);
+	prepareTrustLine(request: PrepareTrustLineRequest): Promise<PreparedTransaction>;
+}
+export type PrepareTokenCloseAccountRequest = {
+	payerAccountId?: string;
+	account: string;
+	destination: string;
+	owner?: string;
+	entityId?: string;
+	securityMode?: SecurityMode;
+	appOwnerPublicKey?: string;
+	memo?: string;
 };
+declare class SolanaTransactionsClient {
+	private readonly http;
+	constructor(http: HttpClient);
+	prepareTokenCloseAccount(request: PrepareTokenCloseAccountRequest): Promise<PreparedTransaction>;
+}
+export type PrepareAssetSetTeamRequest = {
+	payerAccountId?: string;
+	assetId: number;
+	issuer: string;
+	admin: string;
+	freezer: string;
+	entityId?: string;
+	securityMode?: SecurityMode;
+	appOwnerPublicKey?: string;
+	ss58Format?: number;
+};
+export type PrepareAssetSetMetadataRequest = {
+	payerAccountId?: string;
+	assetId: number;
+	name: string;
+	symbol: string;
+	decimals: number;
+	entityId?: string;
+	securityMode?: SecurityMode;
+	appOwnerPublicKey?: string;
+	ss58Format?: number;
+};
+declare class PolkadotTransactionsClient {
+	private readonly http;
+	constructor(http: HttpClient);
+	prepareAssetSetTeam(request: PrepareAssetSetTeamRequest): Promise<PreparedTransaction>;
+	prepareAssetSetMetadata(request: PrepareAssetSetMetadataRequest): Promise<PreparedTransaction>;
+}
 declare class TransactionsClient {
 	private readonly http;
 	constructor(http: HttpClient);
@@ -1170,17 +1303,11 @@ declare class TransactionsClient {
 	prepareTokenCreate(request: PrepareTokenCreateRequest): Promise<PreparedTransaction>;
 	prepareTokenMint(request: PrepareTokenMintRequest): Promise<PreparedTransaction>;
 	prepareTokenBurn(request: PrepareTokenBurnRequest): Promise<PreparedTransaction>;
-	prepareTokenAssociation(request: PrepareTokenAssociationRequest): Promise<PreparedTransaction>;
+	prepareTokenAssociate(request: PrepareTokenAssociateRequest): Promise<PreparedTransaction>;
 	prepareTokenPause(request: PrepareTokenPauseRequest): Promise<PreparedTransaction>;
 	prepareTokenUnpause(request: PrepareTokenUnpauseRequest): Promise<PreparedTransaction>;
 	prepareTokenRestrict(request: PrepareTokenRestrictRequest): Promise<PreparedTransaction>;
 	prepareTokenUnrestrict(request: PrepareTokenUnrestrictRequest): Promise<PreparedTransaction>;
-	prepareTokenComplianceEnable(request: PrepareTokenComplianceEnableRequest): Promise<PreparedTransaction>;
-	prepareTokenComplianceDisable(request: PrepareTokenComplianceDisableRequest): Promise<PreparedTransaction>;
-	prepareTokenWipe(request: PrepareTokenWipeRequest): Promise<PreparedTransaction>;
-	prepareTopicCreate(request: PrepareTopicCreateRequest): Promise<PreparedTransaction>;
-	prepareTopicMessage(request: PrepareTopicMessageRequest): Promise<PreparedTransaction>;
-	prepareTrustLine(request: PrepareTrustLineRequest): Promise<PreparedTransaction>;
 }
 export type SnapshotStatus = "pending" | "generating" | "completed" | "failed";
 export type SnapshotFormat = "json" | "csv";
@@ -1470,6 +1597,10 @@ declare class SmartEngineClient {
 	readonly tss: TSSClient;
 	readonly ipfs: IPFSClient;
 	readonly transactions: TransactionsClient;
+	readonly hedera: HederaTransactionsClient;
+	readonly xrpl: XrplTransactionsClient;
+	readonly solana: SolanaTransactionsClient;
+	readonly polkadot: PolkadotTransactionsClient;
 	readonly snapshots: SnapshotsClient;
 	readonly historicalBalance: HistoricalBalanceClient;
 	readonly settlement: SettlementClient;

package/dist/nestjs/index.js

@@ -1841,80 +1841,134 @@ var IPFSClient = class {
   }
 };
 
+// src/transactions/chains/hedera.ts
+var HederaTransactionsClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Prepare an HCS topic creation transaction. */
+  async prepareTopicCreate(request) {
+    return this.http.post("/topic/create/prepare", { ...request, chain: "hedera" });
+  }
+  /** Prepare an HCS topic message submission. */
+  async prepareTopicMessage(request) {
+    return this.http.post("/topic/message/prepare", { ...request, chain: "hedera" });
+  }
+  /** Prepare a token compliance-enable (KYC grant) transaction. */
+  async prepareTokenComplianceEnable(request) {
+    return this.http.post("/token/compliance/enable/prepare", { ...request, chain: "hedera" });
+  }
+  /** Prepare a token compliance-disable (KYC revoke) transaction. */
+  async prepareTokenComplianceDisable(request) {
+    return this.http.post("/token/compliance/disable/prepare", { ...request, chain: "hedera" });
+  }
+  /** Prepare a token wipe transaction (force-remove tokens from an account). */
+  async prepareTokenWipe(request) {
+    return this.http.post("/token/wipe/prepare", { ...request, chain: "hedera" });
+  }
+};
+
+// src/transactions/chains/xrpl.ts
+var XrplTransactionsClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Prepare an XRPL TrustSet (trust line) transaction. */
+  async prepareTrustLine(request) {
+    return this.http.post("/trustline/prepare", { ...request, chain: "xrpl" });
+  }
+};
+
+// src/transactions/chains/solana.ts
+var SolanaTransactionsClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Prepare an SPL Token close-account transaction. */
+  async prepareTokenCloseAccount(request) {
+    return this.http.post("/token/close-account/prepare", { ...request, chain: "solana" });
+  }
+};
+
+// src/transactions/chains/polkadot.ts
+var PolkadotTransactionsClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Prepare a pallet-assets.setTeam transaction. */
+  async prepareAssetSetTeam(request) {
+    return this.http.post("/token/set-team/prepare", { ...request, chain: "polkadot" });
+  }
+  /** Prepare a pallet-assets.setMetadata transaction. */
+  async prepareAssetSetMetadata(request) {
+    return this.http.post("/token/set-metadata/prepare", { ...request, chain: "polkadot" });
+  }
+};
+
 // src/transactions/index.ts
 var TransactionsClient = class {
   constructor(http) {
     this.http = http;
   }
   http;
-  /**
-   * Get transaction preparation service info
-   */
+  /** Get transaction preparation service info. */
   async getInfo() {
     return this.http.get("/info");
   }
-  /**
-   * Prepare a transfer transaction for local signing
-   */
+  /** Prepare a transfer transaction (any supported chain). */
   async prepareTransfer(request) {
     return this.http.post("/transfer/prepare", request);
   }
-  /**
-   * Prepare an NFT mint transaction
-   */
+  /** Prepare an NFT mint transaction (any supported chain). */
   async prepareNftMint(request) {
     return this.http.post("/nft/mint/prepare", request);
   }
-  /**
-   * Prepare an NFT burn transaction
-   */
+  /** Prepare an NFT burn transaction (any supported chain). */
   async prepareNftBurn(request) {
     return this.http.post("/nft/burn/prepare", request);
   }
-  /**
-   * Prepare an NFT transfer transaction
-   */
+  /** Prepare an NFT transfer transaction (any supported chain). */
   async prepareNftTransfer(request) {
     return this.http.post("/nft/transfer/prepare", request);
   }
-  /**
-   * Prepare a token creation transaction
-   */
+  /** Prepare a token creation transaction (Hedera, Solana, Polkadot, Cardano). */
   async prepareTokenCreate(request) {
     return this.http.post("/token/create/prepare", request);
   }
-  /**
-   * Prepare a token mint transaction
-   */
+  /** Prepare a token mint transaction (any supported chain). */
   async prepareTokenMint(request) {
     return this.http.post("/token/mint/prepare", request);
   }
   /**
-   * Prepare a fungible token burn transaction (Hedera).
-   *
-   * For NFT burn use `prepareNftBurn` with a serialNumber.
+   * Prepare a fungible token burn transaction (Hedera, Solana, Polkadot,
+   * Cardano). For NFT burn use `prepareNftBurn` with a `serialNumber`.
    */
   async prepareTokenBurn(request) {
     return this.http.post("/token/burn/prepare", request);
   }
   /**
-   * Prepare a token association transaction
+   * Prepare a token association transaction (Hedera HTS associate / Solana
+   * ATA create). On chains that don't need explicit association (XRPL uses
+   * trustlines — see `client.xrpl.prepareTrustLine`), the server returns 400.
    */
-  async prepareTokenAssociation(request) {
+  async prepareTokenAssociate(request) {
     return this.http.post("/token/associate/prepare", request);
   }
-  // ── Capability actions (Hedera) ──────────────────────────────────────
-  /** Prepare a token pause transaction (capability: pausable). */
+  /** Prepare a token pause transaction (Hedera, Polkadot, Solana). */
   async prepareTokenPause(request) {
     return this.http.post("/token/pause/prepare", request);
   }
-  /** Prepare a token unpause transaction (capability: pausable). */
+  /** Prepare a token unpause transaction (Hedera, Polkadot, Solana). */
   async prepareTokenUnpause(request) {
     return this.http.post("/token/unpause/prepare", request);
   }
   /**
-   * Prepare a token restrict (freeze account) transaction (capability:
-   * restrictable). Freezes `accountId` from transacting `tokenId`.
+   * Prepare a token restrict (freeze account) transaction (Hedera, Polkadot,
+   * Solana). Freezes `accountId`/`who`/`account` from transacting the token.
    */
   async prepareTokenRestrict(request) {
     return this.http.post("/token/restrict/prepare", request);
@@ -1923,42 +1977,6 @@ var TransactionsClient = class {
   async prepareTokenUnrestrict(request) {
     return this.http.post("/token/unrestrict/prepare", request);
   }
-  /**
-   * Prepare a token compliance-enable (grant KYC) transaction (capability:
-   * compliant).
-   */
-  async prepareTokenComplianceEnable(request) {
-    return this.http.post("/token/compliance/enable/prepare", request);
-  }
-  /** Prepare a token compliance-disable (revoke KYC) transaction. */
-  async prepareTokenComplianceDisable(request) {
-    return this.http.post("/token/compliance/disable/prepare", request);
-  }
-  /**
-   * Prepare a token wipe transaction (capability: wipeable). Force-removes
-   * `amount` of `tokenId` from `accountId`.
-   */
-  async prepareTokenWipe(request) {
-    return this.http.post("/token/wipe/prepare", request);
-  }
-  /**
-   * Prepare a topic creation transaction
-   */
-  async prepareTopicCreate(request) {
-    return this.http.post("/topic/create/prepare", request);
-  }
-  /**
-   * Prepare a topic message submission transaction
-   */
-  async prepareTopicMessage(request) {
-    return this.http.post("/topic/message/prepare", request);
-  }
-  /**
-   * Prepare a trust line transaction (e.g. XRPL trust lines)
-   */
-  async prepareTrustLine(request) {
-    return this.http.post("/trustline/prepare", request);
-  }
 };
 
 // src/snapshots/index.ts
@@ -2269,8 +2287,16 @@ var SmartEngineClient = class _SmartEngineClient {
   tss;
   /** IPFS decentralized file storage */
   ipfs;
-  /** Transaction preparation for local signing (sovereignty model) */
+  /** Transaction preparation for local signing (sovereignty model) — chain-agnostic */
   transactions;
+  /** Hedera-specific transaction preparation (HCS topics, KYC, wipe) */
+  hedera;
+  /** XRPL-specific transaction preparation (trust lines) */
+  xrpl;
+  /** Solana-specific transaction preparation (close-account) */
+  solana;
+  /** Polkadot-specific transaction preparation (asset setTeam/setMetadata) */
+  polkadot;
   /** Token holder snapshot generation and retrieval */
   snapshots;
   /** Historical balance archive reads (chain-native bigint, returned as decimal string) */
@@ -2300,6 +2326,10 @@ var SmartEngineClient = class _SmartEngineClient {
     this.tss = new TSSClient(this.http);
     this.ipfs = new IPFSClient(this.http);
     this.transactions = new TransactionsClient(this.txHttp);
+    this.hedera = new HederaTransactionsClient(this.txHttp);
+    this.xrpl = new XrplTransactionsClient(this.txHttp);
+    this.solana = new SolanaTransactionsClient(this.txHttp);
+    this.polkadot = new PolkadotTransactionsClient(this.txHttp);
     this.snapshots = new SnapshotsClient(this.http);
     this.historicalBalance = HistoricalBalanceClient.fromHttp(this.http);
     this.settlement = new SettlementClient(this.http);