@glamsystems/glam-sdk 0.2.0-alpha.3 → 1.0.0-alpha.0

package/index.cjs.js

@@ -22352,28 +22352,6 @@ const JUPSOL_STAKE_POOL = new web3_js.PublicKey("8VpRhuxa7sUUepdY3kQiTmX9rS5vx4W
 /**
  * Referrers
  */ const GLAM_REFERRER = new web3_js.PublicKey("GLAMrG37ZqioqvzBNQGCfCUueDz3tsr7MwMFyRk9PS89");
-/**
- * Integration program mapping
- */ const INTEGRATION_MAPPING = {
-    GM1NtvvnSXUptTrMCqbogAdZJydZSNv98DoU5AZVLmGh: {
-        "0000000000000001": "GLAM Mint Protocol"
-    },
-    G1NTcMDYgNLpDwgnrpSZvoSKQuR9NXG7S3DmtNQCDmrK: {
-        "0000000000000001": "CCTP"
-    },
-    G1NTsQ36mjPe89HtPYqxKsjY5HmYsDR6CbD2gd2U2pta: {
-        "0000000000000001": "Token"
-    },
-    G1NTdrBmBpW43msRQmsf7qXSw3MFBNaqJcAkGiRmRq2F: {
-        "0000000000000001": "Drift Protocol",
-        "0000000000000010": "Drift Vaults"
-    },
-    G1NTkDEUR3pkEqGCKZtmtmVzCUEdYa86pezHkwYbLyde: {
-        "0000000000000001": "Kamino Lending",
-        "0000000000000010": "Kamino Vaults",
-        "0000000000000100": "Kamino Farms"
-    }
-};
 /**
  * CCTP domain to chain name mapping
  */ const CCTP_DOMAIN_MAPPING = {
@@ -22405,66 +22383,6 @@ const JUPSOL_STAKE_POOL = new web3_js.PublicKey("8VpRhuxa7sUUepdY3kQiTmX9rS5vx4W
     3: "Exponent Market"
 };
 // Permission mappings for each protocol - maps bit positions to permission names
-const PERMISSION_MAPPINGS = {
-    // Kamino integration program
-    G1NTkDEUR3pkEqGCKZtmtmVzCUEdYa86pezHkwYbLyde: {
-        // Kamino Lending (protocol bitmask: 0000000000000001)
-        "0000000000000001": {
-            0: "Init",
-            1: "Deposit",
-            2: "Withdraw",
-            3: "Borrow",
-            4: "Repay"
-        },
-        // Kamino Vaults (protocol bitmask: 0000000000000010)
-        "0000000000000010": {
-            0: "Deposit",
-            1: "Withdraw"
-        },
-        // Kamino Farms (protocol bitmask: 0000000000000100)
-        "0000000000000100": {
-            0: "Stake",
-            1: "Unstake",
-            2: "HarvestReward"
-        }
-    },
-    // Drift integration program
-    G1NTdrBmBpW43msRQmsf7qXSw3MFBNaqJcAkGiRmRq2F: {
-        // Drift Protocol (protocol bitmask: 0000000000000001)
-        "0000000000000001": {
-            0: "InitUser",
-            1: "UpdateUser",
-            2: "DeleteUser",
-            3: "Deposit",
-            4: "Withdraw",
-            5: "Borrow",
-            6: "CreateModifyOrders",
-            7: "CancelOrders",
-            8: "PerpMarkets",
-            9: "SpotMarkets"
-        },
-        // Drift Vaults (protocol bitmask: 0000000000000010)
-        "0000000000000010": {
-            0: "Deposit",
-            1: "Withdraw"
-        }
-    },
-    // Token integration program
-    G1NTsQ36mjPe89HtPYqxKsjY5HmYsDR6CbD2gd2U2pta: {
-        // Token (protocol bitmask: 0000000000000001)
-        "0000000000000001": {
-            0: "Transfer"
-        }
-    },
-    // CCTP integration program
-    G1NTcMDYgNLpDwgnrpSZvoSKQuR9NXG7S3DmtNQCDmrK: {
-        // CCTP (protocol bitmask: 0000000000000001)
-        "0000000000000001": {
-            0: "Transfer"
-        }
-    }
-};
-// Permission mappings for each protocol - maps bit positions to permission names
 const PROTOCOLS_AND_PERMISSIONS = {
     // Self integration
     GLAMpaME8wdTEzxtiYEAa5yD8fZbxZiz2hNtV58RZiEz: {
@@ -22494,16 +22412,22 @@ const PROTOCOLS_AND_PERMISSIONS = {
     // GLAM mint
     GM1NtvvnSXUptTrMCqbogAdZJydZSNv98DoU5AZVLmGh: {
         "0000000000000001": {
-            name: "GLAM Mint",
+            name: "Glam Mint",
             permissions: {
-                [1 << 0]: "Mint"
+                [1 << 0]: "MintTokens",
+                [1 << 1]: "BurnTokens",
+                [1 << 2]: "ForceTransfer",
+                [1 << 3]: "SetTokenAccountState",
+                [1 << 4]: "ClaimFees",
+                [1 << 5]: "Fulfill",
+                [1 << 6]: "EmergencyUpdate"
             }
         }
     },
     // Kamino integration program
     G1NTkDEUR3pkEqGCKZtmtmVzCUEdYa86pezHkwYbLyde: {
         "0000000000000001": {
-            name: "Kamino Lending",
+            name: "Kamino Lend",
             permissions: {
                 [1 << 0]: "Init",
                 [1 << 1]: "Deposit",
@@ -22556,7 +22480,7 @@ const PROTOCOLS_AND_PERMISSIONS = {
     // Token integration program
     G1NTsQ36mjPe89HtPYqxKsjY5HmYsDR6CbD2gd2U2pta: {
         "0000000000000001": {
-            name: "Token",
+            name: "Spl Token",
             permissions: {
                 [1 << 0]: "Transfer"
             }
@@ -22572,6 +22496,33 @@ const PROTOCOLS_AND_PERMISSIONS = {
         }
     }
 };
+/**
+ * (Program ID, Bitflag) -> Protocol Name
+ */ const PROTOCOL_NAME_BY_PROGRAM_AND_BITFLAG = (()=>{
+    const mapping = {};
+    Object.entries(PROTOCOLS_AND_PERMISSIONS).forEach(([programId, protocols])=>{
+        mapping[programId] = {};
+        Object.entries(protocols).forEach(([bitflag, protocol])=>{
+            mapping[programId][bitflag] = protocol.name;
+        });
+    });
+    return mapping;
+})();
+/**
+ * Protocol Name -> (Program ID, Bitflag)
+ */ const PROGRAM_AND_BITFLAG_BY_PROTOCOL_NAME = (()=>{
+    const mapping = {};
+    Object.entries(PROTOCOLS_AND_PERMISSIONS).forEach(([programId, protocols])=>{
+        Object.entries(protocols).forEach(([bitflag, protocol])=>{
+            const name = protocol.name.replace(" ", "");
+            mapping[name] = [
+                programId,
+                bitflag
+            ];
+        });
+    });
+    return mapping;
+})();
 
 // Example response from Helius:
 // {
@@ -22668,7 +22619,7 @@ async function getProgramAccountsWithRetry(connection, programId, filters) {
             await new Promise((resolve)=>setTimeout(resolve, delayMs * attempt));
         }
     }
-    throw new Error(`Failed after ${maxRetries} attempts. Last error: ${lastError.message}`);
+    throw new Error(`Failed after ${maxRetries} attempts. Last error: ${lastError?.message || "Unknown error"}`);
 }
 /**
  * Fetches all the token accounts owned by the specified pubkey.
@@ -23076,10 +23027,32 @@ MintPolicy._layout = borsh.struct([
     borsh.option(borsh.vec(borsh.publicKey()), "allowlist"),
     borsh.option(borsh.vec(borsh.publicKey()), "blocklist")
 ]);
+class JupiterSwapPolicy {
+    static decode(buffer) {
+        const policy = JupiterSwapPolicy._layout.decode(buffer);
+        return new JupiterSwapPolicy(policy.maxSlippageBps, policy.swapAllowlist);
+    }
+    encode() {
+        const swapAllowlistSize = this.swapAllowlist ? 1 + 4 + this.swapAllowlist.length * 32 : 1;
+        const totalSize = 4 + swapAllowlistSize;
+        const buffer = Buffer.alloc(totalSize);
+        JupiterSwapPolicy._layout.encode(this, buffer);
+        return buffer;
+    }
+    constructor(maxSlippageBps, swapAllowlist){
+        this.maxSlippageBps = maxSlippageBps;
+        this.swapAllowlist = swapAllowlist;
+    }
+}
+JupiterSwapPolicy._layout = borsh.struct([
+    borsh.u32("maxSlippageBps"),
+    borsh.option(borsh.vec(borsh.publicKey()), "swapAllowlist")
+]);
+// System Program and Token Program use the same TransferPolicy struct
 class TransferPolicy {
     static decode(buffer) {
-        const data = TransferPolicy._layout.decode(buffer);
-        return data;
+        const { allowlist } = TransferPolicy._layout.decode(buffer);
+        return new TransferPolicy(allowlist);
     }
     encode() {
         const header = Buffer.alloc(4);
@@ -23153,6 +23126,47 @@ DriftProtocolPolicy._layout = borsh.struct([
     borsh.vec(borsh.u16(), "perpMarketsAllowlist"),
     borsh.vec(borsh.publicKey(), "borrowAllowlist")
 ]);
+class KaminoLendingPolicy {
+    static decode(buffer) {
+        const { marketsAllowlist, borrowAllowlist } = KaminoLendingPolicy._layout.decode(buffer);
+        return new KaminoLendingPolicy(marketsAllowlist, borrowAllowlist);
+    }
+    encode() {
+        const marketsAllowlistSize = 4 + this.marketsAllowlist.length * 32;
+        const borrowAllowlistSize = 4 + this.borrowAllowlist.length * 32;
+        const totalSize = marketsAllowlistSize + borrowAllowlistSize;
+        const buffer = Buffer.alloc(totalSize);
+        KaminoLendingPolicy._layout.encode(this, buffer);
+        return buffer;
+    }
+    constructor(marketsAllowlist, borrowAllowlist){
+        this.marketsAllowlist = marketsAllowlist;
+        this.borrowAllowlist = borrowAllowlist;
+    }
+}
+KaminoLendingPolicy._layout = borsh.struct([
+    borsh.vec(borsh.publicKey(), "marketsAllowlist"),
+    borsh.vec(borsh.publicKey(), "borrowAllowlist")
+]);
+class KaminoVaultsPolicy {
+    static decode(buffer) {
+        const { vaultsAllowlist } = KaminoVaultsPolicy._layout.decode(buffer);
+        return new KaminoVaultsPolicy(vaultsAllowlist);
+    }
+    encode() {
+        const vaultsAllowlistSize = 4 + this.vaultsAllowlist.length * 32;
+        const totalSize = vaultsAllowlistSize;
+        const buffer = Buffer.alloc(totalSize);
+        KaminoVaultsPolicy._layout.encode(this, buffer);
+        return buffer;
+    }
+    constructor(vaultsAllowlist){
+        this.vaultsAllowlist = vaultsAllowlist;
+    }
+}
+KaminoVaultsPolicy._layout = borsh.struct([
+    borsh.vec(borsh.publicKey(), "vaultsAllowlist")
+]);
 class CctpPolicy {
     static decode(buffer) {
         const data = CctpPolicy._layout.decode(buffer);
@@ -23185,21 +23199,11 @@ CctpPolicy._layout = borsh.struct([
     ]), "allowedDestinations")
 ]);
 
-function getStatePda(stateModel, programId, owner) {
-    if (!stateModel?.created?.key && !stateModel?.name) {
-        throw new Error("State model must have created key or name");
-    }
-    const createdKey = stateModel?.created?.key || [
-        ...Buffer.from(anchor__namespace.utils.sha256.hash(charsToName(stateModel.name))).subarray(0, 8)
-    ];
-    const stateOwner = owner || stateModel?.owner;
-    if (!stateOwner) {
-        throw new Error("Owner must be specified explicitly or set in state model");
-    }
+function getStatePda(initKey, owner, programId) {
     const [pda, _bump] = web3_js.PublicKey.findProgramAddressSync([
         Buffer.from(SEED_STATE),
-        stateOwner.toBuffer(),
-        Uint8Array.from(createdKey)
+        owner.toBuffer(),
+        Uint8Array.from(initKey)
     ], programId);
     return pda;
 }
@@ -23254,8 +23258,6 @@ function getAccountPolicyPda(tokenAccount) {
     ], TRANSFER_HOOK_PROGRAM)[0];
 }
 
-const GlamIntegrations = GlamProtocolIdlJson?.types?.find((t)=>t.name === "Integration")?.type?.variants?.map((v)=>v.name) ?? [];
-const GlamPermissions = GlamProtocolIdlJson?.types?.find((t)=>t.name === "Permission")?.type?.variants?.map((v)=>v.name).filter((v)=>!v.startsWith("__")) ?? [];
 const GLAM_PROTOCOL_PROGRAM_ID = new web3_js.PublicKey(GlamProtocolIdlJson.address);
 class StateIdlModel {
     constructor(data){
@@ -23274,14 +23276,19 @@ class StateIdlModel {
         this.integrationAcls = data.integrationAcls ?? null;
     }
 }
-class StateModel extends StateIdlModel {
+/**
+ * Enriched state model built from multiple onchain accounts
+ */ class StateModel extends StateIdlModel {
     get idStr() {
         return this.id?.toBase58() || "";
     }
     get nameStr() {
-        return charsToName(this.name);
+        return this.name ? charsToName(this.name) : "";
     }
     get vault() {
+        if (!this.id) {
+            throw new Error("State ID not initialized");
+        }
         return getVaultPda(this.id, this.glamProgramId);
     }
     get productType() {
@@ -23294,6 +23301,9 @@ class StateModel extends StateIdlModel {
         return new Date(createdAt * 1000).toISOString().split("T")[0] || "Unknown";
     }
     get sparkleKey() {
+        if (!this.mint || !this.id) {
+            throw new Error("Mint or state pubkey not set");
+        }
         return (this.mint.equals(web3_js.PublicKey.default) ? this.id : this.mint).toBase58();
     }
     get baseAssetTokenProgramId() {
@@ -23368,6 +23378,7 @@ class StateModel extends StateIdlModel {
                 const name = Object.keys(param.name)[0];
                 // @ts-ignore
                 const value = Object.values(param.value)[0].val;
+                // @ts-ignore
                 mintModel[name] = value;
             });
             // Parse token extensions
@@ -23448,7 +23459,7 @@ class MintIdlModel {
 }
 class MintModel extends MintIdlModel {
     get nameStr() {
-        return charsToName(this.name);
+        return this.name ? charsToName(this.name) : "";
     }
     constructor(data){
         super(data);
@@ -23499,12 +23510,6 @@ class ProtocolPermissions {
         this.permissionsBitmask = obj.permissionsBitmask;
     }
 }
-class JupiterSwapPolicy {
-    constructor(obj){
-        this.maxSlippageBps = obj.maxSlippageBps;
-        this.swapAllowlist = obj.swapAllowlist ?? null;
-    }
-}
 class ProtocolPolicy {
     constructor(obj){
         this.protocolBitflag = obj.protocolBitflag;
@@ -24565,7 +24570,7 @@ class BaseClient {
     /**
    * Fetches mint accounts and token program IDs for the given mint pubkeys
    */ async fetchMintsAndTokenPrograms(mintPubkeys) {
-        const accountsInfo = (await this.provider.connection.getMultipleAccountsInfo(mintPubkeys, "confirmed")).filter(Boolean);
+        const accountsInfo = (await this.provider.connection.getMultipleAccountsInfo(mintPubkeys, "confirmed")).filter((info)=>info !== null);
         if (accountsInfo.length !== mintPubkeys.length) {
             throw new Error(`Failed to fetch mint accounts for ${mintPubkeys.length} mints`);
         }
@@ -24575,6 +24580,9 @@ class BaseClient {
    * Fetches mint account and token program ID for the given mint pubkey
    */ async fetchMintAndTokenProgram(mintPubkey) {
         const info = await this.provider.connection.getAccountInfo(mintPubkey, "confirmed");
+        if (!info) {
+            throw new Error(`Failed to fetch mint account for ${mintPubkey.toBase58()}`);
+        }
         return this.parseMintAccountInfo(info, mintPubkey);
     }
     /**
@@ -24712,6 +24720,15 @@ class BaseClient {
             return StateModel.fromOnchainAccounts(publicKey, stateAccount, mintsCache.get(stateAccount.mint.toBase58()), this.protocolProgram.programId);
         });
     }
+    async fetchProtocolPolicy(integProgramId, protocolBitflag, policyClass) {
+        const stateAccount = await this.fetchStateAccount();
+        const integrationPolicy = stateAccount.integrationAcls?.find((acl)=>acl.integrationProgram.equals(integProgramId));
+        const policyData = integrationPolicy?.protocolPolicies?.find((policy)=>policy.protocolBitflag === protocolBitflag)?.data;
+        if (policyData) {
+            return policyClass.decode(policyData);
+        }
+        return null;
+    }
     constructor(config){
         if (config?.provider) {
             this.provider = config?.provider;
@@ -26504,12 +26521,13 @@ class DriftVaultsClient {
     async parseDriftVaults(driftVaults) {
         const connection = this.base.provider.connection;
         const accountsInfo = await connection.getMultipleAccountsInfo(driftVaults);
-        accountsInfo.forEach((accountInfo, i)=>{
+        const validAccountsInfo = accountsInfo.map((accountInfo, i)=>{
             if (!accountInfo) {
                 throw new Error(`Drift vault account not found: ${driftVaults[i]}`);
             }
+            return accountInfo;
         });
-        return accountsInfo.map((accountInfo, i)=>{
+        return validAccountsInfo.map((accountInfo)=>{
             return DriftVault.decode(accountInfo.data);
         });
     }
@@ -26740,14 +26758,6 @@ async function getSwapInstructions(quoteResponse, from) {
     return await res.json();
 }
 let TxBuilder$3 = class TxBuilder {
-    async setJupiterSwapPolicy(policy, txOptions = {}) {
-        const glamSigner = txOptions.signer || this.base.getSigner();
-        const tx = await this.base.protocolProgram.methods.setJupiterSwapPolicy(policy).accounts({
-            glamState: this.base.statePda,
-            glamSigner
-        }).transaction();
-        return this.base.intoVersionedTransaction(tx, txOptions);
-    }
     async swap(options, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const glamVault = this.base.vaultPda;
@@ -26845,10 +26855,6 @@ class JupiterSwapClient {
         const tx = await this.txBuilder.swap(options, txOptions);
         return await this.base.sendAndConfirm(tx);
     }
-    async setJupiterSwapPolicy(policy, txOptions = {}) {
-        const tx = await this.txBuilder.setJupiterSwapPolicy(policy, txOptions);
-        return await this.base.sendAndConfirm(tx);
-    }
     constructor(base){
         this.base = base;
         this.txBuilder = new TxBuilder$3(base);
@@ -27198,7 +27204,7 @@ class VaultClient {
     }
     /**
    * Returns an instruction that closes the specified vault token account
-   */ async closeTokenAccountIx(tokenAccount, tokenProgram = splToken.TOKEN_PROGRAM_ID, txOptions) {
+   */ async closeTokenAccountIx(tokenAccount, tokenProgram = splToken.TOKEN_PROGRAM_ID, txOptions = {}) {
         return await this.base.extSplProgram.methods.tokenCloseAccount().accounts({
             glamState: this.base.statePda,
             glamSigner: txOptions.signer || this.base.signer,
@@ -27269,6 +27275,24 @@ class VaultClient {
         const tx = new web3_js.Transaction().add(splToken.createAssociatedTokenAccountIdempotentInstruction(signer, vaultAta, this.base.vaultPda, asset, tokenProgram), splToken.createTransferCheckedInstruction(signerAta, asset, vaultAta, signer, new anchor.BN(amount).toNumber(), mint.decimals, [], tokenProgram));
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
+    async tokenTransferIxs(mint, amount, to, txOptions = {}) {
+        const glamSigner = txOptions.signer || this.base.signer;
+        const { mint: mintObj, tokenProgram } = await this.base.fetchMintAndTokenProgram(mint);
+        const toAta = this.base.getAta(mint, to, tokenProgram);
+        const preIx = splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, toAta, to, mint, tokenProgram);
+        const ix = await this.base.extSplProgram.methods.tokenTransferChecked(new anchor.BN(amount), mintObj.decimals).accounts({
+            glamState: this.base.statePda,
+            glamSigner,
+            from: this.base.getVaultAta(mint, tokenProgram),
+            to: toAta,
+            mint,
+            cpiProgram: tokenProgram
+        }).instruction();
+        return [
+            preIx,
+            ix
+        ];
+    }
     async tokenTransferTx(mint, amount, to, txOptions) {
         const glamSigner = txOptions.signer || this.base.signer;
         const { mint: mintObj, tokenProgram } = await this.base.fetchMintAndTokenProgram(mint);
@@ -27754,6 +27778,9 @@ let TxBuilder$2 = class TxBuilder {
         const glamSigner = txOptions.signer || this.base.signer;
         const stateModel = this.enrichStateModel(partialStateModel);
         const { id: statePda } = stateModel;
+        if (!statePda) {
+            throw new Error("State PDA not set");
+        }
         const tx = await this.base.protocolProgram.methods.initializeState(new StateIdlModel(stateModel)).accountsPartial({
             glamState: statePda,
             glamSigner,
@@ -27798,7 +27825,7 @@ let TxBuilder$2 = class TxBuilder {
    * Create an enriched state model from a partial IDL state model
    */ enrichStateModel(stateModel) {
         if (!stateModel?.name) {
-            throw new Error("Name must be specified in partial state model");
+            throw new Error("Name must be specified");
         }
         // stateInitKey = hash state name and get first 8 bytes
         // useful for computing state account PDA in the future
@@ -27809,7 +27836,7 @@ let TxBuilder$2 = class TxBuilder {
             key: stateInitKey
         });
         stateModel.owner = stateModel.owner || this.base.signer;
-        const statePda = getStatePda(stateModel, this.base.protocolProgram.programId);
+        const statePda = getStatePda(stateInitKey, stateModel.owner, this.base.protocolProgram.programId);
         stateModel.uri = stateModel.uri || `https://gui.glam.systems/products/${statePda}`;
         return new StateModel({
             ...stateModel,
@@ -29519,7 +29546,7 @@ class PriceClient {
         possibleShareAtaAccountsInfo.forEach((info, i)=>{
             // share ata must exist and it must be tracked by glam state
             // otherwise skip it for pricing
-            if (info !== null && this.cachedStateModel.externalPositions?.find((a)=>a.equals(possibleShareAtas[i]))) {
+            if (info !== null && this.cachedStateModel?.externalPositions?.find((a)=>a.equals(possibleShareAtas[i]))) {
                 shareAtas.push(possibleShareAtas[i]);
                 shareMints.push(allKvaultMints[i]);
                 kvaultStates.push(allKvaultStates[i]);
@@ -29753,22 +29780,26 @@ class PriceClient {
         if (driftIntegrationAcl) {
             // drift protocol
             if (driftIntegrationAcl.protocolsBitmask & 0b01) {
-                pricingIxs.push(await this.priceDriftUsersIx());
+                const ix = await this.priceDriftUsersIx();
+                if (ix) pricingIxs.push(ix);
             }
             // drift vaults
             if (driftIntegrationAcl.protocolsBitmask & 0b10) {
-                pricingIxs.push(await this.priceDriftVaultDepositorsIx());
+                const ix = await this.priceDriftVaultDepositorsIx();
+                if (ix) pricingIxs.push(ix);
             }
         }
         const kaminoIntegrationAcl = integrationAcls.find((acl)=>acl.integrationProgram.equals(this.base.extKaminoProgram.programId));
         if (kaminoIntegrationAcl) {
             // kamino lending
             if (kaminoIntegrationAcl.protocolsBitmask & 0b01) {
-                pricingIxs.push(await this.priceKaminoObligationsIx());
+                const ix = await this.priceKaminoObligationsIx();
+                if (ix) pricingIxs.push(ix);
             }
             // kamino vaults
             if (kaminoIntegrationAcl.protocolsBitmask & 0b10) {
-                pricingIxs.push(...await this.priceKaminoVaultSharesIx());
+                const ixs = await this.priceKaminoVaultSharesIx();
+                if (ixs) pricingIxs.push(...ixs);
             }
         }
         return pricingIxs.filter(Boolean);
@@ -29986,17 +30017,191 @@ class FeesClient {
     }
 }
 
+let MintTxBuilder = class MintTxBuilder {
+    /**
+   * Creates a glam mint token account
+   *
+   * @param owner Owner of the token account
+   * @param setFrozen If true, the token account will be frozen immediately
+   * @param txOptions
+   */ async createTokenAccount(owner, setFrozen = true, txOptions = {}) {
+        const glamSigner = txOptions.signer || this.base.getSigner();
+        const glamMint = this.base.mintPda;
+        const ata = this.base.getMintAta(owner);
+        const ixCreateAta = splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, ata, owner, glamMint, splToken.TOKEN_2022_PROGRAM_ID);
+        return await this.setTokenAccountsStates([
+            ata
+        ], setFrozen, {
+            preInstructions: [
+                ixCreateAta
+            ],
+            ...txOptions
+        });
+    }
+    /**
+   * Freezes or unfreezes token accounts
+   *
+   * @param tokenAccounts List of token accounts to freeze or unfreeze
+   * @param frozen If true, the token accounts will be frozen; otherwise, they will be unfrozen
+   * @param txOptions
+   */ async setTokenAccountsStates(tokenAccounts, frozen, txOptions = {}) {
+        const glamSigner = txOptions.signer || this.base.getSigner();
+        const tx = await this.base.mintProgram.methods.setTokenAccountsStates(frozen).accounts({
+            glamState: this.base.statePda,
+            glamSigner,
+            glamMint: this.base.mintPda
+        }).remainingAccounts(tokenAccounts.map((account)=>({
+                pubkey: account,
+                isSigner: false,
+                isWritable: true
+            }))).preInstructions(txOptions.preInstructions || []).transaction();
+        return await this.base.intoVersionedTransaction(tx, txOptions);
+    }
+    /**
+   * Mints tokens to recipient. Token account will be created if it does not exist.
+   *
+   * @param recipient Recipient public key
+   * @param amount Amount of tokens to mint
+   * @param forceThaw If true, automatically unfreeze the token account before minting
+   * @param txOptions
+   */ async mint(recipient, amount, forceThaw = false, txOptions = {}) {
+        const glamSigner = txOptions.signer || this.base.signer;
+        const mintTo = this.base.getMintAta(recipient);
+        const preInstructions = [
+            splToken.createAssociatedTokenAccountIdempotentInstruction(glamSigner, mintTo, recipient, this.base.mintPda, splToken.TOKEN_2022_PROGRAM_ID)
+        ];
+        if (forceThaw) {
+            preInstructions.push(await this.base.mintProgram.methods.setTokenAccountsStates(false).accounts({
+                glamState: this.base.statePda,
+                glamSigner,
+                glamMint: this.base.mintPda
+            }).remainingAccounts([
+                {
+                    pubkey: mintTo,
+                    isSigner: false,
+                    isWritable: true
+                }
+            ]).instruction());
+        }
+        let policyAccount = await this.base.isLockupEnabled() ? getAccountPolicyPda(mintTo) : null;
+        const tx = await this.base.mintProgram.methods.mintTokens(amount).accounts({
+            glamState: this.base.statePda,
+            glamSigner,
+            glamMint: this.base.mintPda,
+            recipient,
+            policyAccount
+        }).preInstructions(preInstructions).transaction();
+        return await this.base.intoVersionedTransaction(tx, txOptions);
+    }
+    /**
+   * Burns tokens from a token account
+   *
+   * @param from Owner of the token account
+   * @param amount Amount of tokens to burn
+   * @param forceThaw If true, automatically unfree the token account before burning
+   * @param txOptions
+   */ async burn(from, amount, forceThaw = false, txOptions = {}) {
+        const glamSigner = txOptions.signer || this.base.getSigner();
+        const ata = this.base.getMintAta(from);
+        const preInstructions = [];
+        if (forceThaw) {
+            preInstructions.push(await this.base.mintProgram.methods.setTokenAccountsStates(false).accounts({
+                glamState: this.base.statePda,
+                glamSigner,
+                glamMint: this.base.mintPda
+            }).remainingAccounts([
+                {
+                    pubkey: ata,
+                    isSigner: false,
+                    isWritable: true
+                }
+            ]).instruction());
+        }
+        const tx = await this.base.mintProgram.methods.burnTokens(amount).accounts({
+            glamState: this.base.statePda,
+            glamSigner,
+            glamMint: this.base.mintPda,
+            from
+        }).preInstructions(preInstructions).transaction();
+        return await this.base.intoVersionedTransaction(tx, txOptions);
+    }
+    /**
+   * Transfers tokens from one token account to another
+   *
+   * @param from Owner of the sender token account
+   * @param to Owner of the recipient token account
+   * @param amount Amount of tokens to transfer
+   * @param forceThaw If true, automatically unfree the token accounts before transfer
+   * @param txOptions
+   */ async forceTransfer(from, to, amount, forceThaw = false, txOptions = {}) {
+        const glamSigner = txOptions.signer || this.base.getSigner();
+        const fromAta = this.base.getMintAta(from);
+        const toAta = this.base.getMintAta(to);
+        const preInstructions = [];
+        preInstructions.push(splToken.createAssociatedTokenAccountIdempotentInstruction(this.base.getSigner(), toAta, to, this.base.mintPda, splToken.TOKEN_2022_PROGRAM_ID));
+        if (forceThaw) {
+            preInstructions.push(await this.base.mintProgram.methods.setTokenAccountsStates(false).accounts({
+                glamState: this.base.statePda,
+                glamSigner,
+                glamMint: this.base.mintPda
+            }).remainingAccounts([
+                {
+                    pubkey: fromAta,
+                    isSigner: false,
+                    isWritable: true
+                },
+                {
+                    pubkey: toAta,
+                    isSigner: false,
+                    isWritable: true
+                }
+            ]).instruction());
+        }
+        const remainingAccounts = [];
+        let toPolicyAccount = null;
+        if (await this.base.isLockupEnabled()) {
+            const extraMetasAccount = this.base.extraMetasPda;
+            const fromPolicy = getAccountPolicyPda(fromAta);
+            const toPolicy = getAccountPolicyPda(toAta);
+            toPolicyAccount = toPolicy;
+            remainingAccounts.push(...[
+                extraMetasAccount,
+                fromPolicy,
+                toPolicy,
+                TRANSFER_HOOK_PROGRAM
+            ]);
+        }
+        const tx = await this.base.mintProgram.methods.forceTransferTokens(amount).accounts({
+            glamState: this.base.statePda,
+            glamSigner,
+            glamMint: this.base.mintPda,
+            from,
+            to,
+            toPolicyAccount
+        }).remainingAccounts(remainingAccounts.map((pubkey)=>({
+                pubkey,
+                isSigner: false,
+                isWritable: false
+            }))).preInstructions(preInstructions).transaction();
+        return await this.base.intoVersionedTransaction(tx, txOptions);
+    }
+    constructor(base){
+        this.base = base;
+    }
+};
 let TxBuilder$1 = class TxBuilder {
-    async initialize(mintModel, accountType, txOptions = {}) {
+    async initialize(mintModel, accountType, decimals, txOptions = {}) {
         if (!mintModel.name) {
             throw new Error("Mint name must be specified");
         }
         if (!mintModel.baseAssetMint) {
             throw new Error("Mint asset must be specified");
         }
-        // Set glam mint decimals to the same as deposit asset
-        const { mint } = await this.base.fetchMintAndTokenProgram(mintModel.baseAssetMint);
-        const glamMintDecimals = mint.decimals;
+        // If decimals is not specified, set it to the same as the deposit asset
+        if (decimals === null) {
+            const { mint } = await this.base.fetchMintAndTokenProgram(mintModel.baseAssetMint);
+            decimals = mint.decimals;
+        }
         const stateInitKey = [
             ...Buffer.from(anchor__namespace.utils.sha256.hash(charsToName(mintModel.name))).subarray(0, 8)
         ];
@@ -30010,15 +30215,14 @@ let TxBuilder$1 = class TxBuilder {
             const glamApi = process.env.NEXT_PUBLIC_GLAM_API || process.env.GLAM_API || "https://api.glam.systems";
             mintModel.uri = `${glamApi}/v0/token/2022/mint?key=${this.base.mintPda}`;
         }
-        const tx = await this.base.mintProgram.methods.initializeMint(new MintIdlModel(mintModel), stateInitKey, accountType, glamMintDecimals).accounts({
+        const tx = await this.base.mintProgram.methods.initializeMint(new MintIdlModel(mintModel), stateInitKey, accountType, decimals).accounts({
             glamState: this.base.statePda,
             signer: txOptions.signer || this.base.signer,
             newMint: this.base.mintPda,
             extraMetasAccount: this.base.extraMetasPda,
             baseAssetMint: mintModel.baseAssetMint
         }).transaction();
-        const vTx = await this.base.intoVersionedTransaction(tx, txOptions);
-        return vTx;
+        return await this.base.intoVersionedTransaction(tx, txOptions);
     }
     async update(mintModel, txOptions = {}) {
         const tx = await this.base.mintProgram.methods.updateMint(new MintIdlModel(mintModel)).accounts({
@@ -30120,11 +30324,10 @@ class MintClient {
         // in case users choose to use a non-helius RPC. Fall back to getHolders if
         // helius API key is not provided
         const heliusApiKey = process.env.NEXT_PUBLIC_HELIUS_API_KEY || process.env.HELIUS_API_KEY;
-        if (!heliusApiKey) {
+        if (!heliusApiKey || this.base.cluster !== ClusterNetwork.Mainnet) {
             return await this.getHolders(showZeroBalance);
         }
-        const cluster = this.base.cluster === ClusterNetwork.Mainnet ? "mainnet" : "devnet";
-        const response = await fetch(`https://${cluster}.helius-rpc.com/?api-key=${heliusApiKey}`, {
+        const response = await fetch(`https://mainnet.helius-rpc.com/?api-key=${heliusApiKey}`, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json"
@@ -30143,14 +30346,15 @@ class MintClient {
         });
         const data = await response.json();
         const { token_accounts: tokenAccounts } = data.result;
+        const { mint, tokenProgram } = await this.base.fetchMintAndTokenProgram(this.base.mintPda);
         return tokenAccounts.map((ta)=>({
                 owner: new web3_js.PublicKey(ta.owner),
                 pubkey: new web3_js.PublicKey(ta.address),
                 mint: this.base.mintPda,
-                programId: splToken.TOKEN_2022_PROGRAM_ID,
-                decimals: 9,
+                programId: tokenProgram,
+                decimals: mint.decimals,
                 amount: ta.amount,
-                uiAmount: Number(ta.amount) / 10 ** 9,
+                uiAmount: Number(ta.amount) / 10 ** mint.decimals,
                 frozen: ta.frozen
             }));
     }
@@ -30171,6 +30375,7 @@ class MintClient {
                 }
             ]
         });
+        const { mint, tokenProgram } = await this.base.fetchMintAndTokenProgram(this.base.mintPda);
         return accounts.map((a)=>{
             const { pubkey, account } = a;
             const tokenAccount = splToken.unpackAccount(pubkey, account, splToken.TOKEN_2022_PROGRAM_ID);
@@ -30178,16 +30383,20 @@ class MintClient {
                 owner: tokenAccount.owner,
                 pubkey: tokenAccount.address,
                 mint: tokenAccount.mint,
-                programId: splToken.TOKEN_2022_PROGRAM_ID,
-                decimals: 9,
+                programId: tokenProgram,
+                decimals: mint.decimals,
                 amount: tokenAccount.amount.toString(),
-                uiAmount: Number(tokenAccount.amount) / 10 ** 9,
+                uiAmount: Number(tokenAccount.amount) / 10 ** mint.decimals,
                 frozen: tokenAccount.isFrozen
             };
         }).filter((ta)=>showZeroBalance || ta.uiAmount > 0);
     }
     async initialize(mintModel, accountType, txOptions = {}) {
-        const vTx = await this.txBuilder.initialize(mintModel, accountType, txOptions);
+        const vTx = await this.txBuilder.initialize(mintModel, accountType, null, txOptions);
+        return await this.base.sendAndConfirm(vTx);
+    }
+    async initializeWithDecimals(mintModel, accountType, decimals, txOptions = {}) {
+        const vTx = await this.txBuilder.initialize(mintModel, accountType, decimals, txOptions);
         return await this.base.sendAndConfirm(vTx);
     }
     async update(mintModel, txOptions = {}) {
@@ -30218,15 +30427,35 @@ class MintClient {
         const vTx = await this.txBuilder.closeMint(txOptions);
         return await this.base.sendAndConfirm(vTx);
     }
+    async mint(to, amount, unfreeze = false, txOptions = {}) {
+        const vTx = await this.mintTxBuilder.mint(to, amount, unfreeze, txOptions);
+        return await this.base.sendAndConfirm(vTx);
+    }
+    async burn(from, amount, unfreeze = false, txOptions = {}) {
+        const vTx = await this.mintTxBuilder.burn(from, amount, unfreeze, txOptions);
+        return await this.base.sendAndConfirm(vTx);
+    }
+    async createTokenAccount(owner, setFrozen, txOptions = {}) {
+        const vTx = await this.mintTxBuilder.createTokenAccount(owner, setFrozen, txOptions);
+        return await this.base.sendAndConfirm(vTx);
+    }
+    async setTokenAccountsStates(tokenAccounts, frozen, txOptions = {}) {
+        const vTx = await this.mintTxBuilder.setTokenAccountsStates(tokenAccounts, frozen, txOptions);
+        return await this.base.sendAndConfirm(vTx);
+    }
+    async forceTransfer(from, to, amount, unfreeze = false, txOptions = {}) {
+        const vTx = await this.mintTxBuilder.forceTransfer(from, to, amount, unfreeze, txOptions);
+        return await this.base.sendAndConfirm(vTx);
+    }
     constructor(base){
         this.base = base;
-        // this.mintTxBuilder = new MintTxBuilder(base);
+        this.mintTxBuilder = new MintTxBuilder(base);
         this.txBuilder = new TxBuilder$1(base);
     }
 }
 
 let TxBuilder = class TxBuilder {
-    async emergencyAccessUpdate(args, txOptions) {
+    async emergencyAccessUpdate(args, txOptions = {}) {
         const glamSigner = txOptions.signer || this.base.signer;
         const tx = await this.base.protocolProgram.methods.emergencyAccessUpdate(new EmergencyAccessUpdateArgs(args)).accounts({
             glamState: this.base.statePda,
@@ -30234,6 +30463,13 @@ let TxBuilder = class TxBuilder {
         }).preInstructions(txOptions.preInstructions || []).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
+    async emergencyAccessUpdateIx(args, txOptions = {}) {
+        const glamSigner = txOptions.signer || this.base.signer;
+        return await this.base.protocolProgram.methods.emergencyAccessUpdate(new EmergencyAccessUpdateArgs(args)).accounts({
+            glamState: this.base.statePda,
+            glamSigner
+        }).instruction();
+    }
     async enableDisableProtocols(integrationProgram, protocolBitmask, setEnabled, txOptions) {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const tx = await this.base.protocolProgram.methods.enableDisableProtocols(integrationProgram, protocolBitmask, setEnabled).accounts({
@@ -30250,6 +30486,13 @@ let TxBuilder = class TxBuilder {
         }).preInstructions(txOptions.preInstructions || []).transaction();
         return await this.base.intoVersionedTransaction(tx, txOptions);
     }
+    async grantRevokeDelegatePermissionsIx(delegate, integrationProgram, protocolBitflag, permissionsBitmask, setGranted, txOptions = {}) {
+        const glamSigner = txOptions.signer || this.base.getSigner();
+        return await this.base.protocolProgram.methods.grantRevokeDelegatePermissions(delegate, integrationProgram, protocolBitflag, permissionsBitmask, setGranted).accounts({
+            glamState: this.base.statePda,
+            glamSigner
+        }).instruction();
+    }
     async setProtocolPolicy(integrationProgram, protocolBitflag, data, txOptions) {
         const glamSigner = txOptions.signer || this.base.getSigner();
         const tx = await this.base.protocolProgram.methods.setProtocolPolicy(integrationProgram, protocolBitflag, data).accounts({
@@ -30417,6 +30660,194 @@ class AccessClient {
     }
 }
 
+/**
+ * Get protocol names from a bitmask for a given integration program
+ * Uses the SDK's parseProtocolsBitmask function
+ */ function getProtocolNamesFromBitmask(integrationProgram, bitmask) {
+    const { protocols } = parseProtocolsBitmask(integrationProgram, bitmask);
+    return protocols.map((p)=>p.name);
+}
+/**
+ * Get permission names from a permissions bitmask for a protocol
+ * Uses the SDK's parseProtocolPermissionsBitmask function
+ */ function getPermissionNamesFromBitmask(integrationProgram, protocolBitflag, permissionsBitmask) {
+    const { permissions } = parseProtocolPermissionsBitmask(integrationProgram, protocolBitflag, permissionsBitmask);
+    return permissions.map((p)=>p.name);
+}
+/**
+ * Compare current and staged integrationAcls and return the differences
+ */ function compareIntegrationAcls(current, staged) {
+    const added = [];
+    const removed = [];
+    const modified = [];
+    const currentMap = new Map();
+    (current || []).forEach((acl)=>{
+        currentMap.set(acl.integrationProgram.toBase58(), acl);
+    });
+    const stagedMap = new Map();
+    (staged || []).forEach((acl)=>{
+        stagedMap.set(acl.integrationProgram.toBase58(), acl);
+    });
+    // Find added integrations
+    stagedMap.forEach((stagedAcl, programId)=>{
+        if (!currentMap.has(programId)) {
+            added.push(stagedAcl);
+        }
+    });
+    // Find removed integrations
+    currentMap.forEach((currentAcl, programId)=>{
+        if (!stagedMap.has(programId)) {
+            removed.push(currentAcl);
+        }
+    });
+    // Find modified integrations (changed bitmask)
+    currentMap.forEach((currentAcl, programId)=>{
+        const stagedAcl = stagedMap.get(programId);
+        if (stagedAcl && currentAcl.protocolsBitmask !== stagedAcl.protocolsBitmask) {
+            const currentProtocols = getProtocolNamesFromBitmask(currentAcl.integrationProgram, currentAcl.protocolsBitmask);
+            const stagedProtocols = getProtocolNamesFromBitmask(stagedAcl.integrationProgram, stagedAcl.protocolsBitmask);
+            const enabledProtocols = stagedProtocols.filter((p)=>!currentProtocols.includes(p));
+            const disabledProtocols = currentProtocols.filter((p)=>!stagedProtocols.includes(p));
+            modified.push({
+                integrationProgram: currentAcl.integrationProgram,
+                currentBitmask: currentAcl.protocolsBitmask,
+                stagedBitmask: stagedAcl.protocolsBitmask,
+                enabledProtocols,
+                disabledProtocols
+            });
+        }
+    });
+    return {
+        added,
+        removed,
+        modified
+    };
+}
+/**
+ * Compare current and staged delegateAcls and return the differences
+ */ function compareDelegateAcls(current, staged) {
+    const added = [];
+    const removed = [];
+    const modified = [];
+    const currentMap = new Map();
+    (current || []).forEach((acl)=>{
+        currentMap.set(acl.pubkey.toBase58(), acl);
+    });
+    const stagedMap = new Map();
+    (staged || []).forEach((acl)=>{
+        stagedMap.set(acl.pubkey.toBase58(), acl);
+    });
+    // Find added delegates
+    stagedMap.forEach((stagedAcl, pubkey)=>{
+        if (!currentMap.has(pubkey)) {
+            added.push(stagedAcl);
+        }
+    });
+    // Find removed delegates
+    currentMap.forEach((currentAcl, pubkey)=>{
+        if (!stagedMap.has(pubkey)) {
+            removed.push(currentAcl);
+        }
+    });
+    // Find modified delegates
+    currentMap.forEach((currentAcl, pubkey)=>{
+        const stagedAcl = stagedMap.get(pubkey);
+        if (!stagedAcl) return;
+        const permissionChanges = [];
+        // Create maps for easier comparison
+        const currentPermissionsMap = new Map();
+        currentAcl.integrationPermissions.forEach((intPerm)=>{
+            const programId = intPerm.integrationProgram.toBase58();
+            const protocolMap = new Map();
+            intPerm.protocolPermissions.forEach((protPerm)=>{
+                protocolMap.set(protPerm.protocolBitflag, protPerm.permissionsBitmask);
+            });
+            currentPermissionsMap.set(programId, protocolMap);
+        });
+        const stagedPermissionsMap = new Map();
+        stagedAcl.integrationPermissions.forEach((intPerm)=>{
+            const programId = intPerm.integrationProgram.toBase58();
+            const protocolMap = new Map();
+            intPerm.protocolPermissions.forEach((protPerm)=>{
+                protocolMap.set(protPerm.protocolBitflag, protPerm.permissionsBitmask);
+            });
+            stagedPermissionsMap.set(programId, protocolMap);
+        });
+        // Check all integration programs and protocols
+        const allProgramIds = new Set([
+            ...currentPermissionsMap.keys(),
+            ...stagedPermissionsMap.keys()
+        ]);
+        allProgramIds.forEach((programId)=>{
+            const currentProtocols = currentPermissionsMap.get(programId) || new Map();
+            const stagedProtocols = stagedPermissionsMap.get(programId) || new Map();
+            const integrationProgram = new web3_js.PublicKey(programId);
+            const allProtocolBitflags = new Set([
+                ...currentProtocols.keys(),
+                ...stagedProtocols.keys()
+            ]);
+            allProtocolBitflags.forEach((protocolBitflag)=>{
+                const current = currentProtocols.get(protocolBitflag);
+                const staged = stagedProtocols.get(protocolBitflag);
+                if (!current && staged) {
+                    // Protocol permissions added
+                    const protocolNames = getProtocolNamesFromBitmask(integrationProgram, protocolBitflag);
+                    const addedPermissions = getPermissionNamesFromBitmask(integrationProgram, protocolBitflag, staged);
+                    if (addedPermissions.length > 0) {
+                        permissionChanges.push({
+                            integrationProgram,
+                            protocolName: protocolNames[0] || "Unknown",
+                            addedPermissions,
+                            removedPermissions: []
+                        });
+                    }
+                } else if (current && !staged) {
+                    // Protocol permissions removed
+                    const protocolNames = getProtocolNamesFromBitmask(integrationProgram, protocolBitflag);
+                    const removedPermissions = getPermissionNamesFromBitmask(integrationProgram, protocolBitflag, current);
+                    if (removedPermissions.length > 0) {
+                        permissionChanges.push({
+                            integrationProgram,
+                            protocolName: protocolNames[0] || "Unknown",
+                            addedPermissions: [],
+                            removedPermissions
+                        });
+                    }
+                } else if (current && staged && !current.eq(staged)) {
+                    // Protocol permissions modified
+                    const protocolNames = getProtocolNamesFromBitmask(integrationProgram, protocolBitflag);
+                    const currentPermissions = getPermissionNamesFromBitmask(integrationProgram, protocolBitflag, current);
+                    const stagedPermissions = getPermissionNamesFromBitmask(integrationProgram, protocolBitflag, staged);
+                    const addedPermissions = stagedPermissions.filter((p)=>!currentPermissions.includes(p));
+                    const removedPermissions = currentPermissions.filter((p)=>!stagedPermissions.includes(p));
+                    if (addedPermissions.length > 0 || removedPermissions.length > 0) {
+                        permissionChanges.push({
+                            integrationProgram,
+                            protocolName: protocolNames[0] || "Unknown",
+                            addedPermissions,
+                            removedPermissions
+                        });
+                    }
+                }
+            });
+        });
+        // Check if there are any changes (expiration or permissions)
+        if (!currentAcl.expiresAt.eq(stagedAcl.expiresAt) || permissionChanges.length > 0) {
+            modified.push({
+                pubkey: currentAcl.pubkey,
+                currentExpiresAt: currentAcl.expiresAt,
+                stagedExpiresAt: stagedAcl.expiresAt,
+                permissionChanges
+            });
+        }
+    });
+    return {
+        added,
+        removed,
+        modified
+    };
+}
+
 const getPriorityFeeEstimate = async (heliusApiKey, tx, accountKeys, priorityLevel)=>{
     if (!tx && !accountKeys) {
         throw new Error("Either tx or accountKeys must be provided");
@@ -30541,13 +30972,10 @@ exports.GLAM_REFERRER = GLAM_REFERRER;
 exports.GOVERNANCE_PROGRAM_ID = GOVERNANCE_PROGRAM_ID;
 exports.GlamClient = GlamClient;
 exports.GlamError = GlamError;
-exports.GlamIntegrations = GlamIntegrations;
 exports.GlamMintIdl = GlamMintIdl;
 exports.GlamMintIdlJson = GlamMintIdlJson;
-exports.GlamPermissions = GlamPermissions;
 exports.GlamProtocolIdl = GlamProtocolIdl;
 exports.GlamProtocolIdlJson = GlamProtocolIdlJson;
-exports.INTEGRATION_MAPPING = INTEGRATION_MAPPING;
 exports.InsuranceFundOperation = InsuranceFundOperation;
 exports.IntegrationAcl = IntegrationAcl;
 exports.IntegrationPermissions = IntegrationPermissions;
@@ -30565,6 +30993,8 @@ exports.KAMINO_LENDING_PROGRAM = KAMINO_LENDING_PROGRAM;
 exports.KAMINO_OBTRIGATION_SIZE = KAMINO_OBTRIGATION_SIZE;
 exports.KAMINO_SCOPE_PRICES = KAMINO_SCOPE_PRICES;
 exports.KAMINO_VAULTS_PROGRAM = KAMINO_VAULTS_PROGRAM;
+exports.KaminoLendingPolicy = KaminoLendingPolicy;
+exports.KaminoVaultsPolicy = KaminoVaultsPolicy;
 exports.LPAction = LPAction;
 exports.LiquidationType = LiquidationType;
 exports.MARINADE_NATIVE_STAKE_AUTHORITY = MARINADE_NATIVE_STAKE_AUTHORITY;
@@ -30589,8 +31019,9 @@ exports.OrderActionExplanation = OrderActionExplanation;
 exports.OrderStatus = OrderStatus;
 exports.OrderTriggerCondition = OrderTriggerCondition;
 exports.OrderType = OrderType;
-exports.PERMISSION_MAPPINGS = PERMISSION_MAPPINGS;
+exports.PROGRAM_AND_BITFLAG_BY_PROTOCOL_NAME = PROGRAM_AND_BITFLAG_BY_PROTOCOL_NAME;
 exports.PROTOCOLS_AND_PERMISSIONS = PROTOCOLS_AND_PERMISSIONS;
+exports.PROTOCOL_NAME_BY_PROGRAM_AND_BITFLAG = PROTOCOL_NAME_BY_PROGRAM_AND_BITFLAG;
 exports.PerpOperation = PerpOperation;
 exports.PlaceAndTakeOrderSuccessCondition = PlaceAndTakeOrderSuccessCondition;
 exports.PositionDirection = PositionDirection;
@@ -30642,6 +31073,8 @@ exports.WSOL = WSOL;
 exports.ZERO = ZERO;
 exports.bytesToHex = bytesToHex;
 exports.charsToName = charsToName;
+exports.compareDelegateAcls = compareDelegateAcls;
+exports.compareIntegrationAcls = compareIntegrationAcls;
 exports.decodeUser = decodeUser;
 exports.evmAddressToBytes32 = evmAddressToBytes32;
 exports.evmAddressToPublicKey = evmAddressToPublicKey;
@@ -30668,9 +31101,11 @@ exports.getMarketOrderParams = getMarketOrderParams;
 exports.getMintPda = getMintPda;
 exports.getOpenfundsPda = getOpenfundsPda;
 exports.getOrderParams = getOrderParams;
+exports.getPermissionNamesFromBitmask = getPermissionNamesFromBitmask;
 exports.getPriorityFeeEstimate = getPriorityFeeEstimate;
 exports.getProgramAccountsV2 = getProgramAccountsV2;
 exports.getProgramAccountsWithRetry = getProgramAccountsWithRetry;
+exports.getProtocolNamesFromBitmask = getProtocolNamesFromBitmask;
 exports.getQuoteResponse = getQuoteResponse;
 exports.getRequestQueuePda = getRequestQueuePda;
 exports.getSimulationResult = getSimulationResult;