@idos-network/kwil-infra 1.2.0 → 2.2.0

package/dist/xrpl-credentials/index.d.mts

@@ -1,179 +1,188 @@
-import * as _$xrpl from "xrpl";
 import { TxResponse, Wallet } from "xrpl";
-
 //#region src/xrpl-credentials/accept.d.ts
 /**
-* Payload structure for XRPL CredentialAccept transaction
-*
-* This type defines the required fields for creating a credential acceptance
-* transaction on the XRP Ledger. The CredentialType field is automatically
-* encoded as a hex string from the UTF-8 representation of the credential type.
-*/
-type CredentialAcceptPayload = {
-  /** Transaction type identifier - must be "CredentialAccept" */TransactionType: "CredentialAccept"; /** The issuer's XRPL address who created the Credential object */
-  Issuer: string; /** The account's XRPL address who is receiving the credential */
-  Account: string; /** The type of credential being accepted (encoded as hex string) */
+ * Payload structure for XRPL CredentialAccept transaction
+ *
+ * This type defines the required fields for creating a credential acceptance
+ * transaction on the XRP Ledger. The CredentialType field is automatically
+ * encoded as a hex string from the UTF-8 representation of the credential type.
+ */
+export type CredentialAcceptPayload = {
+  /** Transaction type identifier - must be "CredentialAccept" */
+  TransactionType: "CredentialAccept";
+  /** The issuer's XRPL address who created the Credential object */
+  Issuer: string;
+  /** The account's XRPL address who is receiving the credential */
+  Account: string;
+  /** The type of credential being accepted (encoded as hex string) */
   CredentialType: string;
 };
 /**
-* Creates a credential acceptance payload for XRPL transactions
-*
-* This function constructs a properly formatted payload for credential acceptance
-* transactions. The credential type is automatically encoded from UTF-8 to hex
-* format as required by XRPL specifications.
-*
-* @param issuerAddress - The XRPL address of the credential issuer
-* @param accountAddress - The XRPL address of the account accepting the credential
-* @param credentialType - The human-readable idOS credential type (e.g., "KYC")
-* @returns A properly formatted CredentialAcceptPayload object
-*
-* @example
-* ```typescript
-* const payload = OriginalCredentialAcceptPayload(
-*   "rIssuerAddress123...",
-*   "rAccountAddress456...",
-*   "KYC"
-* );
-* // Result: {
-* //   TransactionType: "CredentialAccept",
-* //   Issuer: "rIssuerAddress123...",
-* //   Account: "rAccountAddress456...",
-* //   CredentialType: "4B5943" // Hex encoded "KYC"
-* // }
-* ```
-*/
-declare function OriginalCredentialAcceptPayload(issuerAddress: string, accountAddress: string, credentialType: string): CredentialAcceptPayload;
+ * Creates a credential acceptance payload for XRPL transactions
+ *
+ * This function constructs a properly formatted payload for credential acceptance
+ * transactions. The credential type is automatically encoded from UTF-8 to hex
+ * format as required by XRPL specifications.
+ *
+ * @param issuerAddress - The XRPL address of the credential issuer
+ * @param accountAddress - The XRPL address of the account accepting the credential
+ * @param credentialType - The human-readable idOS credential type (e.g., "KYC")
+ * @returns A properly formatted CredentialAcceptPayload object
+ *
+ * @example
+ * ```typescript
+ * const payload = OriginalCredentialAcceptPayload(
+ *   "rIssuerAddress123...",
+ *   "rAccountAddress456...",
+ *   "KYC"
+ * );
+ * // Result: {
+ * //   TransactionType: "CredentialAccept",
+ * //   Issuer: "rIssuerAddress123...",
+ * //   Account: "rAccountAddress456...",
+ * //   CredentialType: "4B5943" // Hex encoded "KYC"
+ * // }
+ * ```
+ */
+export declare function OriginalCredentialAcceptPayload(issuerAddress: string, accountAddress: string, credentialType: string): CredentialAcceptPayload;
 /**
-* Creates a copy credential acceptance payload for XRPL transactions
-*
-* This function constructs a payload for accepting a copy of an existing credential
-* with additional metadata including the original issuer and a timelock period.
-* The CredentialType field is encoded as a composite string containing:
-* - "AG-" prefix (indicating copy credential)
-* - Original credential type
-* - Original issuer address
-* - Timelock period in years
-*
-* @param copyCredentialIssuerAddress - The XRPL address of the issuer created a XRPL Credential object related to idOS credential copy
-* @param accountAddress - The XRPL address of the account accepting the credential copy
-* @param originalCredentialIssuerAddress - The XRPL address of the issuer created a XRPL Credential object related to idOS original credential
-* @param credentialType - The human-readable idOScredential type (e.g., "KYC")
-* @param timelockYears - The number of years for the timelock period (must be non-negative integer)
-* @returns A properly formatted CredentialAcceptPayload object for copy credentials
-* @throws {Error} When timelockYears is not a non-negative integer
-*
-* @example
-* ```typescript
-* const payload = await CopyCredentialAcceptPayload(
-*   "rCopyIssuerAddress123...",
-*   "rAccountAddress456...",
-*   "rOriginalIssuerAddress789...",
-*   "KYC",
-*   2
-* );
-* // Result: {
-* //   TransactionType: "CredentialAccept",
-* //   Issuer: "rCopyIssuerAddress123...",
-* //   Account: "rAccountAddress456...",
-* //   CredentialType: "41472D4B59432D..." // Hex encoded "AG-KYC-{originalIssuer}-2Y"
-* // }
-* ```
-*/
-declare function CopyCredentialAcceptPayload(copyCredentialIssuerAddress: string, accountAddress: string, originalCredentialIssuerAddress: string, credentialType: string, timelockYears: number): Promise<CredentialAcceptPayload>;
+ * Creates a copy credential acceptance payload for XRPL transactions
+ *
+ * This function constructs a payload for accepting a copy of an existing credential
+ * with additional metadata including the original issuer and a timelock period.
+ * The CredentialType field is encoded as a composite string containing:
+ * - "AG-" prefix (indicating copy credential)
+ * - Original credential type
+ * - Original issuer address
+ * - Timelock period in years
+ *
+ * @param copyCredentialIssuerAddress - The XRPL address of the issuer created a XRPL Credential object related to idOS credential copy
+ * @param accountAddress - The XRPL address of the account accepting the credential copy
+ * @param originalCredentialIssuerAddress - The XRPL address of the issuer created a XRPL Credential object related to idOS original credential
+ * @param credentialType - The human-readable idOScredential type (e.g., "KYC")
+ * @param timelockYears - The number of years for the timelock period (must be non-negative integer)
+ * @returns A properly formatted CredentialAcceptPayload object for copy credentials
+ * @throws {Error} When timelockYears is not a non-negative integer
+ *
+ * @example
+ * ```typescript
+ * const payload = await CopyCredentialAcceptPayload(
+ *   "rCopyIssuerAddress123...",
+ *   "rAccountAddress456...",
+ *   "rOriginalIssuerAddress789...",
+ *   "KYC",
+ *   2
+ * );
+ * // Result: {
+ * //   TransactionType: "CredentialAccept",
+ * //   Issuer: "rCopyIssuerAddress123...",
+ * //   Account: "rAccountAddress456...",
+ * //   CredentialType: "41472D4B59432D..." // Hex encoded "AG-KYC-{originalIssuer}-2Y"
+ * // }
+ * ```
+ */
+export declare function CopyCredentialAcceptPayload(copyCredentialIssuerAddress: string, accountAddress: string, originalCredentialIssuerAddress: string, credentialType: string, timelockYears: number): Promise<CredentialAcceptPayload>;
 //#endregion
 //#region src/xrpl-credentials/create.d.ts
 /**
-* Parameters for creating an original credential on XRPL
-*/
-type CreateCredentialForOriginalParams = {
-  /** Unique identifier for the idOS credential, like `741a9caf-ec53-42c7-aed6-519950dcded5` */credId: string; /** Type/category of the credential, like `KYC` */
-  credType: string; /** XRPL address of the user receiving the credential, like `rPT1Sjq2YGrBMTttX4GZHjKu9dyf6bpAYe` */
+ * Parameters for creating an original credential on XRPL
+ */
+export type CreateCredentialForOriginalParams = {
+  /** Unique identifier for the idOS credential, like `741a9caf-ec53-42c7-aed6-519950dcded5` */
+  credId: string;
+  /** Type/category of the credential, like `KYC` */
+  credType: string;
+  /** XRPL address of the user receiving the credential, like `rPT1Sjq2YGrBMTttX4GZHjKu9dyf6bpAYe` */
   userAddress: string;
 };
 /**
-* Parameters for creating a time-locked copy credential on XRPL
-*/
-type CreateCredentialForCopyParams = {
-  /** Unique identifier for the idOS credential */credId: string; /** Type/category of the credential */
-  credType: string; /** XRPL address of the user receiving the credential */
-  userAddress: string; /** Number of years to lock the credential (must be non-negative integer) */
-  timelockYears: number; /** XRPL address of the original credential issuer */
+ * Parameters for creating a time-locked copy credential on XRPL
+ */
+export type CreateCredentialForCopyParams = {
+  /** Unique identifier for the idOS credential */
+  credId: string;
+  /** Type/category of the credential */
+  credType: string;
+  /** XRPL address of the user receiving the credential */
+  userAddress: string;
+  /** Number of years to lock the credential (must be non-negative integer) */
+  timelockYears: number;
+  /** XRPL address of the original credential issuer */
   origCredIssuerAddress: string;
 };
 /**
-* Service class for creating credentials on the XRPL blockchain
-*
-* This service provides methods to create both original and copy credentials
-* on the XRPL. It handles connection management, transaction submission,
-* and proper encoding of credential data according to XRPL specifications.
-*
-* @example
-* ```typescript
-* const wallet = Wallet.fromSeed("s...");
-* const xrplService = await XrplCredentialsCreate.init("wss://s.devnet.rippletest.net:51233", wallet);
-*
-* // Create original credential
-* await xrplService.createCredentialForOriginal({
-*   credId: "741a9caf-ec53-42c7-aed6-519950dcded5",
-*   credType: "KYC",
-*   userAddress: "rPT1Sjq2YGrBMTttX4GZHjKu9dyf6bpAYe"
-* });
-* ```
-*/
-declare class XrplCredentialsCreate {
+ * Service class for creating credentials on the XRPL blockchain
+ *
+ * This service provides methods to create both original and copy credentials
+ * on the XRPL. It handles connection management, transaction submission,
+ * and proper encoding of credential data according to XRPL specifications.
+ *
+ * @example
+ * ```typescript
+ * const wallet = Wallet.fromSeed("s...");
+ * const xrplService = await XrplCredentialsCreate.init("wss://s.devnet.rippletest.net:51233", wallet);
+ *
+ * // Create original credential
+ * await xrplService.createCredentialForOriginal({
+ *   credId: "741a9caf-ec53-42c7-aed6-519950dcded5",
+ *   credType: "KYC",
+ *   userAddress: "rPT1Sjq2YGrBMTttX4GZHjKu9dyf6bpAYe"
+ * });
+ * ```
+ */
+export declare class XrplCredentialsCreate {
   #private;
-  constructor(nodeUrl: string, wallet: Wallet, xrpl: typeof _$xrpl);
+  constructor(nodeUrl: string, wallet: Wallet, xrpl: typeof import("xrpl"));
   /**
-  * Creates a new XRPL credentials service instance.
-  *
-  * @param nodeUrl - The WebSocket URL of the XRPL node to connect to
-  * @param wallet  - The XRPL wallet to use for signing transactions
-  */
+   * Creates a new XRPL credentials service instance.
+   *
+   * @param nodeUrl - The WebSocket URL of the XRPL node to connect to
+   * @param wallet  - The XRPL wallet to use for signing transactions
+   */
   static init(nodeUrl: string, wallet: Wallet): Promise<XrplCredentialsCreate>;
   /**
-  * Creates a credential on the XRPL that reflects an idOS original credential.
-  *
-  * This method creates a new credential with the specified type and assigns it to the given user.
-  * The credential type is encoded as a hex string, and the credential ID is encoded as a hex URI.
-  *
-  * @param params - Parameters for creating the original credential
-  * @returns Promise resolving to the XRPL transaction result
-  *
-  * @example
-  * ```typescript
-  * await xrplService.createCredentialForOriginal({
-  *   credId: "741a9caf-ec53-42c7-aed6-519950dcded5",
-  *   credType: "KYC",
-  *   userAddress: "rPT1Sjq2YGrBMTttX4GZHjKu9dyf6bpAYe"
-  * });
-  * ```
-  */
+   * Creates a credential on the XRPL that reflects an idOS original credential.
+   *
+   * This method creates a new credential with the specified type and assigns it to the given user.
+   * The credential type is encoded as a hex string, and the credential ID is encoded as a hex URI.
+   *
+   * @param params - Parameters for creating the original credential
+   * @returns Promise resolving to the XRPL transaction result
+   *
+   * @example
+   * ```typescript
+   * await xrplService.createCredentialForOriginal({
+   *   credId: "741a9caf-ec53-42c7-aed6-519950dcded5",
+   *   credType: "KYC",
+   *   userAddress: "rPT1Sjq2YGrBMTttX4GZHjKu9dyf6bpAYe"
+   * });
+   * ```
+   */
   createCredentialForOriginal(params: CreateCredentialForOriginalParams): Promise<TxResponse>;
   /**
-  * Creates a time-locked credential copy on the XRPL.
-  *
-  * This method creates a Credential object in XRPL that reflects an idOS credential copy.
-  * The credential type includes metadata about the original issuer and time-lock duration.
-  * The composite credential type follows the format: "AG-{type}-{originalIssuer}-{timelock}Y"
-  *
-  * @param params - Parameters for creating the time-locked credential copy
-  * @returns Promise resolving to the XRPL transaction result
-  *
-  * @throws {Error} When timelockYears is not a non-negative integer
-  *
-  * @example
-  * ```typescript
-  * const result = await xrplService.createCredentialForCopy({
-  *   credId: "741a9caf-ec53-42c7-aed6-519950dcded5",
-  *   credType: "KYC",
-  *   userAddress: "rPT1Sjq2YGrBMTttX4GZHjKu9dyf6bpAYe",
-  *   timelockYears: 5,
-  *   origCredIssuerAddress: "rU9C67bZ3ZvjXaJYwYqMqjMq1o4ZbwK3YN"
-  * });
-  * ```
-  */
+   * Creates a time-locked credential copy on the XRPL.
+   *
+   * This method creates a Credential object in XRPL that reflects an idOS credential copy.
+   * The credential type includes metadata about the original issuer and time-lock duration.
+   * The composite credential type follows the format: "AG-{type}-{originalIssuer}-{timelock}Y"
+   *
+   * @param params - Parameters for creating the time-locked credential copy
+   * @returns Promise resolving to the XRPL transaction result
+   *
+   * @throws {Error} When timelockYears is not a non-negative integer
+   *
+   * @example
+   * ```typescript
+   * const result = await xrplService.createCredentialForCopy({
+   *   credId: "741a9caf-ec53-42c7-aed6-519950dcded5",
+   *   credType: "KYC",
+   *   userAddress: "rPT1Sjq2YGrBMTttX4GZHjKu9dyf6bpAYe",
+   *   timelockYears: 5,
+   *   origCredIssuerAddress: "rU9C67bZ3ZvjXaJYwYqMqjMq1o4ZbwK3YN"
+   * });
+   * ```
+   */
   createCredentialForCopy(params: CreateCredentialForCopyParams): Promise<TxResponse>;
 }
 //#endregion
-export { CopyCredentialAcceptPayload, CreateCredentialForCopyParams, CreateCredentialForOriginalParams, CredentialAcceptPayload, OriginalCredentialAcceptPayload, XrplCredentialsCreate };
 //# sourceMappingURL=index.d.mts.map

package/dist/xrpl-credentials/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/xrpl-credentials/accept.ts","../../src/xrpl-credentials/create.ts"],"mappings":";;;;;;;;AASA;;;KAAY,uBAAA;iEAEV,eAAA;EAEA,MAAA;EAEA,OAAA,UAgCF;EA9BE,cAAA;AAAA;;;;;;;;AAmFF;;;;;;;;;;;;;;;;AC7FA;;;;iBDwCgB,+BAAA,CACd,aAAA,UACA,cAAA,UACA,cAAA,WACC,uBAAA;;;;;AChCH;;;;;;;;;;;AAiCA;;;;;;;;;;;;;;;;;;;;;iBDgDsB,2BAAA,CACpB,2BAAA,UACA,cAAA,UACA,+BAAA,UACA,cAAA,UACA,aAAA,WACC,OAAA,CAAQ,uBAAA;;;;;;KCnGC,iCAAA;EDEA,6FCAV,MAAA,UDAU;ECEV,QAAA;EAEA,WAAA;AAAA;;;ADkCF;KC5BY,6BAAA;kDAEV,MAAA;EAEA,QAAA;EAEA,WAAA;EAEA,aAAA,UDyEF;ECvEE,qBAAA;AAAA;;;;;;;;;;;;;;AAtBF;;;;;;;cA6Ca,qBAAA;EAAA;EAKX,WAAA,CAAY,OAAA,UAAiB,MAAA,EAAQ,MAAA,EAAQ,IAAA,SAAR,MAAA;EAtC3B;;;;;;EAAA,OAkDG,IAAA,CAAK,OAAA,UAAiB,MAAA,EAAQ,MAAA,GAAS,OAAA,CAAQ,qBAAA;;;;AAjB9D;;;;;;;;;;;;;;;EAiDE,2BAAA,CACE,MAAA,EAAQ,iCAAA,GACP,OAAA,CAAQ,UAAA;;;;;;;;;;;;;;;;;;;;;;;;EAmDX,uBAAA,CAA8B,MAAA,EAAQ,6BAAA,GAAgC,OAAA,CAAQ,UAAA;AAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/xrpl-credentials/accept.ts","../../src/xrpl-credentials/create.ts"],"mappings":";;;;;;;;;YASY;;EAEV;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8Bc,gCACd,uBACA,wBACA,yBACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAiDmB,4BACpB,qCACA,wBACA,yCACA,wBACA,wBACC,QAAQ;;;;;;YCnGC;;EAEV;;EAEA;;EAEA;;;;;YAMU;;EAEV;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;;;;;;;;qBAuBW;;EAKX,YAAY,iBAAiB,QAAQ,QAAQ;;;;;;;SAYhC,KAAK,iBAAiB,QAAQ,SAAS,QAAQ;;;;;;;;;;;;;;;;;;;EAgC5D,4BACE,QAAQ,oCACP,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;EAmDX,wBAA8B,QAAQ,gCAAgC,QAAQ"}

package/dist/xrpl-credentials/index.mjs

@@ -1,224 +1,2 @@
-import { hexEncode, utf8Encode } from "@idos-network/utils/codecs";
-//#region src/xrpl-credentials/accept.ts
-/**
-* Creates a credential acceptance payload for XRPL transactions
-*
-* This function constructs a properly formatted payload for credential acceptance
-* transactions. The credential type is automatically encoded from UTF-8 to hex
-* format as required by XRPL specifications.
-*
-* @param issuerAddress - The XRPL address of the credential issuer
-* @param accountAddress - The XRPL address of the account accepting the credential
-* @param credentialType - The human-readable idOS credential type (e.g., "KYC")
-* @returns A properly formatted CredentialAcceptPayload object
-*
-* @example
-* ```typescript
-* const payload = OriginalCredentialAcceptPayload(
-*   "rIssuerAddress123...",
-*   "rAccountAddress456...",
-*   "KYC"
-* );
-* // Result: {
-* //   TransactionType: "CredentialAccept",
-* //   Issuer: "rIssuerAddress123...",
-* //   Account: "rAccountAddress456...",
-* //   CredentialType: "4B5943" // Hex encoded "KYC"
-* // }
-* ```
-*/
-function OriginalCredentialAcceptPayload(issuerAddress, accountAddress, credentialType) {
-	return {
-		TransactionType: "CredentialAccept",
-		Issuer: issuerAddress,
-		Account: accountAddress,
-		CredentialType: hexEncode(utf8Encode(credentialType))
-	};
-}
-/**
-* Creates a copy credential acceptance payload for XRPL transactions
-*
-* This function constructs a payload for accepting a copy of an existing credential
-* with additional metadata including the original issuer and a timelock period.
-* The CredentialType field is encoded as a composite string containing:
-* - "AG-" prefix (indicating copy credential)
-* - Original credential type
-* - Original issuer address
-* - Timelock period in years
-*
-* @param copyCredentialIssuerAddress - The XRPL address of the issuer created a XRPL Credential object related to idOS credential copy
-* @param accountAddress - The XRPL address of the account accepting the credential copy
-* @param originalCredentialIssuerAddress - The XRPL address of the issuer created a XRPL Credential object related to idOS original credential
-* @param credentialType - The human-readable idOScredential type (e.g., "KYC")
-* @param timelockYears - The number of years for the timelock period (must be non-negative integer)
-* @returns A properly formatted CredentialAcceptPayload object for copy credentials
-* @throws {Error} When timelockYears is not a non-negative integer
-*
-* @example
-* ```typescript
-* const payload = await CopyCredentialAcceptPayload(
-*   "rCopyIssuerAddress123...",
-*   "rAccountAddress456...",
-*   "rOriginalIssuerAddress789...",
-*   "KYC",
-*   2
-* );
-* // Result: {
-* //   TransactionType: "CredentialAccept",
-* //   Issuer: "rCopyIssuerAddress123...",
-* //   Account: "rAccountAddress456...",
-* //   CredentialType: "41472D4B59432D..." // Hex encoded "AG-KYC-{originalIssuer}-2Y"
-* // }
-* ```
-*/
-async function CopyCredentialAcceptPayload(copyCredentialIssuerAddress, accountAddress, originalCredentialIssuerAddress, credentialType, timelockYears) {
-	if (!Number.isInteger(timelockYears) || timelockYears < 0) throw new Error("timelockYears must be a non-negative integer");
-	let decodeAccountID;
-	try {
-		({decodeAccountID} = await import("xrpl"));
-	} catch {
-		throw new Error("Missing optional peer dependency \"xrpl\". Install it to use CopyCredentialAcceptPayload.");
-	}
-	return {
-		TransactionType: "CredentialAccept",
-		Issuer: copyCredentialIssuerAddress,
-		Account: accountAddress,
-		CredentialType: hexEncode(Buffer.concat([
-			utf8Encode("AG"),
-			utf8Encode("-"),
-			utf8Encode(credentialType),
-			utf8Encode("-"),
-			decodeAccountID(originalCredentialIssuerAddress),
-			utf8Encode("-"),
-			utf8Encode(`${timelockYears}Y`)
-		]))
-	};
-}
-//#endregion
-//#region src/xrpl-credentials/create.ts
-/**
-* Service class for creating credentials on the XRPL blockchain
-*
-* This service provides methods to create both original and copy credentials
-* on the XRPL. It handles connection management, transaction submission,
-* and proper encoding of credential data according to XRPL specifications.
-*
-* @example
-* ```typescript
-* const wallet = Wallet.fromSeed("s...");
-* const xrplService = await XrplCredentialsCreate.init("wss://s.devnet.rippletest.net:51233", wallet);
-*
-* // Create original credential
-* await xrplService.createCredentialForOriginal({
-*   credId: "741a9caf-ec53-42c7-aed6-519950dcded5",
-*   credType: "KYC",
-*   userAddress: "rPT1Sjq2YGrBMTttX4GZHjKu9dyf6bpAYe"
-* });
-* ```
-*/
-var XrplCredentialsCreate = class XrplCredentialsCreate {
-	#client;
-	#wallet;
-	#xrpl;
-	constructor(nodeUrl, wallet, xrpl) {
-		this.#xrpl = xrpl;
-		this.#wallet = wallet;
-		this.#client = new this.#xrpl.Client(nodeUrl);
-	}
-	/**
-	* Creates a new XRPL credentials service instance.
-	*
-	* @param nodeUrl - The WebSocket URL of the XRPL node to connect to
-	* @param wallet  - The XRPL wallet to use for signing transactions
-	*/
-	static async init(nodeUrl, wallet) {
-		let xrpl;
-		try {
-			xrpl = await import("xrpl");
-		} catch {
-			throw new Error("Missing optional peer dependency 'xrpl'. Install it to use XrplCredentialsCreate.");
-		}
-		return new XrplCredentialsCreate(nodeUrl, wallet, xrpl);
-	}
-	/**
-	* Creates a credential on the XRPL that reflects an idOS original credential.
-	*
-	* This method creates a new credential with the specified type and assigns it to the given user.
-	* The credential type is encoded as a hex string, and the credential ID is encoded as a hex URI.
-	*
-	* @param params - Parameters for creating the original credential
-	* @returns Promise resolving to the XRPL transaction result
-	*
-	* @example
-	* ```typescript
-	* await xrplService.createCredentialForOriginal({
-	*   credId: "741a9caf-ec53-42c7-aed6-519950dcded5",
-	*   credType: "KYC",
-	*   userAddress: "rPT1Sjq2YGrBMTttX4GZHjKu9dyf6bpAYe"
-	* });
-	* ```
-	*/
-	async createCredentialForOriginal(params) {
-		const { credId, credType, userAddress } = params;
-		await this.#client.connect();
-		const res = await this.#client.submitAndWait({
-			TransactionType: "CredentialCreate",
-			Account: this.#wallet.address,
-			Subject: userAddress,
-			CredentialType: hexEncode(utf8Encode(credType)),
-			URI: hexEncode(utf8Encode(credId))
-		}, { wallet: this.#wallet });
-		await this.#client.disconnect();
-		return res;
-	}
-	/**
-	* Creates a time-locked credential copy on the XRPL.
-	*
-	* This method creates a Credential object in XRPL that reflects an idOS credential copy.
-	* The credential type includes metadata about the original issuer and time-lock duration.
-	* The composite credential type follows the format: "AG-{type}-{originalIssuer}-{timelock}Y"
-	*
-	* @param params - Parameters for creating the time-locked credential copy
-	* @returns Promise resolving to the XRPL transaction result
-	*
-	* @throws {Error} When timelockYears is not a non-negative integer
-	*
-	* @example
-	* ```typescript
-	* const result = await xrplService.createCredentialForCopy({
-	*   credId: "741a9caf-ec53-42c7-aed6-519950dcded5",
-	*   credType: "KYC",
-	*   userAddress: "rPT1Sjq2YGrBMTttX4GZHjKu9dyf6bpAYe",
-	*   timelockYears: 5,
-	*   origCredIssuerAddress: "rU9C67bZ3ZvjXaJYwYqMqjMq1o4ZbwK3YN"
-	* });
-	* ```
-	*/
-	async createCredentialForCopy(params) {
-		const { credId, credType, userAddress, timelockYears, origCredIssuerAddress } = params;
-		if (!Number.isInteger(timelockYears) || timelockYears < 0) throw new Error("timelockYears must be a non-negative integer");
-		await this.#client.connect();
-		const type = Buffer.concat([
-			utf8Encode("AG"),
-			utf8Encode("-"),
-			utf8Encode(credType),
-			utf8Encode("-"),
-			this.#xrpl.decodeAccountID(origCredIssuerAddress),
-			utf8Encode("-"),
-			utf8Encode(`${timelockYears}Y`)
-		]);
-		const res = await this.#client.submitAndWait({
-			TransactionType: "CredentialCreate",
-			Account: this.#wallet.address,
-			Subject: userAddress,
-			CredentialType: hexEncode(type),
-			URI: hexEncode(utf8Encode(credId))
-		}, { wallet: this.#wallet });
-		await this.#client.disconnect();
-		return res;
-	}
-};
-//#endregion
-export { CopyCredentialAcceptPayload, OriginalCredentialAcceptPayload, XrplCredentialsCreate };
-
+import{hexEncode as e,utf8Encode as t}from"@idos-network/utils/codecs";function n(n,r,i){return{TransactionType:`CredentialAccept`,Issuer:n,Account:r,CredentialType:e(t(i))}}async function r(n,r,i,a,o){if(!Number.isInteger(o)||o<0)throw Error(`timelockYears must be a non-negative integer`);let s;try{({decodeAccountID:s}=await import(`xrpl`))}catch{throw Error(`Missing optional peer dependency "xrpl". Install it to use CopyCredentialAcceptPayload.`)}let c=Buffer.concat([t(`AG`),t(`-`),t(a),t(`-`),s(i),t(`-`),t(`${o}Y`)]);return{TransactionType:`CredentialAccept`,Issuer:n,Account:r,CredentialType:e(c)}}var i=class n{#e;#t;#n;constructor(e,t,n){this.#n=n,this.#t=t,this.#e=new this.#n.Client(e)}static async init(e,t){let r;try{r=await import(`xrpl`)}catch{throw Error(`Missing optional peer dependency 'xrpl'. Install it to use XrplCredentialsCreate.`)}return new n(e,t,r)}async createCredentialForOriginal(n){let{credId:r,credType:i,userAddress:a}=n;await this.#e.connect();let o=await this.#e.submitAndWait({TransactionType:`CredentialCreate`,Account:this.#t.address,Subject:a,CredentialType:e(t(i)),URI:e(t(r))},{wallet:this.#t});return await this.#e.disconnect(),o}async createCredentialForCopy(n){let{credId:r,credType:i,userAddress:a,timelockYears:o,origCredIssuerAddress:s}=n;if(!Number.isInteger(o)||o<0)throw Error(`timelockYears must be a non-negative integer`);await this.#e.connect();let c=Buffer.concat([t(`AG`),t(`-`),t(i),t(`-`),this.#n.decodeAccountID(s),t(`-`),t(`${o}Y`)]),l=await this.#e.submitAndWait({TransactionType:`CredentialCreate`,Account:this.#t.address,Subject:a,CredentialType:e(c),URI:e(t(r))},{wallet:this.#t});return await this.#e.disconnect(),l}};export{r as CopyCredentialAcceptPayload,n as OriginalCredentialAcceptPayload,i as XrplCredentialsCreate};
 //# sourceMappingURL=index.mjs.map