@dstoken-solana/rwa-rbac 0.4.1 → 0.4.3

package/dist/index.js

@@ -1,6 +1,5054 @@
-export * from "./pdas";
-export * from "./types";
-export * from "./client";
-export * from "./constants";
-export * from "./utils";
-//# sourceMappingURL=index.js.map
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var web3_js = require('@solana/web3.js');
+var anchor = require('@coral-xyz/anchor');
+var splToken = require('@solana/spl-token');
+var rwaTokenSdk = require('@dstoken-solana/rwa-token-sdk');
+
+const IMR_PROGRAM = new web3_js.PublicKey("D2V7wTBbNCKgYwirgRUnSmc2QyKnHSVmRotWJ4rz8Jp9");
+const RBAC_PROGRAM = new web3_js.PublicKey("3g6fUgMsJQhjPUYxNjEU5PyzGf8DerbDx8p5Qh4yMnRR");
+const TL_PROGRAM = new web3_js.PublicKey("9bNt3ZiZpDdHqAt5Q1Wq6twFe5RKmMCwA7MJyK2HgGnU");
+
+const deriveInvestorLocks = (investorId, identityRegistry, programId = TL_PROGRAM) => {
+    return web3_js.PublicKey.findProgramAddressSync([
+        Buffer.from(investorId),
+        identityRegistry.toBuffer(),
+        Buffer.from("InvestorLocks"),
+    ], programId)[0];
+};
+const deriveLockedTokenAccount = (investorId, identityRegistry, programId = TL_PROGRAM) => {
+    return web3_js.PublicKey.findProgramAddressSync([
+        Buffer.from(investorId),
+        identityRegistry.toBuffer(),
+        Buffer.from("LockedTokenAccount"),
+    ], programId)[0];
+};
+const deriveInvestorPda = (investorId, identityRegistry, programId = IMR_PROGRAM) => {
+    return web3_js.PublicKey.findProgramAddressSync([
+        Buffer.from(investorId),
+        identityRegistry.toBuffer(),
+        Buffer.from("Investor"),
+    ], programId)[0];
+};
+const deriveAssetAccessControllerPda = (uniqueSeed, programId = RBAC_PROGRAM) => {
+    return web3_js.PublicKey.findProgramAddressSync([uniqueSeed.toBuffer(), Buffer.from("AssetAccessController")], programId)[0];
+};
+const deriveControllerAuthorityPda = (assetAccessController, programId = RBAC_PROGRAM) => {
+    return web3_js.PublicKey.findProgramAddressSync([assetAccessController.toBuffer()], programId)[0];
+};
+const deriveUserRolePda = (id, assetAccessController, programId = RBAC_PROGRAM) => {
+    return web3_js.PublicKey.findProgramAddressSync([
+        id.toArrayLike(Buffer, "le", 8),
+        assetAccessController.toBuffer(),
+        Buffer.from("UserRole"),
+    ], programId)[0];
+};
+const getEventAuthority = (programId) => web3_js.PublicKey.findProgramAddressSync([Buffer.from("__event_authority")], programId)[0];
+
+var address$1 = "3g6fUgMsJQhjPUYxNjEU5PyzGf8DerbDx8p5Qh4yMnRR";
+var metadata$1 = {
+	name: "rwa_rbac",
+	version: "0.1.0",
+	spec: "0.1.0",
+	description: "Created with Anchor"
+};
+var instructions$1 = [
+	{
+		name: "add_levels",
+		discriminator: [
+			101,
+			239,
+			15,
+			85,
+			60,
+			13,
+			183,
+			192
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role"
+			},
+			{
+				name: "identity_metadata_registry_program",
+				address: "D2V7wTBbNCKgYwirgRUnSmc2QyKnHSVmRotWJ4rz8Jp9"
+			},
+			{
+				name: "investor",
+				writable: true
+			},
+			{
+				name: "identity_registry_program",
+				address: "GZsnjqT3c5zbHqsctrJ4EG4rbEfo7ZXyyUG7aDJNmxfA"
+			},
+			{
+				name: "identity_registry"
+			},
+			{
+				name: "identity_account",
+				writable: true
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			},
+			{
+				name: "policy_engine_program"
+			},
+			{
+				name: "policy_engine",
+				writable: true
+			},
+			{
+				name: "tracker_account"
+			},
+			{
+				name: "asset_mint"
+			},
+			{
+				name: "event_authority_identity_metadata_registry"
+			},
+			{
+				name: "event_authority_identity_registry"
+			}
+		],
+		args: [
+			{
+				name: "cpi_data",
+				type: "bytes"
+			}
+		]
+	},
+	{
+		name: "add_lock",
+		discriminator: [
+			242,
+			102,
+			183,
+			107,
+			109,
+			168,
+			82,
+			140
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role"
+			},
+			{
+				name: "policy_engine_program",
+				address: "FsE8mCJyvgMzqJbfHbJQm3iuf3cRZC6n2vZi1Q8rQCy2"
+			},
+			{
+				name: "policy_engine",
+				writable: true
+			},
+			{
+				name: "asset_mint"
+			},
+			{
+				name: "identity_registry"
+			},
+			{
+				name: "identity_account"
+			},
+			{
+				name: "tracker_account",
+				writable: true
+			},
+			{
+				name: "event_authority"
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			}
+		],
+		args: [
+			{
+				name: "cpi_data",
+				type: "bytes"
+			}
+		]
+	},
+	{
+		name: "assign_user_role",
+		discriminator: [
+			39,
+			8,
+			31,
+			232,
+			255,
+			118,
+			39,
+			44
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "asset_access_controller",
+				writable: true,
+				relations: [
+					"user_role",
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "user_role",
+				writable: true
+			},
+			{
+				name: "authorized_user_role",
+				optional: true
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			},
+			{
+				name: "event_authority",
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								95,
+								95,
+								101,
+								118,
+								101,
+								110,
+								116,
+								95,
+								97,
+								117,
+								116,
+								104,
+								111,
+								114,
+								105,
+								116,
+								121
+							]
+						}
+					]
+				}
+			},
+			{
+				name: "program"
+			}
+		],
+		args: [
+			{
+				name: "users_to_assign",
+				type: {
+					vec: "pubkey"
+				}
+			}
+		]
+	},
+	{
+		name: "attach_to_policy_engine",
+		discriminator: [
+			99,
+			59,
+			117,
+			21,
+			146,
+			11,
+			54,
+			173
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role"
+			},
+			{
+				name: "policy_engine_program",
+				address: "FsE8mCJyvgMzqJbfHbJQm3iuf3cRZC6n2vZi1Q8rQCy2"
+			},
+			{
+				name: "policy_engine",
+				writable: true
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			},
+			{
+				name: "event_authority"
+			}
+		],
+		args: [
+			{
+				name: "cpi_data",
+				type: "bytes"
+			}
+		]
+	},
+	{
+		name: "attach_wallet_to_identity",
+		discriminator: [
+			61,
+			129,
+			252,
+			190,
+			8,
+			202,
+			179,
+			90
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role"
+			},
+			{
+				name: "identity_registry_program",
+				address: "GZsnjqT3c5zbHqsctrJ4EG4rbEfo7ZXyyUG7aDJNmxfA"
+			},
+			{
+				name: "wallet_identity",
+				writable: true
+			},
+			{
+				name: "identity_account",
+				writable: true
+			},
+			{
+				name: "identity_registry"
+			},
+			{
+				name: "asset_mint"
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			},
+			{
+				name: "event_authority"
+			}
+		],
+		args: [
+			{
+				name: "cpi_data",
+				type: "bytes"
+			}
+		]
+	},
+	{
+		name: "change_counter_limits",
+		discriminator: [
+			200,
+			2,
+			8,
+			102,
+			43,
+			168,
+			141,
+			139
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role"
+			},
+			{
+				name: "policy_engine_program",
+				address: "FsE8mCJyvgMzqJbfHbJQm3iuf3cRZC6n2vZi1Q8rQCy2"
+			},
+			{
+				name: "policy_engine",
+				writable: true
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			},
+			{
+				name: "event_authority"
+			}
+		],
+		args: [
+			{
+				name: "cpi_data",
+				type: "bytes"
+			}
+		]
+	},
+	{
+		name: "change_counters",
+		discriminator: [
+			156,
+			107,
+			88,
+			204,
+			113,
+			131,
+			241,
+			192
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role"
+			},
+			{
+				name: "policy_engine_program",
+				address: "FsE8mCJyvgMzqJbfHbJQm3iuf3cRZC6n2vZi1Q8rQCy2"
+			},
+			{
+				name: "policy_engine",
+				writable: true
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			},
+			{
+				name: "event_authority"
+			}
+		],
+		args: [
+			{
+				name: "cpi_data",
+				type: "bytes"
+			}
+		]
+	},
+	{
+		name: "change_country",
+		discriminator: [
+			208,
+			227,
+			224,
+			246,
+			9,
+			254,
+			62,
+			179
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role"
+			},
+			{
+				name: "identity_metadata_registry_program",
+				address: "D2V7wTBbNCKgYwirgRUnSmc2QyKnHSVmRotWJ4rz8Jp9"
+			},
+			{
+				name: "investor",
+				writable: true
+			},
+			{
+				name: "identity_registry_program",
+				address: "GZsnjqT3c5zbHqsctrJ4EG4rbEfo7ZXyyUG7aDJNmxfA"
+			},
+			{
+				name: "identity_registry"
+			},
+			{
+				name: "identity_account",
+				writable: true
+			},
+			{
+				name: "policy_engine_program"
+			},
+			{
+				name: "policy_engine",
+				writable: true
+			},
+			{
+				name: "tracker_account"
+			},
+			{
+				name: "asset_mint"
+			},
+			{
+				name: "event_authority_identity_registry"
+			}
+		],
+		args: [
+			{
+				name: "cpi_data",
+				type: "bytes"
+			}
+		]
+	},
+	{
+		name: "change_issuance_policies",
+		discriminator: [
+			186,
+			201,
+			163,
+			157,
+			32,
+			250,
+			166,
+			37
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role"
+			},
+			{
+				name: "policy_engine_program",
+				address: "FsE8mCJyvgMzqJbfHbJQm3iuf3cRZC6n2vZi1Q8rQCy2"
+			},
+			{
+				name: "policy_engine",
+				writable: true
+			},
+			{
+				name: "event_authority"
+			}
+		],
+		args: [
+			{
+				name: "cpi_data",
+				type: "bytes"
+			}
+		]
+	},
+	{
+		name: "change_mapping",
+		discriminator: [
+			103,
+			1,
+			52,
+			20,
+			160,
+			194,
+			113,
+			125
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role"
+			},
+			{
+				name: "policy_engine_program",
+				address: "FsE8mCJyvgMzqJbfHbJQm3iuf3cRZC6n2vZi1Q8rQCy2"
+			},
+			{
+				name: "policy_engine",
+				writable: true
+			},
+			{
+				name: "event_authority"
+			}
+		],
+		args: [
+			{
+				name: "cpi_data",
+				type: "bytes"
+			}
+		]
+	},
+	{
+		name: "create_controller",
+		discriminator: [
+			176,
+			246,
+			168,
+			148,
+			10,
+			12,
+			2,
+			48
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "admin",
+				signer: true
+			},
+			{
+				name: "asset_access_controller",
+				writable: true,
+				pda: {
+					seeds: [
+						{
+							kind: "account",
+							path: "asset_mint"
+						},
+						{
+							kind: "const",
+							value: [
+								65,
+								115,
+								115,
+								101,
+								116,
+								65,
+								99,
+								99,
+								101,
+								115,
+								115,
+								67,
+								111,
+								110,
+								116,
+								114,
+								111,
+								108,
+								108,
+								101,
+								114
+							]
+						}
+					]
+				}
+			},
+			{
+				name: "asset_access_controller_authority",
+				pda: {
+					seeds: [
+						{
+							kind: "account",
+							path: "asset_access_controller"
+						}
+					]
+				}
+			},
+			{
+				name: "asset_controller",
+				writable: true
+			},
+			{
+				name: "asset_mint",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "extra_metas_account",
+				writable: true
+			},
+			{
+				name: "policy_engine_account",
+				writable: true
+			},
+			{
+				name: "identity_registry_account",
+				writable: true
+			},
+			{
+				name: "policy_engine_program"
+			},
+			{
+				name: "identity_registry_program"
+			},
+			{
+				name: "asset_controller_program"
+			},
+			{
+				name: "asset_controller_event_authority"
+			},
+			{
+				name: "token_program"
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			}
+		],
+		args: [
+			{
+				name: "cpi_data",
+				type: "bytes"
+			}
+		]
+	},
+	{
+		name: "create_identity_account",
+		discriminator: [
+			82,
+			240,
+			35,
+			129,
+			113,
+			134,
+			116,
+			70
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role"
+			},
+			{
+				name: "identity_registry_program",
+				address: "GZsnjqT3c5zbHqsctrJ4EG4rbEfo7ZXyyUG7aDJNmxfA"
+			},
+			{
+				name: "identity_registry"
+			},
+			{
+				name: "identity_account",
+				writable: true
+			},
+			{
+				name: "wallet_identity",
+				writable: true
+			},
+			{
+				name: "policy_engine_program"
+			},
+			{
+				name: "tracker_account",
+				writable: true
+			},
+			{
+				name: "asset_mint"
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			},
+			{
+				name: "event_authority"
+			}
+		],
+		args: [
+			{
+				name: "cpi_data",
+				type: "bytes"
+			}
+		]
+	},
+	{
+		name: "create_user_role",
+		discriminator: [
+			13,
+			20,
+			224,
+			42,
+			3,
+			120,
+			67,
+			23
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "new_user_role",
+				writable: true
+			},
+			{
+				name: "asset_access_controller",
+				writable: true,
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role",
+				optional: true
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			}
+		],
+		args: [
+			{
+				name: "name",
+				type: "string"
+			},
+			{
+				name: "allowed_admin_ixs",
+				type: "u64"
+			},
+			{
+				name: "allowed_medici_ixs",
+				type: "u64"
+			},
+			{
+				name: "is_master_role",
+				type: "bool"
+			}
+		]
+	},
+	{
+		name: "delete_user_role",
+		discriminator: [
+			177,
+			139,
+			27,
+			46,
+			113,
+			250,
+			139,
+			225
+		],
+		accounts: [
+			{
+				name: "receiver",
+				writable: true
+			},
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"user_role",
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "user_role",
+				writable: true
+			},
+			{
+				name: "authorized_user_role",
+				optional: true
+			}
+		],
+		args: [
+		]
+	},
+	{
+		name: "detach_from_policy_engine",
+		discriminator: [
+			156,
+			137,
+			67,
+			121,
+			46,
+			207,
+			45,
+			12
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role"
+			},
+			{
+				name: "policy_engine_program",
+				address: "FsE8mCJyvgMzqJbfHbJQm3iuf3cRZC6n2vZi1Q8rQCy2"
+			},
+			{
+				name: "policy_engine",
+				writable: true
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			},
+			{
+				name: "event_authority"
+			}
+		],
+		args: [
+			{
+				name: "cpi_data",
+				type: "bytes"
+			}
+		]
+	},
+	{
+		name: "detach_wallet_from_identity",
+		discriminator: [
+			166,
+			70,
+			236,
+			254,
+			166,
+			116,
+			201,
+			50
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				writable: true,
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role"
+			},
+			{
+				name: "identity_registry_program",
+				address: "GZsnjqT3c5zbHqsctrJ4EG4rbEfo7ZXyyUG7aDJNmxfA"
+			},
+			{
+				name: "wallet_identity",
+				writable: true
+			},
+			{
+				name: "identity_account",
+				writable: true
+			},
+			{
+				name: "identity_registry"
+			},
+			{
+				name: "token_account"
+			},
+			{
+				name: "asset_mint"
+			},
+			{
+				name: "event_authority"
+			}
+		],
+		args: [
+			{
+				name: "cpi_data",
+				type: "bytes"
+			}
+		]
+	},
+	{
+		name: "freeze_token_account",
+		discriminator: [
+			138,
+			168,
+			178,
+			109,
+			205,
+			224,
+			209,
+			93
+		],
+		accounts: [
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role"
+			},
+			{
+				name: "asset_controller_program",
+				address: "7tXjmbkZVY3Gmg9kDBebcNXT1yC5pyoxxXVLwdbv9tvP"
+			},
+			{
+				name: "asset_mint",
+				writable: true
+			},
+			{
+				name: "asset_controller"
+			},
+			{
+				name: "token_account",
+				writable: true
+			},
+			{
+				name: "token_program",
+				address: "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
+			}
+		],
+		args: [
+			{
+				name: "cpi_data",
+				type: "bytes"
+			}
+		]
+	},
+	{
+		name: "issue_tokens",
+		discriminator: [
+			40,
+			207,
+			145,
+			106,
+			249,
+			54,
+			23,
+			179
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				writable: true,
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role"
+			},
+			{
+				name: "asset_controller_program",
+				address: "7tXjmbkZVY3Gmg9kDBebcNXT1yC5pyoxxXVLwdbv9tvP"
+			},
+			{
+				name: "asset_mint",
+				writable: true
+			},
+			{
+				name: "asset_controller"
+			},
+			{
+				name: "to"
+			},
+			{
+				name: "token_account",
+				writable: true
+			},
+			{
+				name: "identity_registry",
+				writable: true
+			},
+			{
+				name: "identity_account"
+			},
+			{
+				name: "tracker_account",
+				writable: true
+			},
+			{
+				name: "token_program",
+				address: "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
+			},
+			{
+				name: "associated_token_program",
+				address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			},
+			{
+				name: "policy_engine_program",
+				address: "FsE8mCJyvgMzqJbfHbJQm3iuf3cRZC6n2vZi1Q8rQCy2"
+			},
+			{
+				name: "policy_engine",
+				writable: true
+			},
+			{
+				name: "wallet_identity_account"
+			},
+			{
+				name: "event_authority"
+			}
+		],
+		args: [
+			{
+				name: "cpi_data",
+				type: "bytes"
+			}
+		]
+	},
+	{
+		name: "modify_user_role",
+		discriminator: [
+			108,
+			235,
+			68,
+			252,
+			229,
+			247,
+			71,
+			185
+		],
+		accounts: [
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"user_role",
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "user_role",
+				writable: true
+			},
+			{
+				name: "authorized_user_role",
+				optional: true
+			}
+		],
+		args: [
+			{
+				name: "name",
+				type: "string"
+			},
+			{
+				name: "allowed_admin_ixs",
+				type: "u64"
+			},
+			{
+				name: "allowed_medici_ixs",
+				type: "u64"
+			}
+		]
+	},
+	{
+		name: "register_investor",
+		discriminator: [
+			95,
+			16,
+			66,
+			212,
+			152,
+			123,
+			136,
+			173
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role"
+			},
+			{
+				name: "identity_metadata_registry_program",
+				address: "D2V7wTBbNCKgYwirgRUnSmc2QyKnHSVmRotWJ4rz8Jp9"
+			},
+			{
+				name: "investor",
+				writable: true
+			},
+			{
+				name: "identity_registry_program",
+				address: "GZsnjqT3c5zbHqsctrJ4EG4rbEfo7ZXyyUG7aDJNmxfA"
+			},
+			{
+				name: "identity_registry"
+			},
+			{
+				name: "identity_account",
+				writable: true
+			},
+			{
+				name: "wallet_identity",
+				writable: true
+			},
+			{
+				name: "policy_engine_program"
+			},
+			{
+				name: "tracker_account",
+				writable: true
+			},
+			{
+				name: "asset_mint"
+			},
+			{
+				name: "event_authority_identity_metadata_registry"
+			},
+			{
+				name: "event_authority_identity_registry"
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			}
+		],
+		args: [
+			{
+				name: "cpi_data",
+				type: "bytes"
+			}
+		]
+	},
+	{
+		name: "remove_identity_account",
+		discriminator: [
+			78,
+			35,
+			174,
+			50,
+			72,
+			181,
+			12,
+			42
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role"
+			},
+			{
+				name: "identity_registry_program",
+				address: "GZsnjqT3c5zbHqsctrJ4EG4rbEfo7ZXyyUG7aDJNmxfA"
+			},
+			{
+				name: "identity_registry"
+			},
+			{
+				name: "identity_account",
+				writable: true
+			},
+			{
+				name: "wallet_identity",
+				writable: true
+			},
+			{
+				name: "event_authority"
+			},
+			{
+				name: "identity_owner"
+			},
+			{
+				name: "policy_engine_program"
+			},
+			{
+				name: "tracker_account",
+				writable: true
+			},
+			{
+				name: "asset_mint"
+			}
+		],
+		args: [
+			{
+				name: "cpi_data",
+				type: "bytes"
+			}
+		]
+	},
+	{
+		name: "remove_investor",
+		discriminator: [
+			93,
+			0,
+			162,
+			199,
+			76,
+			5,
+			180,
+			2
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role"
+			},
+			{
+				name: "identity_metadata_registry_program",
+				address: "D2V7wTBbNCKgYwirgRUnSmc2QyKnHSVmRotWJ4rz8Jp9"
+			},
+			{
+				name: "investor",
+				writable: true
+			},
+			{
+				name: "identity_registry_program",
+				address: "GZsnjqT3c5zbHqsctrJ4EG4rbEfo7ZXyyUG7aDJNmxfA"
+			},
+			{
+				name: "identity_registry"
+			},
+			{
+				name: "identity_account",
+				writable: true
+			},
+			{
+				name: "wallet_identity",
+				writable: true
+			},
+			{
+				name: "policy_engine_program",
+				address: "FsE8mCJyvgMzqJbfHbJQm3iuf3cRZC6n2vZi1Q8rQCy2"
+			},
+			{
+				name: "tracker_account",
+				writable: true
+			},
+			{
+				name: "event_authority_identity_metadata_registry"
+			},
+			{
+				name: "event_authority_identity_registry"
+			},
+			{
+				name: "asset_mint"
+			}
+		],
+		args: [
+		]
+	},
+	{
+		name: "remove_levels",
+		discriminator: [
+			200,
+			96,
+			65,
+			253,
+			97,
+			55,
+			16,
+			192
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role"
+			},
+			{
+				name: "identity_metadata_registry_program",
+				address: "D2V7wTBbNCKgYwirgRUnSmc2QyKnHSVmRotWJ4rz8Jp9"
+			},
+			{
+				name: "investor",
+				writable: true
+			},
+			{
+				name: "identity_registry_program",
+				address: "GZsnjqT3c5zbHqsctrJ4EG4rbEfo7ZXyyUG7aDJNmxfA"
+			},
+			{
+				name: "identity_registry"
+			},
+			{
+				name: "identity_account",
+				writable: true
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			},
+			{
+				name: "policy_engine_program"
+			},
+			{
+				name: "policy_engine",
+				writable: true
+			},
+			{
+				name: "tracker_account"
+			},
+			{
+				name: "asset_mint"
+			},
+			{
+				name: "event_authority_identity_registry"
+			}
+		],
+		args: [
+			{
+				name: "cpi_data",
+				type: "bytes"
+			}
+		]
+	},
+	{
+		name: "remove_lock",
+		discriminator: [
+			1,
+			17,
+			121,
+			74,
+			62,
+			241,
+			127,
+			120
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role"
+			},
+			{
+				name: "policy_engine_program",
+				address: "FsE8mCJyvgMzqJbfHbJQm3iuf3cRZC6n2vZi1Q8rQCy2"
+			},
+			{
+				name: "policy_engine",
+				writable: true
+			},
+			{
+				name: "asset_mint"
+			},
+			{
+				name: "identity_registry"
+			},
+			{
+				name: "identity_account"
+			},
+			{
+				name: "tracker_account",
+				writable: true
+			},
+			{
+				name: "event_authority"
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			}
+		],
+		args: [
+			{
+				name: "cpi_data",
+				type: "bytes"
+			}
+		]
+	},
+	{
+		name: "remove_user_role",
+		discriminator: [
+			43,
+			242,
+			133,
+			94,
+			48,
+			124,
+			214,
+			153
+		],
+		accounts: [
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"user_role",
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "user_role",
+				writable: true
+			},
+			{
+				name: "authorized_user_role",
+				optional: true
+			},
+			{
+				name: "event_authority",
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								95,
+								95,
+								101,
+								118,
+								101,
+								110,
+								116,
+								95,
+								97,
+								117,
+								116,
+								104,
+								111,
+								114,
+								105,
+								116,
+								121
+							]
+						}
+					]
+				}
+			},
+			{
+				name: "program"
+			}
+		],
+		args: [
+			{
+				name: "users_to_remove",
+				type: {
+					vec: "pubkey"
+				}
+			}
+		]
+	},
+	{
+		name: "revoke_tokens",
+		discriminator: [
+			215,
+			42,
+			15,
+			134,
+			173,
+			80,
+			33,
+			21
+		],
+		accounts: [
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				writable: true,
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role"
+			},
+			{
+				name: "asset_controller_program",
+				address: "7tXjmbkZVY3Gmg9kDBebcNXT1yC5pyoxxXVLwdbv9tvP"
+			},
+			{
+				name: "asset_mint",
+				writable: true
+			},
+			{
+				name: "asset_controller"
+			},
+			{
+				name: "revoke_token_account",
+				writable: true
+			},
+			{
+				name: "identity_registry"
+			},
+			{
+				name: "identity_account"
+			},
+			{
+				name: "tracker_account",
+				writable: true
+			},
+			{
+				name: "policy_engine_program"
+			},
+			{
+				name: "policy_engine",
+				writable: true
+			},
+			{
+				name: "wallet_identity_account"
+			},
+			{
+				name: "token_program",
+				address: "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
+			},
+			{
+				name: "associated_token_program",
+				address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			},
+			{
+				name: "event_authority"
+			}
+		],
+		args: [
+			{
+				name: "cpi_data",
+				type: "bytes"
+			}
+		]
+	},
+	{
+		name: "seize_tokens",
+		discriminator: [
+			79,
+			30,
+			69,
+			54,
+			78,
+			1,
+			16,
+			23
+		],
+		accounts: [
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				writable: true,
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role"
+			},
+			{
+				name: "asset_controller_program",
+				address: "7tXjmbkZVY3Gmg9kDBebcNXT1yC5pyoxxXVLwdbv9tvP"
+			},
+			{
+				name: "asset_mint"
+			},
+			{
+				name: "asset_controller"
+			},
+			{
+				name: "destination_token_account",
+				writable: true
+			},
+			{
+				name: "source_token_account",
+				writable: true
+			},
+			{
+				name: "token_program",
+				address: "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
+			},
+			{
+				name: "event_authority"
+			}
+		],
+		args: [
+			{
+				name: "cpi_data",
+				type: "bytes"
+			}
+		]
+	},
+	{
+		name: "set_counters",
+		discriminator: [
+			127,
+			151,
+			147,
+			141,
+			171,
+			53,
+			28,
+			135
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role"
+			},
+			{
+				name: "policy_engine_program",
+				address: "FsE8mCJyvgMzqJbfHbJQm3iuf3cRZC6n2vZi1Q8rQCy2"
+			},
+			{
+				name: "policy_engine",
+				writable: true
+			},
+			{
+				name: "event_authority"
+			}
+		],
+		args: [
+			{
+				name: "cpi_data",
+				type: "bytes"
+			}
+		]
+	},
+	{
+		name: "set_lut_address",
+		discriminator: [
+			254,
+			239,
+			106,
+			70,
+			17,
+			87,
+			57,
+			202
+		],
+		accounts: [
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "asset_access_controller",
+				writable: true,
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role",
+				optional: true
+			},
+			{
+				name: "lut_address"
+			}
+		],
+		args: [
+		]
+	},
+	{
+		name: "thaw_token_account",
+		discriminator: [
+			199,
+			172,
+			96,
+			93,
+			244,
+			252,
+			137,
+			171
+		],
+		accounts: [
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role"
+			},
+			{
+				name: "asset_controller_program",
+				address: "7tXjmbkZVY3Gmg9kDBebcNXT1yC5pyoxxXVLwdbv9tvP"
+			},
+			{
+				name: "asset_mint",
+				writable: true
+			},
+			{
+				name: "asset_controller"
+			},
+			{
+				name: "token_account",
+				writable: true
+			},
+			{
+				name: "token_program",
+				address: "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
+			}
+		],
+		args: [
+			{
+				name: "cpi_data",
+				type: "bytes"
+			}
+		]
+	},
+	{
+		name: "update_asset_metadata",
+		discriminator: [
+			217,
+			98,
+			205,
+			153,
+			242,
+			4,
+			41,
+			76
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				writable: true,
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role"
+			},
+			{
+				name: "asset_controller_program",
+				address: "7tXjmbkZVY3Gmg9kDBebcNXT1yC5pyoxxXVLwdbv9tvP"
+			},
+			{
+				name: "asset_mint",
+				writable: true
+			},
+			{
+				name: "asset_controller"
+			},
+			{
+				name: "event_authority"
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			},
+			{
+				name: "token_program",
+				address: "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
+			}
+		],
+		args: [
+			{
+				name: "cpi_data",
+				type: "bytes"
+			}
+		]
+	},
+	{
+		name: "update_controller_admin",
+		discriminator: [
+			94,
+			188,
+			33,
+			18,
+			191,
+			119,
+			128,
+			209
+		],
+		accounts: [
+			{
+				name: "admin",
+				signer: true,
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				writable: true
+			}
+		],
+		args: [
+			{
+				name: "new_admin",
+				type: "pubkey"
+			}
+		]
+	},
+	{
+		name: "update_interest_bearing_mint_rate",
+		discriminator: [
+			29,
+			174,
+			109,
+			163,
+			227,
+			75,
+			2,
+			144
+		],
+		accounts: [
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role"
+			},
+			{
+				name: "asset_controller_program",
+				address: "7tXjmbkZVY3Gmg9kDBebcNXT1yC5pyoxxXVLwdbv9tvP"
+			},
+			{
+				name: "asset_mint",
+				writable: true
+			},
+			{
+				name: "asset_controller"
+			},
+			{
+				name: "event_authority"
+			},
+			{
+				name: "token_program",
+				address: "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
+			}
+		],
+		args: [
+			{
+				name: "cpi_data",
+				type: "bytes"
+			}
+		]
+	},
+	{
+		name: "withdraw_excess_rent",
+		discriminator: [
+			20,
+			25,
+			71,
+			58,
+			107,
+			60,
+			159,
+			75
+		],
+		accounts: [
+			{
+				name: "receiver",
+				writable: true
+			},
+			{
+				name: "user",
+				signer: true
+			},
+			{
+				name: "controller_authority",
+				writable: true,
+				relations: [
+					"asset_access_controller"
+				]
+			},
+			{
+				name: "asset_access_controller",
+				relations: [
+					"authorized_user_role"
+				]
+			},
+			{
+				name: "authorized_user_role",
+				optional: true
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			}
+		],
+		args: [
+		]
+	}
+];
+var accounts$1 = [
+	{
+		name: "AssetAccessController",
+		discriminator: [
+			159,
+			84,
+			3,
+			26,
+			90,
+			167,
+			134,
+			33
+		]
+	},
+	{
+		name: "UserRole",
+		discriminator: [
+			62,
+			252,
+			194,
+			137,
+			183,
+			165,
+			147,
+			28
+		]
+	}
+];
+var events$1 = [
+	{
+		name: "AssignUserRoleEvent",
+		discriminator: [
+			66,
+			20,
+			203,
+			47,
+			242,
+			72,
+			213,
+			93
+		]
+	},
+	{
+		name: "RemoveUserRoleEvent",
+		discriminator: [
+			213,
+			162,
+			73,
+			7,
+			11,
+			89,
+			226,
+			140
+		]
+	}
+];
+var errors$1 = [
+	{
+		code: 6000,
+		name: "UnknownInstruction",
+		msg: "Unknown program instruction from CPI data"
+	},
+	{
+		code: 6001,
+		name: "InvalidName",
+		msg: "Invalid name"
+	},
+	{
+		code: 6002,
+		name: "InvalidUserRole",
+		msg: "Invalid user role"
+	},
+	{
+		code: 6003,
+		name: "DataIsNotEmpty",
+		msg: "Data is not empty"
+	},
+	{
+		code: 6004,
+		name: "UnknownAccount",
+		msg: "Unknown account discriminator"
+	},
+	{
+		code: 6005,
+		name: "MissingReason",
+		msg: "Missing reason or code"
+	},
+	{
+		code: 6006,
+		name: "InvalidLevel",
+		msg: "Invalid level"
+	},
+	{
+		code: 6007,
+		name: "IllegalOperation",
+		msg: "Illegal operation"
+	},
+	{
+		code: 6008,
+		name: "InvalidFlags",
+		msg: "Invalid flag bits"
+	},
+	{
+		code: 6009,
+		name: "CannotEmptyMasterRole",
+		msg: "Cannot empty master role of users"
+	},
+	{
+		code: 6010,
+		name: "CannotVoidAuthority",
+		msg: "Cannot void authority"
+	},
+	{
+		code: 6011,
+		name: "InvalidMasterRole",
+		msg: "Invalid master role"
+	},
+	{
+		code: 6012,
+		name: "CannotDeleteMasterRole",
+		msg: "Cannot delete master role"
+	},
+	{
+		code: 6013,
+		name: "UnauthorizedSigner",
+		msg: "Unauthorized admin signer"
+	}
+];
+var types$1 = [
+	{
+		name: "AssetAccessController",
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "controller_authority",
+					docs: [
+						"PDA generated from [asset_access_controller] as seed to be used as signer authority."
+					],
+					type: "pubkey"
+				},
+				{
+					name: "controller_authority_bump",
+					docs: [
+						"Bump seed for controller_authority."
+					],
+					type: "u8"
+				},
+				{
+					name: "admin",
+					docs: [
+						"Admin keypair that's allowed to manage this controller."
+					],
+					type: "pubkey"
+				},
+				{
+					name: "asset_mint",
+					docs: [
+						"Asset mint that is going to be managed by this controller."
+					],
+					type: "pubkey"
+				},
+				{
+					name: "user_roles_count",
+					docs: [
+						"Number of UserRoles created since initialization. Used for deriving all created UserRole PDAs."
+					],
+					type: "u64"
+				},
+				{
+					name: "has_master_role",
+					docs: [
+						"Whether a master role exists."
+					],
+					type: "bool"
+				},
+				{
+					name: "lut_address",
+					docs: [
+						"Address of the lookup table."
+					],
+					type: "pubkey"
+				}
+			]
+		}
+	},
+	{
+		name: "AssignUserRoleEvent",
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "addresses",
+					type: {
+						vec: "pubkey"
+					}
+				},
+				{
+					name: "role",
+					type: "string"
+				},
+				{
+					name: "role_id",
+					type: "u64"
+				},
+				{
+					name: "sender",
+					type: "pubkey"
+				},
+				{
+					name: "asset_mint",
+					type: "pubkey"
+				}
+			]
+		}
+	},
+	{
+		name: "RemoveUserRoleEvent",
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "addresses",
+					type: {
+						vec: "pubkey"
+					}
+				},
+				{
+					name: "role",
+					type: "string"
+				},
+				{
+					name: "role_id",
+					type: "u64"
+				},
+				{
+					name: "sender",
+					type: "pubkey"
+				},
+				{
+					name: "asset_mint",
+					type: "pubkey"
+				}
+			]
+		}
+	},
+	{
+		name: "UserRole",
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "asset_access_controller",
+					docs: [
+						"Controller that user role is designated for."
+					],
+					type: "pubkey"
+				},
+				{
+					name: "id",
+					docs: [
+						"ID of UserRole. Matches AssetAccessController.user_roles_count at time of creation."
+					],
+					type: "u64"
+				},
+				{
+					name: "name",
+					docs: [
+						"Name of this role."
+					],
+					type: "string"
+				},
+				{
+					name: "allowed_admin_ixs",
+					docs: [
+						"Bitflag of allowed admin instructions."
+					],
+					type: "u64"
+				},
+				{
+					name: "allowed_medici_ixs",
+					docs: [
+						"Bitflag of allowed Medici CPI instructions."
+					],
+					type: "u64"
+				},
+				{
+					name: "is_master_role",
+					docs: [
+						"If true, this is the master role."
+					],
+					type: "bool"
+				},
+				{
+					name: "users",
+					docs: [
+						"List of users assigned with this role."
+					],
+					type: {
+						vec: "pubkey"
+					}
+				}
+			]
+		}
+	}
+];
+var rwa_rbac = {
+	address: address$1,
+	metadata: metadata$1,
+	instructions: instructions$1,
+	accounts: accounts$1,
+	events: events$1,
+	errors: errors$1,
+	types: types$1
+};
+
+var rbacIDL = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  address: address$1,
+  metadata: metadata$1,
+  instructions: instructions$1,
+  accounts: accounts$1,
+  events: events$1,
+  errors: errors$1,
+  types: types$1,
+  'default': rwa_rbac
+});
+
+var address = "D2V7wTBbNCKgYwirgRUnSmc2QyKnHSVmRotWJ4rz8Jp9";
+var metadata = {
+	name: "rwa_imr",
+	version: "0.1.0",
+	spec: "0.1.0",
+	description: "Created with Anchor"
+};
+var instructions = [
+	{
+		name: "add_levels",
+		discriminator: [
+			101,
+			239,
+			15,
+			85,
+			60,
+			13,
+			183,
+			192
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "authority",
+				signer: true,
+				relations: [
+					"investor"
+				]
+			},
+			{
+				name: "investor",
+				writable: true
+			},
+			{
+				name: "identity_registry_program",
+				address: "GZsnjqT3c5zbHqsctrJ4EG4rbEfo7ZXyyUG7aDJNmxfA"
+			},
+			{
+				name: "identity_registry",
+				relations: [
+					"investor"
+				]
+			},
+			{
+				name: "identity_account",
+				writable: true,
+				relations: [
+					"investor"
+				]
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			},
+			{
+				name: "policy_engine_program"
+			},
+			{
+				name: "policy_engine",
+				writable: true
+			},
+			{
+				name: "tracker_account"
+			},
+			{
+				name: "asset_mint"
+			},
+			{
+				name: "event_authority_identity_registry"
+			},
+			{
+				name: "event_authority",
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								95,
+								95,
+								101,
+								118,
+								101,
+								110,
+								116,
+								95,
+								97,
+								117,
+								116,
+								104,
+								111,
+								114,
+								105,
+								116,
+								121
+							]
+						}
+					]
+				}
+			},
+			{
+				name: "program"
+			}
+		],
+		args: [
+			{
+				name: "levels",
+				type: "bytes"
+			},
+			{
+				name: "expiries",
+				type: {
+					vec: "i64"
+				}
+			},
+			{
+				name: "proof_hashes",
+				type: {
+					vec: "string"
+				}
+			},
+			{
+				name: "enforce_limits",
+				type: "bool"
+			}
+		]
+	},
+	{
+		name: "attach_wallet_by_investor",
+		discriminator: [
+			252,
+			160,
+			12,
+			48,
+			159,
+			73,
+			185,
+			247
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "wallet",
+				signer: true
+			},
+			{
+				name: "investor"
+			},
+			{
+				name: "wallet_identity"
+			},
+			{
+				name: "identity_registry_program",
+				address: "GZsnjqT3c5zbHqsctrJ4EG4rbEfo7ZXyyUG7aDJNmxfA"
+			},
+			{
+				name: "new_wallet_identity",
+				writable: true
+			},
+			{
+				name: "identity_account",
+				writable: true,
+				relations: [
+					"investor"
+				]
+			},
+			{
+				name: "identity_registry",
+				relations: [
+					"investor"
+				]
+			},
+			{
+				name: "asset_mint"
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			},
+			{
+				name: "event_authority_identity_registry"
+			}
+		],
+		args: [
+			{
+				name: "new_wallet",
+				type: "pubkey"
+			}
+		]
+	},
+	{
+		name: "change_country",
+		discriminator: [
+			208,
+			227,
+			224,
+			246,
+			9,
+			254,
+			62,
+			179
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "authority",
+				signer: true,
+				relations: [
+					"investor"
+				]
+			},
+			{
+				name: "investor",
+				writable: true
+			},
+			{
+				name: "identity_registry_program",
+				address: "GZsnjqT3c5zbHqsctrJ4EG4rbEfo7ZXyyUG7aDJNmxfA"
+			},
+			{
+				name: "identity_registry",
+				relations: [
+					"investor"
+				]
+			},
+			{
+				name: "identity_account",
+				writable: true,
+				relations: [
+					"investor"
+				]
+			},
+			{
+				name: "policy_engine_program"
+			},
+			{
+				name: "policy_engine",
+				writable: true
+			},
+			{
+				name: "tracker_account"
+			},
+			{
+				name: "asset_mint"
+			},
+			{
+				name: "event_authority_identity_registry"
+			}
+		],
+		args: [
+			{
+				name: "new_country",
+				type: "u8"
+			},
+			{
+				name: "enforce_limits",
+				type: "bool"
+			}
+		]
+	},
+	{
+		name: "register_investor",
+		discriminator: [
+			95,
+			16,
+			66,
+			212,
+			152,
+			123,
+			136,
+			173
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "authority",
+				docs: [
+					"Authority has to be authority or delegate of IdentityRegistry for CPI to succeed."
+				],
+				signer: true
+			},
+			{
+				name: "investor",
+				writable: true,
+				pda: {
+					seeds: [
+						{
+							kind: "arg",
+							path: "investor_id"
+						},
+						{
+							kind: "account",
+							path: "identity_registry"
+						},
+						{
+							kind: "const",
+							value: [
+								73,
+								110,
+								118,
+								101,
+								115,
+								116,
+								111,
+								114
+							]
+						}
+					]
+				}
+			},
+			{
+				name: "identity_registry_program",
+				address: "GZsnjqT3c5zbHqsctrJ4EG4rbEfo7ZXyyUG7aDJNmxfA"
+			},
+			{
+				name: "identity_registry"
+			},
+			{
+				name: "identity_account",
+				writable: true
+			},
+			{
+				name: "wallet_identity",
+				writable: true
+			},
+			{
+				name: "policy_engine_program"
+			},
+			{
+				name: "tracker_account",
+				writable: true
+			},
+			{
+				name: "asset_mint"
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			},
+			{
+				name: "event_authority_identity_registry"
+			},
+			{
+				name: "event_authority",
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								95,
+								95,
+								101,
+								118,
+								101,
+								110,
+								116,
+								95,
+								97,
+								117,
+								116,
+								104,
+								111,
+								114,
+								105,
+								116,
+								121
+							]
+						}
+					]
+				}
+			},
+			{
+				name: "program"
+			}
+		],
+		args: [
+			{
+				name: "investor_id",
+				type: "string"
+			},
+			{
+				name: "collision_hash",
+				type: "string"
+			},
+			{
+				name: "level",
+				type: "u8"
+			},
+			{
+				name: "expiry",
+				type: "i64"
+			},
+			{
+				name: "country",
+				type: "u8"
+			},
+			{
+				name: "proof_hash",
+				type: "string"
+			}
+		]
+	},
+	{
+		name: "remove_investor",
+		discriminator: [
+			93,
+			0,
+			162,
+			199,
+			76,
+			5,
+			180,
+			2
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "authority",
+				signer: true,
+				relations: [
+					"investor"
+				]
+			},
+			{
+				name: "investor",
+				writable: true
+			},
+			{
+				name: "identity_registry_program",
+				address: "GZsnjqT3c5zbHqsctrJ4EG4rbEfo7ZXyyUG7aDJNmxfA"
+			},
+			{
+				name: "identity_registry",
+				relations: [
+					"investor"
+				]
+			},
+			{
+				name: "identity_account",
+				writable: true,
+				relations: [
+					"investor"
+				]
+			},
+			{
+				name: "wallet_identity",
+				writable: true
+			},
+			{
+				name: "policy_engine_program",
+				address: "FsE8mCJyvgMzqJbfHbJQm3iuf3cRZC6n2vZi1Q8rQCy2"
+			},
+			{
+				name: "tracker_account",
+				writable: true
+			},
+			{
+				name: "event_authority_identity_registry"
+			},
+			{
+				name: "asset_mint"
+			},
+			{
+				name: "event_authority",
+				pda: {
+					seeds: [
+						{
+							kind: "const",
+							value: [
+								95,
+								95,
+								101,
+								118,
+								101,
+								110,
+								116,
+								95,
+								97,
+								117,
+								116,
+								104,
+								111,
+								114,
+								105,
+								116,
+								121
+							]
+						}
+					]
+				}
+			},
+			{
+				name: "program"
+			}
+		],
+		args: [
+		]
+	},
+	{
+		name: "remove_levels",
+		discriminator: [
+			200,
+			96,
+			65,
+			253,
+			97,
+			55,
+			16,
+			192
+		],
+		accounts: [
+			{
+				name: "payer",
+				writable: true,
+				signer: true
+			},
+			{
+				name: "authority",
+				signer: true,
+				relations: [
+					"investor"
+				]
+			},
+			{
+				name: "investor",
+				writable: true
+			},
+			{
+				name: "identity_registry_program",
+				address: "GZsnjqT3c5zbHqsctrJ4EG4rbEfo7ZXyyUG7aDJNmxfA"
+			},
+			{
+				name: "identity_registry",
+				relations: [
+					"investor"
+				]
+			},
+			{
+				name: "identity_account",
+				writable: true,
+				relations: [
+					"investor"
+				]
+			},
+			{
+				name: "system_program",
+				address: "11111111111111111111111111111111"
+			},
+			{
+				name: "policy_engine_program"
+			},
+			{
+				name: "policy_engine",
+				writable: true
+			},
+			{
+				name: "tracker_account"
+			},
+			{
+				name: "asset_mint"
+			},
+			{
+				name: "event_authority_identity_registry"
+			}
+		],
+		args: [
+			{
+				name: "levels_to_remove",
+				type: "bytes"
+			},
+			{
+				name: "enforce_limits",
+				type: "bool"
+			}
+		]
+	}
+];
+var accounts = [
+	{
+		name: "Investor",
+		discriminator: [
+			174,
+			129,
+			17,
+			83,
+			36,
+			116,
+			26,
+			196
+		]
+	}
+];
+var events = [
+	{
+		name: "AddLevelsEvent",
+		discriminator: [
+			90,
+			156,
+			44,
+			28,
+			242,
+			1,
+			130,
+			61
+		]
+	},
+	{
+		name: "RegisterInvestorEvent",
+		discriminator: [
+			137,
+			181,
+			142,
+			164,
+			140,
+			196,
+			246,
+			182
+		]
+	},
+	{
+		name: "RemoveInvestorEvent",
+		discriminator: [
+			221,
+			84,
+			243,
+			216,
+			215,
+			253,
+			246,
+			253
+		]
+	},
+	{
+		name: "RemoveLevelsEvent",
+		discriminator: [
+			145,
+			158,
+			97,
+			146,
+			126,
+			14,
+			2,
+			225
+		]
+	}
+];
+var errors = [
+	{
+		code: 6000,
+		name: "UnknownInstruction",
+		msg: "Unknown program instruction from CPI data"
+	},
+	{
+		code: 6001,
+		name: "InvalidHash",
+		msg: "Invalid hash"
+	},
+	{
+		code: 6002,
+		name: "InvalidLevels",
+		msg: "Invalid levels"
+	},
+	{
+		code: 6003,
+		name: "InvalidCountryLevel",
+		msg: "Invalid country level"
+	},
+	{
+		code: 6004,
+		name: "InvalidRegionLevel",
+		msg: "Invalid region level"
+	},
+	{
+		code: 6005,
+		name: "InvalidAttribute",
+		msg: "Invalid attribute level"
+	},
+	{
+		code: 6006,
+		name: "UnknownLevel",
+		msg: "Unknown level"
+	}
+];
+var types = [
+	{
+		name: "AddLevelsEvent",
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "investor_id",
+					type: "string"
+				},
+				{
+					name: "sender",
+					type: "pubkey"
+				},
+				{
+					name: "levels",
+					type: "bytes"
+				},
+				{
+					name: "expiries",
+					type: {
+						vec: "i64"
+					}
+				},
+				{
+					name: "proof_hashes",
+					type: {
+						vec: "string"
+					}
+				}
+			]
+		}
+	},
+	{
+		name: "Investor",
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "authority",
+					docs: [
+						"Authority keypair allowed to write this account, will match authority or delegate of IdentityRegistry",
+						"at time of creation of IdentityAccount."
+					],
+					type: "pubkey"
+				},
+				{
+					name: "identity_account",
+					docs: [
+						"IdentityAccount associated with this investor."
+					],
+					type: "pubkey"
+				},
+				{
+					name: "identity_registry",
+					docs: [
+						"IdentityRegistryAccount associated with this investor."
+					],
+					type: "pubkey"
+				},
+				{
+					name: "bump",
+					docs: [
+						"PDA Seed Bump"
+					],
+					type: "u8"
+				},
+				{
+					name: "investor_id",
+					docs: [
+						"Unique ID for Investor, generated off-chain."
+					],
+					type: "string"
+				},
+				{
+					name: "collision_hash",
+					docs: [
+						"Metadata for investor, generated off-chain."
+					],
+					type: "string"
+				},
+				{
+					name: "last_updated_by",
+					docs: [
+						"User that last modified this investor. Read from payer of instruction."
+					],
+					type: "pubkey"
+				},
+				{
+					name: "levels",
+					docs: [
+						"Levels assigned to investor."
+					],
+					type: {
+						vec: {
+							defined: {
+								name: "LevelData"
+							}
+						}
+					}
+				},
+				{
+					name: "country",
+					type: "u8"
+				}
+			]
+		}
+	},
+	{
+		name: "LevelData",
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "level",
+					docs: [
+						"Maps to IdentityAccount level used in RWA Token."
+					],
+					type: "u8"
+				},
+				{
+					name: "proof_hash",
+					docs: [
+						"Hash generated off-chain."
+					],
+					type: "string"
+				}
+			]
+		}
+	},
+	{
+		name: "RegisterInvestorEvent",
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "investor_id",
+					type: "string"
+				},
+				{
+					name: "level",
+					type: "u8"
+				},
+				{
+					name: "expiry",
+					type: "i64"
+				},
+				{
+					name: "collision_hash",
+					type: "string"
+				},
+				{
+					name: "sender",
+					type: "pubkey"
+				},
+				{
+					name: "country",
+					type: "u8"
+				}
+			]
+		}
+	},
+	{
+		name: "RemoveInvestorEvent",
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "investor_id",
+					type: "string"
+				},
+				{
+					name: "sender",
+					type: "pubkey"
+				}
+			]
+		}
+	},
+	{
+		name: "RemoveLevelsEvent",
+		type: {
+			kind: "struct",
+			fields: [
+				{
+					name: "investor_id",
+					type: "string"
+				},
+				{
+					name: "sender",
+					type: "pubkey"
+				},
+				{
+					name: "levels",
+					type: "bytes"
+				}
+			]
+		}
+	}
+];
+var rwa_imr = {
+	address: address,
+	metadata: metadata,
+	instructions: instructions,
+	accounts: accounts,
+	events: events,
+	errors: errors,
+	types: types
+};
+
+var imrIDL = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  address: address,
+  metadata: metadata,
+  instructions: instructions,
+  accounts: accounts,
+  events: events,
+  errors: errors,
+  types: types,
+  'default': rwa_imr
+});
+
+exports.AdminFlags = void 0;
+(function (AdminFlags) {
+    AdminFlags[AdminFlags["NONE"] = 0] = "NONE";
+    AdminFlags[AdminFlags["CREATE_OR_DELETE_USER_ROLE"] = 1] = "CREATE_OR_DELETE_USER_ROLE";
+    AdminFlags[AdminFlags["MODIFY_USER_ROLE"] = 2] = "MODIFY_USER_ROLE";
+    AdminFlags[AdminFlags["ASSIGN_OR_REMOVE_ANY_USER_ROLE"] = 4] = "ASSIGN_OR_REMOVE_ANY_USER_ROLE";
+    AdminFlags[AdminFlags["ASSIGN_OR_REMOVE_CURRENT_ROLE"] = 8] = "ASSIGN_OR_REMOVE_CURRENT_ROLE";
+    AdminFlags[AdminFlags["SET_LUT_ADDRESS"] = 16] = "SET_LUT_ADDRESS";
+    AdminFlags[AdminFlags["WITHDRAW_EXCESS_RENT"] = 32] = "WITHDRAW_EXCESS_RENT";
+    AdminFlags[AdminFlags["ALL"] = 63] = "ALL";
+})(exports.AdminFlags || (exports.AdminFlags = {}));
+exports.MediciFlags = void 0;
+(function (MediciFlags) {
+    MediciFlags[MediciFlags["NONE"] = 0] = "NONE";
+    MediciFlags[MediciFlags["UPDATE_ASSET_METADATA"] = 1] = "UPDATE_ASSET_METADATA";
+    MediciFlags[MediciFlags["THAW_TOKEN_ACCOUNT"] = 2] = "THAW_TOKEN_ACCOUNT";
+    MediciFlags[MediciFlags["FREEZE_TOKEN_ACCOUNT"] = 4] = "FREEZE_TOKEN_ACCOUNT";
+    MediciFlags[MediciFlags["ISSUE_TOKENS"] = 8] = "ISSUE_TOKENS";
+    MediciFlags[MediciFlags["REVOKE_TOKENS"] = 16] = "REVOKE_TOKENS";
+    MediciFlags[MediciFlags["UPDATE_INTEREST_BEARING_MINT_RATE"] = 32] = "UPDATE_INTEREST_BEARING_MINT_RATE";
+    MediciFlags[MediciFlags["ATTACH_TO_POLICY_ACCOUNT"] = 64] = "ATTACH_TO_POLICY_ACCOUNT";
+    MediciFlags[MediciFlags["CREATE_POLICY_ACCOUNT"] = 128] = "CREATE_POLICY_ACCOUNT";
+    MediciFlags[MediciFlags["DETACH_FROM_POLICY_ACCOUNT"] = 256] = "DETACH_FROM_POLICY_ACCOUNT";
+    MediciFlags[MediciFlags["ADD_LEVELS"] = 512] = "ADD_LEVELS";
+    MediciFlags[MediciFlags["ADD_LEVEL_TO_IDENTITY_ACCOUNT"] = 1024] = "ADD_LEVEL_TO_IDENTITY_ACCOUNT";
+    MediciFlags[MediciFlags["REGISTER_INVESTOR"] = 2048] = "REGISTER_INVESTOR";
+    MediciFlags[MediciFlags["REMOVE_LEVELS"] = 4096] = "REMOVE_LEVELS";
+    MediciFlags[MediciFlags["REMOVE_INVESTOR"] = 8192] = "REMOVE_INVESTOR";
+    MediciFlags[MediciFlags["EDIT_IDENTITY_METADATA"] = 16384] = "EDIT_IDENTITY_METADATA";
+    MediciFlags[MediciFlags["REFRESH_LEVEL_TO_IDENTITY_ACCOUNT"] = 32768] = "REFRESH_LEVEL_TO_IDENTITY_ACCOUNT";
+    MediciFlags[MediciFlags["ATTACH_WALLET_TO_IDENTITY"] = 65536] = "ATTACH_WALLET_TO_IDENTITY";
+    MediciFlags[MediciFlags["DETACH_WALLET_FROM_IDENTITY"] = 131072] = "DETACH_WALLET_FROM_IDENTITY";
+    MediciFlags[MediciFlags["SEIZE_TOKENS"] = 262144] = "SEIZE_TOKENS";
+    MediciFlags[MediciFlags["CREATE_IDENTITY_ACCOUNT"] = 524288] = "CREATE_IDENTITY_ACCOUNT";
+    MediciFlags[MediciFlags["CREATE_INVESTOR_LOCKS"] = 1048576] = "CREATE_INVESTOR_LOCKS";
+    MediciFlags[MediciFlags["CLOSE_INVESTOR_LOCKS"] = 2097152] = "CLOSE_INVESTOR_LOCKS";
+    MediciFlags[MediciFlags["ADD_TOKEN_LOCK"] = 4194304] = "ADD_TOKEN_LOCK";
+    MediciFlags[MediciFlags["REMOVE_TOKEN_LOCK"] = 8388608] = "REMOVE_TOKEN_LOCK";
+    MediciFlags[MediciFlags["CHANGE_COUNTERS"] = 16777216] = "CHANGE_COUNTERS";
+    MediciFlags[MediciFlags["CHANGE_COUNTER_LIMITS"] = 33554432] = "CHANGE_COUNTER_LIMITS";
+    MediciFlags[MediciFlags["CHANGE_COUNTRY"] = 67108864] = "CHANGE_COUNTRY";
+    MediciFlags[MediciFlags["CHANGE_MAPPING"] = 134217728] = "CHANGE_MAPPING";
+    MediciFlags[MediciFlags["CHANGE_ISSUANCE_POLICIES"] = 268435456] = "CHANGE_ISSUANCE_POLICIES";
+    MediciFlags[MediciFlags["REMOVE_IDENTITY_ACCOUNT"] = 536870912] = "REMOVE_IDENTITY_ACCOUNT";
+    MediciFlags[MediciFlags["ALL"] = 1073741823] = "ALL";
+})(exports.MediciFlags || (exports.MediciFlags = {}));
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * Represents the role-based access client for Asset Controller for an RWA.
+ */
+class AssetController {
+    constructor(rwaClient, rbacProgram) {
+        this.rwaClient = rwaClient;
+        this.rbacProgram = rbacProgram;
+    }
+    /**
+     * Asynchronously generates instructions to setup a new asset controller.
+     * @param args - {@link CreateAssetControllerIx}
+     * @returns A Promise that resolves to the instructions to create an asset controller.
+     */
+    setupNewRegistry(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return rwaTokenSdk.getCreateAssetControllerIx(args, this.rwaClient.provider);
+        });
+    }
+    /**
+     * Update the asset controller's metadata.
+     * @param args - {@link UpdateAssetMetadataArgs}
+     * @param assetAccessController - RBAC AssetAccessController account.
+     * @param authorizedUserRole - UserRole authorized to invoke instruction.
+     * @returns A Promise that resolves to the instructions to update the asset controller's metadata.
+     * */
+    updateAssetMetadata(args, assetAccessController, authorizedUserRole) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const updateIx = yield this.rwaClient.assetController.updateAssetMetadata(args);
+            const ixData = updateIx.data;
+            return this.rbacProgram.methods
+                .updateAssetMetadata(ixData)
+                .accountsStrict({
+                payer: args.payer,
+                user: args.signer,
+                controllerAuthority: args.authority,
+                assetAccessController,
+                authorizedUserRole: authorizedUserRole || null,
+                assetMint: args.assetMint,
+                assetController: rwaTokenSdk.getAssetControllerPda(args.assetMint),
+                assetControllerProgram: rwaTokenSdk.assetControllerProgramId,
+                tokenProgram: splToken.TOKEN_2022_PROGRAM_ID,
+                eventAuthority: rwaTokenSdk.getAssetControllerEventAuthority(),
+                systemProgram: web3_js.SystemProgram.programId,
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Asynchronously generates instructions to issue tokens and lock tokens according to issuance policy.
+     * @param args - {@link IssueTokensWithLockArgs}
+     * @param assetAccessController - RBAC AssetAccessController account.
+     * @param authorizedUserRole - UserRole authorized to invoke instruction.
+     */
+    issueTokenIxns(args, assetAccessController, authorizedUserRole) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const identityRegistry = rwaTokenSdk.getIdentityRegistryPda(args.assetMint);
+            const controllerAuthority = deriveControllerAuthorityPda(assetAccessController);
+            const investorPda = deriveInvestorPda(args.investorId, identityRegistry);
+            const issueTokensIxs = yield rwaTokenSdk.getIssueTokensIx({
+                payer: args.payer,
+                signer: args.signer,
+                wallet: args.wallet,
+                assetMint: args.assetMint,
+                amount: args.amount,
+                timestamp: args.issuanceTimestamp,
+                authority: controllerAuthority.toString(),
+                owner: investorPda.toString(),
+            }, this.rwaClient.provider);
+            const trackerAccount = rwaTokenSdk.getTrackerAccountPda(args.assetMint, investorPda.toString());
+            const ixData = issueTokensIxs[0].data;
+            const tokenAccount = splToken.getAssociatedTokenAddressSync(new web3_js.PublicKey(args.assetMint), new web3_js.PublicKey(args.wallet), false, splToken.TOKEN_2022_PROGRAM_ID);
+            return yield this.rbacProgram.methods
+                .issueTokens(ixData)
+                .accountsStrict({
+                payer: args.payer,
+                user: args.signer,
+                controllerAuthority: controllerAuthority,
+                assetAccessController: assetAccessController,
+                authorizedUserRole: authorizedUserRole || null,
+                assetControllerProgram: rwaTokenSdk.assetControllerProgramId,
+                assetMint: args.assetMint,
+                assetController: rwaTokenSdk.getAssetControllerPda(args.assetMint),
+                to: args.wallet,
+                tokenAccount: tokenAccount,
+                policyEngine: rwaTokenSdk.getPolicyEnginePda(args.assetMint),
+                policyEngineProgram: rwaTokenSdk.policyEngineProgramId,
+                identityAccount: rwaTokenSdk.getIdentityAccountPda(args.assetMint, investorPda.toString()),
+                trackerAccount,
+                identityRegistry,
+                tokenProgram: splToken.TOKEN_2022_PROGRAM_ID,
+                associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+                systemProgram: web3_js.SystemProgram.programId,
+                walletIdentityAccount: rwaTokenSdk.getWalletIdentityAccountPda(args.assetMint, args.wallet),
+                eventAuthority: rwaTokenSdk.getAssetControllerEventAuthority(),
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Executes a token transfer.
+     * @param args - {@link TransferTokensArgs}
+     * @returns A promise that resolves to transaction instruction.
+     */
+    transfer(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.rwaClient.assetController.transfer(args);
+        });
+    }
+    /**
+     * Asynchronously generates instruction to freeze a token account.
+     * @param args - {@link FreezeTokenArgs}
+     * @param assetAccessController - RBAC AssetAccessController account.
+     * @param authorizedUserRole - UserRole authorized to invoke instruction.
+     * @returns A Promise that resolves to the instruction to freeze.
+     */
+    freezeTokenIxn(args, assetAccessController, authorizedUserRole) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const freezeIx = yield rwaTokenSdk.getFreezeTokenIx(args, this.rwaClient.provider);
+            const ixData = freezeIx.data;
+            const tokenAccount = splToken.getAssociatedTokenAddressSync(new web3_js.PublicKey(args.assetMint), new web3_js.PublicKey(args.owner), false, splToken.TOKEN_2022_PROGRAM_ID);
+            return this.rbacProgram.methods
+                .freezeTokenAccount(ixData)
+                .accountsStrict({
+                user: args.signer,
+                controllerAuthority: args.authority,
+                assetAccessController: assetAccessController,
+                authorizedUserRole: authorizedUserRole || null,
+                assetControllerProgram: rwaTokenSdk.assetControllerProgramId,
+                assetMint: args.assetMint,
+                assetController: rwaTokenSdk.getAssetControllerPda(args.assetMint),
+                tokenAccount,
+                tokenProgram: splToken.TOKEN_2022_PROGRAM_ID,
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Asynchronously generates instruction to thaw a token account.
+     * @param args - {@link FreezeTokenArgs}
+     * @param assetAccessController - RBAC AssetAccessController account.
+     * @param authorizedUserRole - UserRole authorized to invoke instruction.
+     * @returns A Promise that resolves to the instruction to thaw.
+     */
+    thawTokenIxn(args, assetAccessController, authorizedUserRole) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const thawIx = yield rwaTokenSdk.getThawTokenIx(args, this.rwaClient.provider);
+            const ixData = thawIx.data;
+            const tokenAccount = splToken.getAssociatedTokenAddressSync(new web3_js.PublicKey(args.assetMint), new web3_js.PublicKey(args.owner), false, splToken.TOKEN_2022_PROGRAM_ID);
+            return this.rbacProgram.methods
+                .thawTokenAccount(ixData)
+                .accountsStrict({
+                user: args.signer,
+                controllerAuthority: args.authority,
+                assetAccessController: assetAccessController,
+                authorizedUserRole: authorizedUserRole || null,
+                assetControllerProgram: rwaTokenSdk.assetControllerProgramId,
+                assetMint: args.assetMint,
+                assetController: rwaTokenSdk.getAssetControllerPda(args.assetMint),
+                tokenAccount,
+                tokenProgram: splToken.TOKEN_2022_PROGRAM_ID,
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Asynchronously generates instructions to revoke tokens from a user.
+     * @param args - {@link RevokeTokensArgs}
+     * @param signer - User signer public key.
+     * @param assetAccessController - RBAC AssetAccessController account.
+     * @param authorizedUserRole - UserRole authorized to invoke instruction.
+     * @param investorId - Optional investorId. Required if user is not an investor.
+     * @returns A Promise that resolves to the instructions to revoke.
+     */
+    revokeTokenIxn(args, signer, assetAccessController, authorizedUserRole, investorId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!args.wallet) {
+                throw new Error("Use wallet arg for wallet to revoke tokens from.");
+            }
+            // Set owner (even though it is InvestorPda) as wallet to generate ix data.
+            args.owner = args.wallet;
+            const revokeIx = yield rwaTokenSdk.getRevokeTokensIx(args, this.rwaClient.provider);
+            const identityRegistry = rwaTokenSdk.getIdentityRegistryPda(args.assetMint);
+            const investorPda = investorId
+                ? deriveInvestorPda(investorId, identityRegistry)
+                : null;
+            const ixData = revokeIx.data;
+            const assetController = rwaTokenSdk.getAssetControllerPda(args.assetMint);
+            const revokeTokenAccount = splToken.getAssociatedTokenAddressSync(new web3_js.PublicKey(args.assetMint), new web3_js.PublicKey(args.wallet), false, splToken.TOKEN_2022_PROGRAM_ID);
+            return yield this.rbacProgram.methods
+                .revokeTokens(ixData)
+                .accountsStrict({
+                user: signer,
+                controllerAuthority: args.authority,
+                assetAccessController: assetAccessController,
+                authorizedUserRole: authorizedUserRole || null,
+                assetControllerProgram: rwaTokenSdk.assetControllerProgramId,
+                assetMint: args.assetMint,
+                assetController,
+                revokeTokenAccount,
+                identityRegistry,
+                identityAccount: rwaTokenSdk.getIdentityAccountPda(args.assetMint, investorId ? investorPda.toString() : args.owner),
+                trackerAccount: rwaTokenSdk.getTrackerAccountPda(args.assetMint, investorId ? investorPda.toString() : args.owner),
+                policyEngineProgram: rwaTokenSdk.policyEngineProgramId,
+                policyEngine: rwaTokenSdk.getPolicyEnginePda(args.assetMint),
+                walletIdentityAccount: rwaTokenSdk.getWalletIdentityAccountPda(args.assetMint, args.wallet),
+                tokenProgram: splToken.TOKEN_2022_PROGRAM_ID,
+                associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+                systemProgram: web3_js.SystemProgram.programId,
+                eventAuthority: rwaTokenSdk.getAssetControllerEventAuthority(),
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Asynchronously generates instruction to update mint interest rate.
+     * @param args - {@link UpdateInterestBearingMintRateArgs}
+     * @param assetAccessController - RBAC AssetAccessController account.
+     * @param authorizedUserRole - UserRole authorized to invoke instruction.
+     * @returns A Promise that resolves to the instruction to update mint interest rate.
+     */
+    updateInterestBearingMintRateIxn(args, assetAccessController, authorizedUserRole) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const updateIx = yield rwaTokenSdk.getUpdateInterestBearingMintRateIx(args, this.rwaClient.provider);
+            const ixData = updateIx.data;
+            return this.rbacProgram.methods
+                .updateInterestBearingMintRate(ixData)
+                .accountsStrict({
+                user: args.signer,
+                controllerAuthority: args.authority,
+                assetAccessController: assetAccessController,
+                authorizedUserRole: authorizedUserRole || null,
+                assetControllerProgram: rwaTokenSdk.assetControllerProgramId,
+                assetMint: args.assetMint,
+                assetController: rwaTokenSdk.getAssetControllerPda(args.assetMint),
+                eventAuthority: rwaTokenSdk.getAssetControllerEventAuthority(),
+                tokenProgram: splToken.TOKEN_2022_PROGRAM_ID,
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Asynchronously generates instruction to seize tokens.
+     * @param args - {@link SeizeTokensArgs}
+     * @param signer - User signer public key.
+     * @param assetAccessController - RBAC AssetAccessController account.
+     * @param authorizedUserRole - UserRole authorized to invoke instruction.
+     * @returns A Promise that resolves to the instruction to seize.
+     */
+    seizeTokensIxn(args, investorId, signer, assetAccessController, authorizedUserRole) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const identityRegistry = rwaTokenSdk.getIdentityRegistryPda(args.assetMint);
+            const investorPda = deriveInvestorPda(investorId, identityRegistry);
+            const [_, seizeIx] = yield rwaTokenSdk.getSeizeTokensIx(Object.assign(Object.assign({}, args), { wallet: args.from, from: investorPda.toString() }), this.rwaClient.provider);
+            return this.rbacProgram.methods
+                .seizeTokens(seizeIx.data)
+                .accountsStrict({
+                user: signer,
+                controllerAuthority: args.authority,
+                assetAccessController: assetAccessController,
+                authorizedUserRole: authorizedUserRole || null,
+                assetControllerProgram: rwaTokenSdk.assetControllerProgramId,
+                assetMint: args.assetMint,
+                assetController: rwaTokenSdk.getAssetControllerPda(args.assetMint),
+                sourceTokenAccount: splToken.getAssociatedTokenAddressSync(new web3_js.PublicKey(args.assetMint), new web3_js.PublicKey(args.from), false, splToken.TOKEN_2022_PROGRAM_ID),
+                destinationTokenAccount: splToken.getAssociatedTokenAddressSync(new web3_js.PublicKey(args.assetMint), new web3_js.PublicKey(args.to), true, splToken.TOKEN_2022_PROGRAM_ID),
+                tokenProgram: splToken.TOKEN_2022_PROGRAM_ID,
+                eventAuthority: rwaTokenSdk.getAssetControllerEventAuthority(),
+            })
+                .remainingAccounts([
+                {
+                    pubkey: rwaTokenSdk.getPolicyEnginePda(args.assetMint),
+                    isWritable: true,
+                    isSigner: false,
+                },
+                {
+                    pubkey: rwaTokenSdk.identityRegistryProgramId,
+                    isWritable: false,
+                    isSigner: false,
+                },
+                {
+                    pubkey: rwaTokenSdk.policyEngineProgramId,
+                    isWritable: false,
+                    isSigner: false,
+                },
+                {
+                    pubkey: rwaTokenSdk.getIdentityRegistryPda(args.assetMint),
+                    isWritable: false,
+                    isSigner: false,
+                },
+                {
+                    pubkey: rwaTokenSdk.getIdentityAccountPda(args.assetMint, args.to),
+                    isWritable: false,
+                    isSigner: false,
+                },
+                {
+                    pubkey: rwaTokenSdk.getIdentityAccountPda(args.assetMint, investorPda.toString()),
+                    isWritable: false,
+                    isSigner: false,
+                },
+                {
+                    pubkey: rwaTokenSdk.getTrackerAccountPda(args.assetMint, args.to),
+                    isWritable: true,
+                    isSigner: false,
+                },
+                {
+                    pubkey: rwaTokenSdk.getTrackerAccountPda(args.assetMint, investorPda.toString()),
+                    isWritable: true,
+                    isSigner: false,
+                },
+                {
+                    pubkey: rwaTokenSdk.getExtraMetasListPda(args.assetMint),
+                    isWritable: false,
+                    isSigner: false,
+                },
+                {
+                    pubkey: rwaTokenSdk.getWalletIdentityAccountPda(args.assetMint, args.to),
+                    isWritable: false,
+                    isSigner: false,
+                },
+                {
+                    pubkey: rwaTokenSdk.getWalletIdentityAccountPda(args.assetMint, args.from),
+                    isWritable: false,
+                    isSigner: false,
+                },
+            ])
+                .instruction();
+        });
+    }
+}
+
+/**
+ * Represents the role-based access client for Policy Engine for an RWA.
+ */
+class PolicyEngine {
+    constructor(rwaClient, rbacProgram) {
+        this.rwaClient = rwaClient;
+        this.rbacProgram = rbacProgram;
+    }
+    /**
+     * Asynchronously attaches a policy to the policy account.
+     * @param args - {@link AttachPolicyArgs}
+     * @param signer - User signer public key.
+     * @param assetAccessController - RBAC AssetAccessController account.
+     * @param authorizedUserRole - UserRole authorized to invoke instruction.
+     * @returns A Promise that resolves to the instructions to attach a policy.
+     * */
+    attachPolicy(args, signer, assetAccessController, authorizedUserRole) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const policyIx = yield this.rwaClient.policyEngine.attachPolicy(args);
+            const ixData = policyIx.ixs[0].data;
+            return this.rbacProgram.methods
+                .attachToPolicyEngine(ixData)
+                .accountsStrict({
+                payer: args.payer,
+                user: signer,
+                controllerAuthority: args.authority,
+                assetAccessController,
+                authorizedUserRole: authorizedUserRole || null,
+                policyEngineProgram: rwaTokenSdk.policyEngineProgramId,
+                policyEngine: rwaTokenSdk.getPolicyEnginePda(args.assetMint),
+                systemProgram: web3_js.SystemProgram.programId,
+                eventAuthority: rwaTokenSdk.getPolicyEngineEventAuthority(),
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Asynchronously detaches a policy to the policy account.
+     * @param args - {@link DetachPolicyArgs}
+     * @param signer - User signer public key.
+     * @param assetAccessController - RBAC AssetAccessController account.
+     * @param authorizedUserRole - UserRole authorized to invoke instruction.
+     * @returns A Promise that resolves to the instructions to detach a policy.
+     * */
+    detachPolicy(args, signer, assetAccessController, authorizedUserRole) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const policyIx = yield this.rwaClient.policyEngine.detachPolicy(args);
+            const ixData = policyIx.ixs[0].data;
+            return this.rbacProgram.methods
+                .detachFromPolicyEngine(ixData)
+                .accountsStrict({
+                payer: args.payer,
+                user: signer,
+                controllerAuthority: args.authority,
+                assetAccessController,
+                authorizedUserRole: authorizedUserRole || null,
+                policyEngineProgram: rwaTokenSdk.policyEngineProgramId,
+                policyEngine: rwaTokenSdk.getPolicyEnginePda(args.assetMint),
+                systemProgram: web3_js.SystemProgram.programId,
+                eventAuthority: rwaTokenSdk.getPolicyEngineEventAuthority(),
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Asynchronously changes counters on the policy account.
+     * @param args - {@link ChangeCountersArgs}
+     * @param signer - User signer public key.
+     * @param assetAccessController - RBAC AssetAccessController account.
+     * @param authorizedUserRole - UserRole authorized to invoke instruction.
+     * @returns A Promise that resolves to the instructions to change the counters.
+     * */
+    changeCounters(args, signer, assetAccessController, authorizedUserRole) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const policyIx = yield this.rwaClient.policyEngine.changeCounters(args);
+            const ixData = policyIx.ixs[0].data;
+            return this.rbacProgram.methods
+                .changeCounters(ixData)
+                .accountsStrict({
+                payer: args.payer,
+                user: signer,
+                controllerAuthority: args.authority,
+                assetAccessController,
+                authorizedUserRole: authorizedUserRole || null,
+                policyEngineProgram: rwaTokenSdk.policyEngineProgramId,
+                policyEngine: rwaTokenSdk.getPolicyEnginePda(args.assetMint),
+                systemProgram: web3_js.SystemProgram.programId,
+                eventAuthority: rwaTokenSdk.getPolicyEngineEventAuthority(),
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Asynchronously sets counter values on the policy account.
+     * @param args - {@link SetCountersArgs}
+     * @param signer - User signer public key.
+     * @param assetAccessController - RBAC AssetAccessController account.
+     * @param authorizedUserRole - UserRole authorized to invoke instruction.
+     * @returns A Promise that resolves to the instructions to set the counter values.
+     * */
+    setCounters(args, signer, assetAccessController, authorizedUserRole) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const policyIx = yield this.rwaClient.policyEngine.setCounters(args);
+            const ixData = policyIx.ixs[0].data;
+            return this.rbacProgram.methods
+                .setCounters(ixData)
+                .accountsStrict({
+                payer: args.payer,
+                user: signer,
+                controllerAuthority: args.authority,
+                assetAccessController,
+                authorizedUserRole: authorizedUserRole || null,
+                policyEngineProgram: rwaTokenSdk.policyEngineProgramId,
+                policyEngine: rwaTokenSdk.getPolicyEnginePda(args.assetMint),
+                eventAuthority: rwaTokenSdk.getPolicyEngineEventAuthority(),
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Asynchronously changes counters limits on the policy account.
+     * @param args - {@link ChangeCounterLimitsArgs}
+     * @param signer - User signer public key.
+     * @param assetAccessController - RBAC AssetAccessController account.
+     * @param authorizedUserRole - UserRole authorized to invoke instruction.
+     * @returns A Promise that resolves to the instructions to change the counters limits.
+     * */
+    changeCounterLimits(args, signer, assetAccessController, authorizedUserRole) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const policyIx = yield this.rwaClient.policyEngine.changeCounterLimits(args);
+            const ixData = policyIx.ixs[0].data;
+            return this.rbacProgram.methods
+                .changeCounterLimits(ixData)
+                .accountsStrict({
+                payer: args.payer,
+                user: signer,
+                controllerAuthority: args.authority,
+                assetAccessController,
+                authorizedUserRole: authorizedUserRole || null,
+                policyEngineProgram: rwaTokenSdk.policyEngineProgramId,
+                policyEngine: rwaTokenSdk.getPolicyEnginePda(args.assetMint),
+                systemProgram: web3_js.SystemProgram.programId,
+                eventAuthority: rwaTokenSdk.getPolicyEngineEventAuthority(),
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Asynchronously changes the levels mapping used in Policy Engine.
+     * @param args - {@link ChangeMappingArgs}
+     * @param signer - User signer public key.
+     * @param assetAccessController - RBAC AssetAccessController account.
+     * @param authorizedUserRole - UserRole authorized to invoke instruction.
+     * */
+    changeMapping(args, signer, assetAccessController, authorizedUserRole) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const policyIx = yield this.rwaClient.policyEngine.changeMapping(args);
+            const ixData = policyIx.ixs[0].data;
+            return this.rbacProgram.methods
+                .changeMapping(ixData)
+                .accountsStrict({
+                payer: args.payer,
+                user: signer,
+                controllerAuthority: args.authority,
+                assetAccessController,
+                authorizedUserRole: authorizedUserRole || null,
+                policyEngineProgram: rwaTokenSdk.policyEngineProgramId,
+                policyEngine: rwaTokenSdk.getPolicyEnginePda(args.assetMint),
+                eventAuthority: rwaTokenSdk.getPolicyEngineEventAuthority(),
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Asynchronously changes the issuance policies enforced by Policy Engine.
+     * @param args - {@link ChangeIssuancePoliciesArgs}
+     * @param signer - User signer public key.
+     * @param assetAccessController - RBAC AssetAccessController account.
+     * @param authorizedUserRole - UserRole authorized to invoke instruction.
+     * */
+    changeIssuancePolicies(args, signer, assetAccessController, authorizedUserRole) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const policyIx = yield this.rwaClient.policyEngine.changeIssuancePolicies(args);
+            const ixData = policyIx.ixs[0].data;
+            return this.rbacProgram.methods
+                .changeIssuancePolicies(ixData)
+                .accountsStrict({
+                payer: args.payer,
+                user: signer,
+                controllerAuthority: args.authority,
+                assetAccessController,
+                authorizedUserRole: authorizedUserRole || null,
+                policyEngineProgram: rwaTokenSdk.policyEngineProgramId,
+                policyEngine: rwaTokenSdk.getPolicyEnginePda(args.assetMint),
+                eventAuthority: rwaTokenSdk.getPolicyEngineEventAuthority(),
+            })
+                .instruction();
+        });
+    }
+    addLock(args, signer, assetAccessController, authorizedUserRole) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const policyIx = yield this.rwaClient.policyEngine.addLock(args);
+            const ixData = policyIx.ixs[0].data;
+            return this.rbacProgram.methods
+                .addLock(ixData)
+                .accountsStrict({
+                payer: args.payer,
+                user: signer,
+                controllerAuthority: args.authority,
+                assetAccessController,
+                authorizedUserRole: authorizedUserRole || null,
+                policyEngineProgram: rwaTokenSdk.policyEngineProgramId,
+                policyEngine: rwaTokenSdk.getPolicyEnginePda(args.assetMint),
+                systemProgram: web3_js.SystemProgram.programId,
+                assetMint: new web3_js.PublicKey(args.assetMint),
+                identityRegistry: rwaTokenSdk.getIdentityRegistryPda(args.assetMint),
+                identityAccount: rwaTokenSdk.getIdentityAccountPda(args.assetMint, args.owner),
+                trackerAccount: rwaTokenSdk.getTrackerAccountPda(args.assetMint, args.owner),
+                eventAuthority: rwaTokenSdk.getPolicyEngineEventAuthority(),
+            })
+                .instruction();
+        });
+    }
+    removeLock(args, signer, assetAccessController, authorizedUserRole) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const policyIx = yield this.rwaClient.policyEngine.removeLock(args);
+            const ixData = policyIx.ixs[0].data;
+            return this.rbacProgram.methods
+                .removeLock(ixData)
+                .accountsStrict({
+                payer: args.payer,
+                user: signer,
+                controllerAuthority: args.authority,
+                assetAccessController,
+                authorizedUserRole: authorizedUserRole || null,
+                policyEngineProgram: rwaTokenSdk.policyEngineProgramId,
+                policyEngine: rwaTokenSdk.getPolicyEnginePda(args.assetMint),
+                systemProgram: web3_js.SystemProgram.programId,
+                assetMint: new web3_js.PublicKey(args.assetMint),
+                identityRegistry: rwaTokenSdk.getIdentityRegistryPda(args.assetMint),
+                identityAccount: rwaTokenSdk.getIdentityAccountPda(args.assetMint, args.owner),
+                trackerAccount: rwaTokenSdk.getTrackerAccountPda(args.assetMint, args.owner),
+                eventAuthority: rwaTokenSdk.getPolicyEngineEventAuthority(),
+            })
+                .instruction();
+        });
+    }
+}
+
+/**
+ * Represents the role-based access client for Identity Registry for an RWA.
+ */
+class IdentityRegistry {
+    constructor(rwaClient, rbacProgram) {
+        this.rwaClient = rwaClient;
+        this.rbacProgram = rbacProgram;
+    }
+    /**
+     * Asynchronously generates instructions to setup a non-investor user with an identity account.
+     * @param args - {@link SetupUserArgs}
+     * @param authority - RBAC AssetAccessController ControllerAuthority.
+     * @param assetAccessController - RBAC AssetAccessController account.
+     * @param authorizedUserRole - UserRole authorized to invoke instruction.
+     * @returns A Promise that resolves to the instructions to setup a user.
+     *
+     * It is required for at least a single user to be setup before issuing tokens.
+     */
+    setupUserIxns(args, assetAccessController, authorizedUserRole) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { ixs } = yield this.rwaClient.identityRegistry.setupUserIxns(args);
+            const returnIxs = [];
+            const identityAccountIx = ixs[0];
+            const controllerAuthority = deriveControllerAuthorityPda(assetAccessController);
+            const identityAccount = rwaTokenSdk.getIdentityAccountPda(args.assetMint, args.owner);
+            returnIxs.push(yield this.rbacProgram.methods
+                .createIdentityAccount(identityAccountIx.data)
+                .accountsStrict({
+                payer: args.payer,
+                user: args.signer,
+                controllerAuthority,
+                assetAccessController,
+                authorizedUserRole: authorizedUserRole || null,
+                identityRegistryProgram: rwaTokenSdk.identityRegistryProgramId,
+                identityRegistry: rwaTokenSdk.getIdentityRegistryPda(args.assetMint),
+                identityAccount,
+                walletIdentity: rwaTokenSdk.getWalletIdentityAccountPda(args.assetMint, args.owner),
+                systemProgram: web3_js.SystemProgram.programId,
+                eventAuthority: rwaTokenSdk.getIdentityRegistryEventAuthority(),
+                policyEngineProgram: rwaTokenSdk.policyEngineProgramId,
+                trackerAccount: rwaTokenSdk.getTrackerAccountPda(args.assetMint, args.owner),
+                assetMint: args.assetMint,
+            })
+                .instruction());
+            return {
+                ixs: returnIxs,
+                signers: [],
+            };
+        });
+    }
+    /**
+     * Asynchronously generates instructions to remove a non-investor user with an identity account.
+     * @param args - {@link SetupUserArgs}
+     * @param authority - RBAC AssetAccessController ControllerAuthority.
+     * @param assetAccessController - RBAC AssetAccessController account.
+     * @param authorizedUserRole - UserRole authorized to invoke instruction.
+     * @returns A Promise that resolves to the instructions to setup a user.
+     *
+     * It is required for at least a single user to be setup before issuing tokens.
+     */
+    removeUserIxn(args, assetAccessController, authorizedUserRole) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ix = yield this.rwaClient.identityRegistry.revokeIdentityAccount(args);
+            const identityAccountAddress = rwaTokenSdk.getIdentityAccountPda(args.assetMint, args.owner);
+            const identityAccount = yield rwaTokenSdk.getIdentityAccount(identityAccountAddress, this.rwaClient.provider);
+            const controllerAuthority = deriveControllerAuthorityPda(assetAccessController);
+            const returnIx = yield this.rbacProgram.methods
+                .removeIdentityAccount(ix.data)
+                .accountsStrict({
+                payer: args.payer,
+                user: args.signer,
+                controllerAuthority,
+                assetAccessController,
+                authorizedUserRole: authorizedUserRole || null,
+                identityRegistryProgram: rwaTokenSdk.identityRegistryProgramId,
+                identityRegistry: rwaTokenSdk.getIdentityRegistryPda(args.assetMint),
+                identityAccount: identityAccountAddress,
+                walletIdentity: rwaTokenSdk.getWalletIdentityAccountPda(args.assetMint, args.owner),
+                eventAuthority: rwaTokenSdk.getIdentityRegistryEventAuthority(),
+                identityOwner: identityAccount.owner,
+                policyEngineProgram: rwaTokenSdk.policyEngineProgramId,
+                trackerAccount: rwaTokenSdk.getTrackerAccountPda(args.assetMint, args.owner),
+                assetMint: args.assetMint,
+            })
+                .instruction();
+            return returnIx;
+        });
+    }
+    /**
+     * Asynchronously generates instruction to attach wallet to identity.
+     * @param args - {@link AttachDetachWalletArgs}
+     * @param assetAccessController - RBAC AssetAccessController account.
+     * @param authorizedUserRole - UserRole authorized to invoke instruction.
+     * @returns A Promise that resolves to attach wallet.
+     * */
+    attachWalletToIdentityIxn(args, assetAccessController, authorizedUserRole) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const controllerAuthority = deriveControllerAuthorityPda(assetAccessController);
+            const identityProgram = rwaTokenSdk.getIdentityRegistryProgram(this.rwaClient.provider);
+            const identityRegistry = rwaTokenSdk.getIdentityRegistryPda(args.assetMint);
+            const identityAccount = rwaTokenSdk.getIdentityAccountPda(args.assetMint, args.owner);
+            rwaTokenSdk.getIdentityAccountPda(args.assetMint, args.wallet);
+            const walletIdentity = rwaTokenSdk.getWalletIdentityAccountPda(args.assetMint, args.wallet.toString());
+            const ix = yield identityProgram.methods
+                .attachWalletToIdentity(new web3_js.PublicKey(args.wallet))
+                .accountsStrict({
+                payer: args.payer,
+                authority: controllerAuthority,
+                identityAccount,
+                identityRegistry,
+                assetMint: args.assetMint,
+                walletIdentity,
+                systemProgram: web3_js.SystemProgram.programId,
+                eventAuthority: rwaTokenSdk.getIdentityRegistryEventAuthority(),
+                program: rwaTokenSdk.identityRegistryProgramId,
+            })
+                .instruction();
+            return this.rbacProgram.methods
+                .attachWalletToIdentity(ix.data)
+                .accountsStrict({
+                payer: args.payer,
+                user: args.signer,
+                controllerAuthority,
+                assetAccessController,
+                authorizedUserRole: authorizedUserRole || null,
+                identityRegistryProgram: rwaTokenSdk.identityRegistryProgramId,
+                identityAccount,
+                identityRegistry,
+                assetMint: args.assetMint,
+                walletIdentity,
+                systemProgram: web3_js.SystemProgram.programId,
+                eventAuthority: rwaTokenSdk.getIdentityRegistryEventAuthority(),
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Asynchronously generates instruction to detach wallet from identity.
+     * @param args - {@link AttachDetachWalletArgs}
+     * @param assetAccessController - RBAC AssetAccessController account.
+     * @param authorizedUserRole - UserRole authorized to invoke instruction.
+     * @returns A Promise that resolves to detach wallet.
+     * */
+    detachWalletFromIdentityIxn(args, assetAccessController, authorizedUserRole) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const controllerAuthority = deriveControllerAuthorityPda(assetAccessController);
+            const identityProgram = rwaTokenSdk.getIdentityRegistryProgram(this.rwaClient.provider);
+            const identityRegistry = rwaTokenSdk.getIdentityRegistryPda(args.assetMint);
+            const identityAccount = rwaTokenSdk.getIdentityAccountPda(args.assetMint, args.owner);
+            const walletIdentity = rwaTokenSdk.getWalletIdentityAccountPda(args.assetMint, args.wallet.toString());
+            const tokenAccount = splToken.getAssociatedTokenAddressSync(new web3_js.PublicKey(args.assetMint), new web3_js.PublicKey(args.wallet), false, splToken.TOKEN_2022_PROGRAM_ID);
+            const ix = yield identityProgram.methods
+                .detachWalletFromIdentity()
+                .accountsStrict({
+                payer: args.payer,
+                authority: controllerAuthority,
+                walletIdentity,
+                identityAccount,
+                identityRegistry,
+                eventAuthority: rwaTokenSdk.getIdentityRegistryEventAuthority(),
+                program: rwaTokenSdk.identityRegistryProgramId,
+                tokenAccount: tokenAccount,
+                assetMint: args.assetMint,
+            })
+                .instruction();
+            return this.rbacProgram.methods
+                .detachWalletFromIdentity(ix.data)
+                .accountsStrict({
+                payer: args.payer,
+                user: args.signer,
+                controllerAuthority,
+                assetAccessController,
+                authorizedUserRole: authorizedUserRole || null,
+                identityRegistryProgram: rwaTokenSdk.identityRegistryProgramId,
+                walletIdentity,
+                identityAccount,
+                identityRegistry,
+                eventAuthority: rwaTokenSdk.getIdentityRegistryEventAuthority(),
+                tokenAccount: tokenAccount,
+                assetMint: args.assetMint,
+            })
+                .instruction();
+        });
+    }
+}
+
+/**
+ * Role-based access client for accessing Identity Metadata Registry.
+ */
+class IdentityMetadataRegistry {
+    constructor(rwaClient, rbacProgram, imrProgram) {
+        this.rwaClient = rwaClient;
+        this.rbacProgram = rbacProgram;
+        this.imrProgram = imrProgram;
+    }
+    /**
+     * Parses inner instructions data field for array of events emitted by program using CPI Events.
+     * @param ixs - Array of CompiledInstruction from a transaction inner instructions.
+     * @returns Array of Events
+     * */
+    parseEvents(ixs) {
+        const eventCoder = this.imrProgram.coder.events;
+        const events = ixs
+            .map(({ data }) => {
+            try {
+                const buffer = Buffer.from(anchor.utils.bytes.bs58.decode(data));
+                const event = eventCoder.decode(anchor.utils.bytes.base64.encode(buffer.slice(8)));
+                return event;
+            }
+            catch (err) {
+                console.error("Error decoding events", err);
+            }
+        })
+            .filter((v) => v != null);
+        return events;
+    }
+    /**
+     * Asynchronously generates instructions to setup an investor.
+     * @param args - {@link SetupInvestorArgs}
+     * @param authority - RBAC AssetAccessController ControllerAuthority.
+     * @param assetAccessController - RBAC AssetAccessController account.
+     * @param authorizedUserRole - UserRole authorized to invoke instruction.
+     * @returns A Promise that resolves to the instructions to setup an investor.
+     *
+     * It is required for at least a single user to be setup before issuing tokens.
+     */
+    setupUserIxns(args, assetAccessController, authorizedUserRole) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const returnIxs = [];
+            const controllerAuthority = deriveControllerAuthorityPda(assetAccessController);
+            const identityRegistry = rwaTokenSdk.getIdentityRegistryPda(args.assetMint);
+            const investor = deriveInvestorPda(args.investorId, identityRegistry);
+            const identityAccount = rwaTokenSdk.getIdentityAccountPda(args.assetMint, investor.toString() // Investor is owner of IdentityAccount
+            );
+            const assetMintKey = new web3_js.PublicKey(args.assetMint);
+            const registerIx = yield this.imrProgram.methods
+                .registerInvestor(args.investorId, args.collisionHash, args.levels[0], args.expiries[0], args.country, args.proofHashes[0])
+                .accountsStrict({
+                payer: args.payer,
+                authority: controllerAuthority,
+                investor,
+                identityRegistryProgram: rwaTokenSdk.identityRegistryProgramId,
+                identityRegistry,
+                identityAccount,
+                walletIdentity: rwaTokenSdk.getWalletIdentityAccountPda(args.assetMint, investor.toString() // Investor is owner of IdentityAccount
+                ),
+                systemProgram: web3_js.SystemProgram.programId,
+                eventAuthority: getEventAuthority(IMR_PROGRAM),
+                eventAuthorityIdentityRegistry: rwaTokenSdk.getIdentityRegistryEventAuthority(),
+                program: rwaTokenSdk.identityRegistryProgramId,
+                policyEngineProgram: rwaTokenSdk.policyEngineProgramId,
+                trackerAccount: rwaTokenSdk.getTrackerAccountPda(args.assetMint, investor.toString()),
+                assetMint: assetMintKey,
+            })
+                .instruction();
+            returnIxs.push(yield this.rbacProgram.methods
+                .registerInvestor(registerIx.data)
+                .accountsStrict({
+                payer: args.payer,
+                user: args.signer,
+                controllerAuthority,
+                assetAccessController,
+                authorizedUserRole: authorizedUserRole || null,
+                identityMetadataRegistryProgram: IMR_PROGRAM,
+                investor,
+                identityRegistryProgram: rwaTokenSdk.identityRegistryProgramId,
+                identityRegistry,
+                identityAccount,
+                walletIdentity: rwaTokenSdk.getWalletIdentityAccountPda(args.assetMint, investor.toString()),
+                systemProgram: web3_js.SystemProgram.programId,
+                eventAuthorityIdentityMetadataRegistry: getEventAuthority(IMR_PROGRAM),
+                eventAuthorityIdentityRegistry: rwaTokenSdk.getIdentityRegistryEventAuthority(),
+                policyEngineProgram: rwaTokenSdk.policyEngineProgramId,
+                trackerAccount: rwaTokenSdk.getTrackerAccountPda(args.assetMint, investor.toString()),
+                assetMint: assetMintKey,
+            })
+                .instruction());
+            if (args.levels.length > 1) {
+                returnIxs.push(yield this.addLevels({
+                    payer: args.payer,
+                    signer: args.signer,
+                    investorId: args.investorId,
+                    assetMint: args.assetMint,
+                    levels: args.levels.slice(1),
+                    expiries: args.expiries.slice(1),
+                    proofHashes: args.proofHashes.slice(1),
+                    enforceLimits: args.enforceLimits,
+                }, assetAccessController, authorizedUserRole));
+            }
+            return {
+                ixs: returnIxs,
+                signers: [],
+            };
+        });
+    }
+    /**
+     * Asynchronously add levels to investor.
+     * @param args - {@link AddLevelsArgs}
+     * @param assetAccessController - RBAC AssetAccessController account.
+     * @param authorizedUserRole - UserRole authorized to invoke instruction.
+     * @returns A Promise that resolves to the instructions to add levels.
+     * */
+    addLevels(args, assetAccessController, authorizedUserRole) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const controllerAuthority = deriveControllerAuthorityPda(assetAccessController);
+            const identityRegistry = rwaTokenSdk.getIdentityRegistryPda(args.assetMint);
+            const investor = deriveInvestorPda(args.investorId, identityRegistry);
+            const identityAccount = rwaTokenSdk.getIdentityAccountPda(args.assetMint, investor.toString());
+            const trackerAccount = rwaTokenSdk.getTrackerAccountPda(args.assetMint, investor.toString());
+            const ix = yield this.imrProgram.methods
+                .addLevels(Buffer.from(args.levels), args.expiries, args.proofHashes, (_a = args.enforceLimits) !== null && _a !== void 0 ? _a : false)
+                .accountsStrict({
+                payer: args.payer,
+                authority: controllerAuthority,
+                investor,
+                identityRegistryProgram: rwaTokenSdk.identityRegistryProgramId,
+                identityRegistry,
+                identityAccount,
+                systemProgram: web3_js.SystemProgram.programId,
+                policyEngineProgram: rwaTokenSdk.policyEngineProgramId,
+                policyEngine: rwaTokenSdk.getPolicyEnginePda(args.assetMint),
+                trackerAccount,
+                assetMint: args.assetMint,
+                eventAuthorityIdentityRegistry: rwaTokenSdk.getIdentityRegistryEventAuthority(),
+                eventAuthority: getEventAuthority(IMR_PROGRAM),
+                program: IMR_PROGRAM,
+            })
+                .instruction();
+            return this.rbacProgram.methods
+                .addLevels(ix.data)
+                .accountsStrict({
+                payer: args.payer,
+                user: args.signer,
+                controllerAuthority,
+                assetAccessController,
+                authorizedUserRole: authorizedUserRole || null,
+                identityMetadataRegistryProgram: IMR_PROGRAM,
+                investor,
+                identityRegistryProgram: rwaTokenSdk.identityRegistryProgramId,
+                identityRegistry,
+                identityAccount,
+                systemProgram: web3_js.SystemProgram.programId,
+                policyEngineProgram: rwaTokenSdk.policyEngineProgramId,
+                policyEngine: rwaTokenSdk.getPolicyEnginePda(args.assetMint),
+                trackerAccount,
+                assetMint: args.assetMint,
+                eventAuthorityIdentityRegistry: rwaTokenSdk.getIdentityRegistryEventAuthority(),
+                eventAuthorityIdentityMetadataRegistry: getEventAuthority(IMR_PROGRAM),
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Asynchronously change country for the Investor.
+     * @param args - {@link ChangeCountryArgs}
+     * @param assetAccessController - RBAC AssetAccessController account.
+     * @param authorizedUserRole - UserRole authorized to invoke instruction.
+     * @returns A Promise that resolves to the instructions to change the country.
+     * */
+    changeCountry(args, assetAccessController, authorizedUserRole) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const controllerAuthority = deriveControllerAuthorityPda(assetAccessController);
+            const identityRegistry = rwaTokenSdk.getIdentityRegistryPda(args.assetMint);
+            const investor = deriveInvestorPda(args.investorId, identityRegistry);
+            const identityAccount = rwaTokenSdk.getIdentityAccountPda(args.assetMint, investor.toString());
+            const trackerAccount = rwaTokenSdk.getTrackerAccountPda(args.assetMint, investor.toString());
+            const ix = yield this.imrProgram.methods
+                .changeCountry(args.country, (_a = args.enforceLimits) !== null && _a !== void 0 ? _a : false)
+                .accountsStrict({
+                payer: args.payer,
+                authority: controllerAuthority,
+                investor,
+                identityRegistryProgram: rwaTokenSdk.identityRegistryProgramId,
+                identityRegistry,
+                identityAccount,
+                policyEngineProgram: rwaTokenSdk.policyEngineProgramId,
+                policyEngine: rwaTokenSdk.getPolicyEnginePda(args.assetMint),
+                trackerAccount,
+                assetMint: args.assetMint,
+                eventAuthorityIdentityRegistry: rwaTokenSdk.getIdentityRegistryEventAuthority(),
+            })
+                .instruction();
+            return this.rbacProgram.methods
+                .changeCountry(ix.data)
+                .accountsStrict({
+                payer: args.payer,
+                user: args.signer,
+                controllerAuthority,
+                assetAccessController,
+                authorizedUserRole: authorizedUserRole || null,
+                identityMetadataRegistryProgram: IMR_PROGRAM,
+                investor,
+                identityRegistryProgram: rwaTokenSdk.identityRegistryProgramId,
+                identityRegistry,
+                identityAccount,
+                policyEngineProgram: rwaTokenSdk.policyEngineProgramId,
+                policyEngine: rwaTokenSdk.getPolicyEnginePda(args.assetMint),
+                trackerAccount,
+                assetMint: args.assetMint,
+                eventAuthorityIdentityRegistry: rwaTokenSdk.getIdentityRegistryEventAuthority(),
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Asynchronously remove levels from an investor.
+     * @param args - {@link RemoveLevelsArgs}
+     * @param assetAccessController - RBAC AssetAccessController account.
+     * @param authorizedUserRole - UserRole authorized to invoke instruction.
+     * @returns A Promise that resolves to the instructions to remove levels.
+     * */
+    removeLevels(args, assetAccessController, authorizedUserRole) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const controllerAuthority = deriveControllerAuthorityPda(assetAccessController);
+            const identityRegistry = rwaTokenSdk.getIdentityRegistryPda(args.assetMint);
+            const investor = deriveInvestorPda(args.investorId, identityRegistry);
+            const identityAccount = rwaTokenSdk.getIdentityAccountPda(args.assetMint, investor.toString());
+            const trackerAccount = rwaTokenSdk.getTrackerAccountPda(args.assetMint, investor.toString());
+            const ix = yield this.imrProgram.methods
+                .removeLevels(Buffer.from(args.levels), (_a = args.enforceLimits) !== null && _a !== void 0 ? _a : false)
+                .accountsStrict({
+                payer: args.payer,
+                authority: controllerAuthority,
+                investor,
+                identityRegistryProgram: rwaTokenSdk.identityRegistryProgramId,
+                identityRegistry,
+                identityAccount,
+                systemProgram: web3_js.SystemProgram.programId,
+                policyEngineProgram: rwaTokenSdk.policyEngineProgramId,
+                policyEngine: rwaTokenSdk.getPolicyEnginePda(args.assetMint),
+                trackerAccount,
+                assetMint: args.assetMint,
+                eventAuthorityIdentityRegistry: rwaTokenSdk.getIdentityRegistryEventAuthority(),
+            })
+                .instruction();
+            return this.rbacProgram.methods
+                .removeLevels(ix.data)
+                .accountsStrict({
+                payer: args.payer,
+                user: args.signer,
+                controllerAuthority,
+                assetAccessController,
+                authorizedUserRole: authorizedUserRole || null,
+                identityMetadataRegistryProgram: IMR_PROGRAM,
+                investor,
+                identityRegistryProgram: rwaTokenSdk.identityRegistryProgramId,
+                identityRegistry,
+                identityAccount,
+                systemProgram: web3_js.SystemProgram.programId,
+                policyEngineProgram: rwaTokenSdk.policyEngineProgramId,
+                policyEngine: rwaTokenSdk.getPolicyEnginePda(args.assetMint),
+                trackerAccount,
+                assetMint: args.assetMint,
+                eventAuthorityIdentityRegistry: rwaTokenSdk.getIdentityRegistryEventAuthority(),
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Asynchronously remove an investor.
+     * @param args - {@link RemoveLevelsArgs}
+     * @param assetAccessController - RBAC AssetAccessController account.
+     * @param authorizedUserRole - UserRole authorized to invoke instruction.
+     * @returns A Promise that resolves to the instructions to remove an investor.
+     * */
+    removeInvestor(args, assetAccessController, authorizedUserRole) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const controllerAuthority = deriveControllerAuthorityPda(assetAccessController);
+            const identityRegistry = rwaTokenSdk.getIdentityRegistryPda(args.assetMint);
+            const investor = deriveInvestorPda(args.investorId, identityRegistry);
+            const identityAccount = rwaTokenSdk.getIdentityAccountPda(args.assetMint, investor.toString());
+            return this.rbacProgram.methods
+                .removeInvestor()
+                .accountsStrict({
+                payer: args.payer,
+                user: args.signer,
+                controllerAuthority,
+                assetAccessController,
+                authorizedUserRole: authorizedUserRole || null,
+                identityMetadataRegistryProgram: IMR_PROGRAM,
+                investor,
+                identityRegistryProgram: rwaTokenSdk.identityRegistryProgramId,
+                identityRegistry,
+                identityAccount,
+                walletIdentity: rwaTokenSdk.getWalletIdentityAccountPda(args.assetMint, investor.toString()),
+                policyEngineProgram: rwaTokenSdk.policyEngineProgramId,
+                trackerAccount: rwaTokenSdk.getTrackerAccountPda(args.assetMint, investor.toString()),
+                eventAuthorityIdentityMetadataRegistry: getEventAuthority(IMR_PROGRAM),
+                eventAuthorityIdentityRegistry: rwaTokenSdk.getIdentityRegistryEventAuthority(),
+                assetMint: args.assetMint,
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Asynchronously attach a wallet to IdentityAccouont for the Investor.
+     * @param args - {@link AttachWalletByInvestorArgs}
+     * */
+    attachWalletByInvestor(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const identityRegistry = rwaTokenSdk.getIdentityRegistryPda(args.assetMint);
+            const investor = deriveInvestorPda(args.investorId, identityRegistry);
+            const identityAccount = rwaTokenSdk.getIdentityAccountPda(args.assetMint, investor.toString());
+            return this.imrProgram.methods
+                .attachWalletByInvestor(args.newWallet)
+                .accountsStrict({
+                payer: args.payer,
+                wallet: args.signer,
+                investor,
+                walletIdentity: rwaTokenSdk.getWalletIdentityAccountPda(args.assetMint, args.signer),
+                identityRegistryProgram: rwaTokenSdk.identityRegistryProgramId,
+                newWalletIdentity: rwaTokenSdk.getWalletIdentityAccountPda(args.assetMint, args.newWallet.toString()),
+                identityAccount,
+                identityRegistry,
+                assetMint: args.assetMint,
+                systemProgram: web3_js.SystemProgram.programId,
+                eventAuthorityIdentityRegistry: rwaTokenSdk.getIdentityRegistryEventAuthority(),
+            })
+                .instruction();
+        });
+    }
+}
+
+class RwaRbacClient {
+    constructor(config, provider) {
+        this.rwaClient = new rwaTokenSdk.RwaClient(config, provider);
+        this.provider = provider;
+        this.rbacProgram = new anchor.Program(rbacIDL, this.provider);
+        this.assetController = new AssetController(this.rwaClient, this.rbacProgram);
+        this.policyEngine = new PolicyEngine(this.rwaClient, this.rbacProgram);
+        this.identityRegistry = new IdentityRegistry(this.rwaClient, this.rbacProgram);
+        this.identityMetadataRegistry = new IdentityMetadataRegistry(this.rwaClient, this.rbacProgram, new anchor.Program(imrIDL, this.provider));
+    }
+    /**
+     * Parses inner instructions data field for array of events emitted by program using CPI Events.
+     * @param ixs - Array of CompiledInstruction from a transaction inner instructions.
+     * @returns Array of Events
+     * */
+    parseEvents(ixs) {
+        const eventCoder = this.rbacProgram.coder.events;
+        const events = ixs
+            .map(({ data }) => {
+            try {
+                const buffer = Buffer.from(anchor.utils.bytes.bs58.decode(data));
+                const event = eventCoder.decode(anchor.utils.bytes.base64.encode(buffer.slice(8)));
+                return event;
+            }
+            catch (err) {
+                console.error("Error decoding events", err);
+            }
+        })
+            .filter((v) => v != null);
+        return events;
+    }
+    /**
+     * Asynchronously generates instruction to create AssetAccessController for an organization.
+     * @param args - {@link CreateControllerArgs}
+     * @returns A Promise that resolves to the instruction to create AssetAccessController.
+     */
+    createAssetAccessControllerIxn(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const assetAccessController = deriveAssetAccessControllerPda(args.assetMint);
+            const assetAccessControllerAuthority = deriveControllerAuthorityPda(assetAccessController);
+            const cpiInstruction = yield this.assetController.setupNewRegistry({
+                decimals: args.decimals,
+                authority: assetAccessControllerAuthority.toString(),
+                name: args.name,
+                uri: args.uri,
+                symbol: args.symbol,
+                interestRate: args.interestRate,
+                assetMint: args.assetMint.toString(),
+                payer: args.payer.toString(),
+            });
+            return this.rbacProgram.methods
+                .createController(cpiInstruction.data)
+                .accountsStrict({
+                payer: args.payer,
+                admin: args.admin,
+                assetAccessController,
+                assetAccessControllerAuthority,
+                assetMint: args.assetMint,
+                assetController: cpiInstruction.keys[2].pubkey,
+                extraMetasAccount: cpiInstruction.keys[4].pubkey,
+                policyEngineAccount: cpiInstruction.keys[5].pubkey,
+                identityRegistryAccount: cpiInstruction.keys[6].pubkey,
+                policyEngineProgram: cpiInstruction.keys[7].pubkey,
+                identityRegistryProgram: cpiInstruction.keys[8].pubkey,
+                assetControllerProgram: cpiInstruction.programId,
+                tokenProgram: splToken.TOKEN_2022_PROGRAM_ID,
+                systemProgram: web3_js.SystemProgram.programId,
+                assetControllerEventAuthority: rwaTokenSdk.getAssetControllerEventAuthority(),
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Asynchronously generates instruction to update admin key on AssetAccessController.
+     * @param args - {@link UpdateControllerAdminArgs}
+     * @returns A Promise that resolves to the instruction to update admin on AssetAccessController.
+     */
+    updateControllerAdminIxn(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.rbacProgram.methods
+                .updateControllerAdmin(args.newAdmin)
+                .accountsStrict({
+                admin: args.admin,
+                assetAccessController: args.assetAccessController,
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Asynchronously generates instruction to create a UserRole for an AssetAccessController.
+     * @param args - {@link SetupUserRoleArgs}
+     * @returns A Promise that resolves to the instruction to create UserRole.
+     */
+    createUserRoleIxn(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Fetch controller to get next UserRole id.
+            const controller = yield this.rbacProgram.account.assetAccessController.fetch(args.assetAccessController);
+            return this.rbacProgram.methods
+                .createUserRole(args.name, new anchor.BN(args.allowedAdminIxs), new anchor.BN(args.allowedMediciIxs), args.isMasterRole || false)
+                .accountsStrict({
+                payer: args.payer,
+                user: args.user,
+                newUserRole: deriveUserRolePda(controller.userRolesCount.addn(1), args.assetAccessController),
+                authorizedUserRole: args.authorizedUserRole || null,
+                assetAccessController: args.assetAccessController,
+                systemProgram: web3_js.SystemProgram.programId,
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Asynchronously generates instruction to modify UserRole.
+     * @param args - {@link ModifyUserRoleArgs}
+     * @returns A Promise that resolves to the instruction to modify UserRole.
+     */
+    modifyUserRoleIxn(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.rbacProgram.methods
+                .modifyUserRole(args.name, new anchor.BN(args.allowedAdminIxs), new anchor.BN(args.allowedMediciIxs))
+                .accountsStrict({
+                user: args.user,
+                userRole: args.userRole,
+                assetAccessController: args.assetAccessController,
+                authorizedUserRole: args.authorizedUserRole || null,
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Asynchronously generates instruction to delete UserRole.
+     * @param args - {@link DeleteUserRoleArgs}
+     * @returns A Promise that resolves to the instruction to delete UserRole.
+     */
+    deleteUserRoleIxn(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.rbacProgram.methods
+                .deleteUserRole()
+                .accountsStrict({
+                receiver: args.receiver,
+                user: args.user,
+                userRole: args.userRole,
+                assetAccessController: args.assetAccessController,
+                authorizedUserRole: args.authorizedUserRole || null,
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Asynchronously generates instruction to assign users to a UserRole.
+     * @param args - {@link AssignUserRoleArgs}
+     * @returns A Promise that resolves to the instruction to assign UserRole.
+     */
+    assignUserRoleIxn(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.rbacProgram.methods
+                .assignUserRole(args.usersToAssign)
+                .accountsStrict({
+                payer: args.payer,
+                user: args.user,
+                userRole: args.userRole,
+                authorizedUserRole: args.authorizedUserRole || null,
+                assetAccessController: args.assetAccessController,
+                systemProgram: web3_js.SystemProgram.programId,
+                eventAuthority: getEventAuthority(RBAC_PROGRAM),
+                program: RBAC_PROGRAM,
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Asynchronously generates instruction to remove users from a UserRole.
+     * @param args - {@link RemoveUserRoleArgs}
+     * @returns A Promise that resolves to the instruction to remove users from a UserRole.
+     */
+    removeUserRoleIxn(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.rbacProgram.methods
+                .removeUserRole(args.usersToRemove)
+                .accountsStrict({
+                user: args.user,
+                userRole: args.userRole,
+                authorizedUserRole: args.authorizedUserRole || null,
+                assetAccessController: args.assetAccessController,
+                eventAuthority: getEventAuthority(RBAC_PROGRAM),
+                program: RBAC_PROGRAM,
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Asynchronously generates instruction to withdraw excess rent from ControllerAuthority.
+     * @param args - {@link WithdrawExcessRentArgs}
+     * @returns A Promise that resolves to the instruction to withdraw excess rent from ControllerAuthority.
+     */
+    withdrawExcessRentIxn(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.rbacProgram.methods
+                .withdrawExcessRent()
+                .accountsStrict({
+                receiver: args.receiver,
+                user: args.admin,
+                controllerAuthority: args.controllerAuthority,
+                assetAccessController: args.assetAccessController,
+                systemProgram: web3_js.SystemProgram.programId,
+                authorizedUserRole: args.authorizedUserRole || null,
+            })
+                .instruction();
+        });
+    }
+    /**
+     * Asynchronously generates instruction to set lookup table address field in the AssetAccessController.
+     * @param args - {@link SetLookuptableAddressArgs}
+     * @returns A Promise that resolves to the instruction to set lookup table address.
+     */
+    setLookuptableAddressIxn(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.rbacProgram.methods
+                .setLutAddress()
+                .accountsStrict({
+                user: args.signer,
+                assetAccessController: args.assetAccessController,
+                authorizedUserRole: args.authorizedUserRole || null,
+                lutAddress: args.lutAddress,
+            })
+                .instruction();
+        });
+    }
+}
+
+/**
+ * Combines one ore more flag enums into a single combination flag.
+ * @returns Number
+ */
+const computeFlags = (...flags) => {
+    return flags.reduce((accumulator, flag) => accumulator | flag, 0);
+};
+
+exports.AssetController = AssetController;
+exports.IMR_PROGRAM = IMR_PROGRAM;
+exports.IdentityMetadataRegistry = IdentityMetadataRegistry;
+exports.IdentityRegistry = IdentityRegistry;
+exports.PolicyEngine = PolicyEngine;
+exports.RBAC_PROGRAM = RBAC_PROGRAM;
+exports.RwaImrIdl = rwa_imr;
+exports.RwaRbacClient = RwaRbacClient;
+exports.RwaRbacIdl = rwa_rbac;
+exports.TL_PROGRAM = TL_PROGRAM;
+exports.computeFlags = computeFlags;
+exports.deriveAssetAccessControllerPda = deriveAssetAccessControllerPda;
+exports.deriveControllerAuthorityPda = deriveControllerAuthorityPda;
+exports.deriveInvestorLocks = deriveInvestorLocks;
+exports.deriveInvestorPda = deriveInvestorPda;
+exports.deriveLockedTokenAccount = deriveLockedTokenAccount;
+exports.deriveUserRolePda = deriveUserRolePda;
+exports.getEventAuthority = getEventAuthority;