@glamsystems/glam-sdk 1.0.6 → 1.0.8

package/src/glamExports.d.ts

@@ -19,6 +19,7 @@ export type ExtKaminoProgram = Program<ExtKamino>;
 export type ExtMarinadeProgram = Program<ExtMarinade>;
 export type ExtStakePoolProgram = Program<ExtStakePool>;
 export type ExtCctpProgram = Program<ExtCctp>;
+export declare const isStaging: () => boolean;
 export declare function getGlamProtocolIdl(): {
     address: string;
     metadata: {
@@ -614,6 +615,618 @@ export declare function getGlamProtocolIdl(): {
         type: string;
         value: string;
     }[];
+} | {
+    address: string;
+    metadata: {
+        name: string;
+        version: string;
+        spec: string;
+        description: string;
+    };
+    instructions: ({
+        name: string;
+        docs: string[];
+        discriminator: number[];
+        accounts: ({
+            name: string;
+            writable: boolean;
+            pda?: undefined;
+            signer?: undefined;
+            address?: undefined;
+        } | {
+            name: string;
+            writable: boolean;
+            pda: {
+                seeds: ({
+                    kind: string;
+                    value: number[];
+                    path?: undefined;
+                } | {
+                    kind: string;
+                    path: string;
+                    value?: undefined;
+                })[];
+            };
+            signer?: undefined;
+            address?: undefined;
+        } | {
+            name: string;
+            writable: boolean;
+            signer: boolean;
+            pda?: undefined;
+            address?: undefined;
+        } | {
+            name: string;
+            writable?: undefined;
+            pda?: undefined;
+            signer?: undefined;
+            address?: undefined;
+        } | {
+            name: string;
+            signer: boolean;
+            writable?: undefined;
+            pda?: undefined;
+            address?: undefined;
+        } | {
+            name: string;
+            address: string;
+            writable?: undefined;
+            pda?: undefined;
+            signer?: undefined;
+        })[];
+        args: ({
+            name: string;
+            type: string;
+        } | {
+            name: string;
+            type: {
+                vec: {
+                    defined: {
+                        name: string;
+                    };
+                };
+            };
+        })[];
+    } | {
+        name: string;
+        docs: string[];
+        discriminator: number[];
+        accounts: ({
+            name: string;
+            writable: boolean;
+            signer?: undefined;
+        } | {
+            name: string;
+            writable: boolean;
+            signer: boolean;
+        })[];
+        args: {
+            name: string;
+            type: {
+                defined: {
+                    name: string;
+                };
+            };
+        }[];
+    } | {
+        name: string;
+        discriminator: number[];
+        accounts: ({
+            name: string;
+            writable: boolean;
+            pda: {
+                seeds: ({
+                    kind: string;
+                    value: number[];
+                    path?: undefined;
+                } | {
+                    kind: string;
+                    path: string;
+                    value?: undefined;
+                })[];
+            };
+            signer?: undefined;
+            address?: undefined;
+        } | {
+            name: string;
+            writable: boolean;
+            signer: boolean;
+            pda?: undefined;
+            address?: undefined;
+        } | {
+            name: string;
+            address: string;
+            writable?: undefined;
+            pda?: undefined;
+            signer?: undefined;
+        } | {
+            name: string;
+            writable?: undefined;
+            pda?: undefined;
+            signer?: undefined;
+            address?: undefined;
+        })[];
+        args: {
+            name: string;
+            type: {
+                defined: {
+                    name: string;
+                };
+            };
+        }[];
+        docs?: undefined;
+    } | {
+        name: string;
+        discriminator: number[];
+        accounts: ({
+            name: string;
+            writable: boolean;
+            pda?: undefined;
+            signer?: undefined;
+            address?: undefined;
+            optional?: undefined;
+        } | {
+            name: string;
+            writable: boolean;
+            pda: {
+                seeds: ({
+                    kind: string;
+                    value: number[];
+                    path?: undefined;
+                } | {
+                    kind: string;
+                    path: string;
+                    value?: undefined;
+                })[];
+                program?: undefined;
+            };
+            signer?: undefined;
+            address?: undefined;
+            optional?: undefined;
+        } | {
+            name: string;
+            writable: boolean;
+            signer: boolean;
+            pda?: undefined;
+            address?: undefined;
+            optional?: undefined;
+        } | {
+            name: string;
+            address: string;
+            writable?: undefined;
+            pda?: undefined;
+            signer?: undefined;
+            optional?: undefined;
+        } | {
+            name: string;
+            optional: boolean;
+            writable?: undefined;
+            pda?: undefined;
+            signer?: undefined;
+            address?: undefined;
+        } | {
+            name: string;
+            optional: boolean;
+            pda: {
+                seeds: {
+                    kind: string;
+                    value: number[];
+                }[];
+                program: {
+                    kind: string;
+                    value: number[];
+                };
+            };
+            writable?: undefined;
+            signer?: undefined;
+            address?: undefined;
+        })[];
+        args: {
+            name: string;
+            type: string;
+        }[];
+        docs?: undefined;
+    } | {
+        name: string;
+        discriminator: number[];
+        accounts: ({
+            name: string;
+            writable: boolean;
+            signer?: undefined;
+        } | {
+            name: string;
+            writable: boolean;
+            signer: boolean;
+        })[];
+        args: {
+            name: string;
+            type: {
+                defined: {
+                    name: string;
+                };
+            };
+        }[];
+        docs?: undefined;
+    } | {
+        name: string;
+        discriminator: number[];
+        accounts: ({
+            name: string;
+            writable?: undefined;
+            pda?: undefined;
+            signer?: undefined;
+            address?: undefined;
+        } | {
+            name: string;
+            writable: boolean;
+            pda: {
+                seeds: ({
+                    kind: string;
+                    value: number[];
+                    path?: undefined;
+                } | {
+                    kind: string;
+                    path: string;
+                    value?: undefined;
+                })[];
+            };
+            signer?: undefined;
+            address?: undefined;
+        } | {
+            name: string;
+            writable: boolean;
+            signer: boolean;
+            pda?: undefined;
+            address?: undefined;
+        } | {
+            name: string;
+            address: string;
+            writable?: undefined;
+            pda?: undefined;
+            signer?: undefined;
+        } | {
+            name: string;
+            writable: boolean;
+            pda?: undefined;
+            signer?: undefined;
+            address?: undefined;
+        })[];
+        args: never[];
+        docs?: undefined;
+    } | {
+        name: string;
+        discriminator: number[];
+        accounts: ({
+            name: string;
+            writable: boolean;
+            signer?: undefined;
+        } | {
+            name: string;
+            writable: boolean;
+            signer: boolean;
+        })[];
+        args: {
+            name: string;
+            type: {
+                vec: {
+                    defined: {
+                        name: string;
+                    };
+                };
+            };
+        }[];
+        docs?: undefined;
+    } | {
+        name: string;
+        docs: string[];
+        discriminator: number[];
+        accounts: ({
+            name: string;
+            writable: boolean;
+            signer?: undefined;
+        } | {
+            name: string;
+            signer: boolean;
+            writable?: undefined;
+        })[];
+        args: {
+            name: string;
+            type: {
+                defined: {
+                    name: string;
+                };
+            };
+        }[];
+    })[];
+    accounts: {
+        name: string;
+        discriminator: number[];
+    }[];
+    errors: {
+        code: number;
+        name: string;
+        msg: string;
+    }[];
+    types: ({
+        name: string;
+        type: {
+            kind: string;
+            variants: {
+                name: string;
+            }[];
+            fields?: undefined;
+        };
+        docs?: undefined;
+    } | {
+        name: string;
+        type: {
+            kind: string;
+            fields: ({
+                name: string;
+                type: {
+                    vec: string;
+                    option?: undefined;
+                };
+            } | {
+                name: string;
+                type: {
+                    option: string;
+                    vec?: undefined;
+                };
+            })[];
+            variants?: undefined;
+        };
+        docs?: undefined;
+    } | {
+        name: string;
+        type: {
+            kind: string;
+            variants: ({
+                name: string;
+                fields: {
+                    name: string;
+                    type: string;
+                }[];
+            } | {
+                name: string;
+                fields: {
+                    name: string;
+                    type: {
+                        vec: string;
+                    };
+                }[];
+            } | {
+                name: string;
+                fields: {
+                    name: string;
+                    type: {
+                        vec: {
+                            defined: {
+                                name: string;
+                            };
+                        };
+                    };
+                }[];
+            } | {
+                name: string;
+                fields: {
+                    name: string;
+                    type: {
+                        defined: {
+                            name: string;
+                        };
+                    };
+                }[];
+            })[];
+            fields?: undefined;
+        };
+        docs?: undefined;
+    } | {
+        name: string;
+        type: {
+            kind: string;
+            fields: ({
+                name: string;
+                type: {
+                    defined: {
+                        name: string;
+                    };
+                    option?: undefined;
+                };
+            } | {
+                name: string;
+                type: string;
+            } | {
+                name: string;
+                type: {
+                    option: string;
+                    defined?: undefined;
+                };
+            })[];
+            variants?: undefined;
+        };
+        docs?: undefined;
+    } | {
+        name: string;
+        docs: string[];
+        type: {
+            kind: string;
+            fields: ({
+                name: string;
+                type: string;
+            } | {
+                name: string;
+                type: {
+                    vec: {
+                        defined: {
+                            name: string;
+                        };
+                    };
+                };
+            })[];
+            variants?: undefined;
+        };
+    } | {
+        name: string;
+        type: {
+            kind: string;
+            fields: ({
+                name: string;
+                type: string;
+            } | {
+                name: string;
+                type: {
+                    option: {
+                        vec: string;
+                    };
+                };
+            })[];
+            variants?: undefined;
+        };
+        docs?: undefined;
+    } | {
+        name: string;
+        docs: string[];
+        type: {
+            kind: string;
+            fields: ({
+                name: string;
+                type: {
+                    vec: {
+                        array: (string | number)[];
+                    };
+                    array?: undefined;
+                };
+            } | {
+                name: string;
+                type: {
+                    array: (string | number)[];
+                    vec?: undefined;
+                };
+            })[];
+            variants?: undefined;
+        };
+    } | {
+        name: string;
+        type: {
+            kind: string;
+            fields: ({
+                name: string;
+                type: {
+                    defined: {
+                        name: string;
+                    };
+                    array?: undefined;
+                    vec?: undefined;
+                };
+            } | {
+                name: string;
+                type: string;
+            } | {
+                name: string;
+                type: {
+                    array: (string | number)[];
+                    defined?: undefined;
+                    vec?: undefined;
+                };
+            } | {
+                name: string;
+                type: {
+                    vec: string;
+                    defined?: undefined;
+                    array?: undefined;
+                };
+            } | {
+                name: string;
+                type: {
+                    vec: {
+                        defined: {
+                            name: string;
+                        };
+                        vec?: undefined;
+                    };
+                    defined?: undefined;
+                    array?: undefined;
+                };
+            } | {
+                name: string;
+                type: {
+                    vec: {
+                        vec: {
+                            defined: {
+                                name: string;
+                            };
+                        };
+                        defined?: undefined;
+                    };
+                    defined?: undefined;
+                    array?: undefined;
+                };
+            })[];
+            variants?: undefined;
+        };
+        docs?: undefined;
+    } | {
+        name: string;
+        type: {
+            kind: string;
+            fields: ({
+                name: string;
+                type: {
+                    option: {
+                        defined: {
+                            name: string;
+                        };
+                        array?: undefined;
+                        vec?: undefined;
+                    };
+                };
+            } | {
+                name: string;
+                type: {
+                    option: {
+                        array: (string | number)[];
+                        defined?: undefined;
+                        vec?: undefined;
+                    };
+                };
+            } | {
+                name: string;
+                type: {
+                    option: string;
+                };
+            } | {
+                name: string;
+                type: {
+                    option: {
+                        vec: string;
+                        defined?: undefined;
+                        array?: undefined;
+                    };
+                };
+            } | {
+                name: string;
+                type: {
+                    option: {
+                        vec: {
+                            defined: {
+                                name: string;
+                            };
+                        };
+                        defined?: undefined;
+                        array?: undefined;
+                    };
+                };
+            })[];
+            variants?: undefined;
+        };
+        docs?: undefined;
+    })[];
+    constants: {
+        name: string;
+        type: string;
+        value: string;
+    }[];
 };
 export declare function getGlamMintIdl(): {
     address: string;

package/src/index.d.ts

@@ -6,6 +6,7 @@ export * from "./client/jupiter";
 export * from "./client/drift";
 export * from "./client/timelock";
 export * from "./client/cctp";
+export * from "./client/price";
 export * from "./deser/integrationPolicies";
 export * from "./client/base";
 export * from "./assets";

package/src/models/index.d.ts

@@ -1,6 +1,6 @@
-export { StateIdlModel, StateModel, CreatedModel, StateAccountType } from "./state";
+export { StateIdlModel, StateModel, CreatedModel, StateAccountType, } from "./state";
 export type { StateAccount, StateModelType, CreatedModelType } from "./state";
-export { MintIdlModel, MintModel, EmergencyUpdateMintArgs, RequestType } from "./mint";
+export { MintIdlModel, MintModel, EmergencyUpdateMintArgs, RequestType, } from "./mint";
 export type { MintModelType, EmergencyUpdateMintArgsType, FeeStructure, FeeParams, AccruedFees, NotifyAndSettle, } from "./mint";
 export { IntegrationPermissions, ProtocolPermissions, ProtocolPolicy, IntegrationAcl, DelegateAcl, EmergencyAccessUpdateArgs, } from "./acl";
 export type { IntegrationPermissionsType, ProtocolPermissionsType, ProtocolPolicyType, IntegrationAclType, DelegateAclType, EmergencyAccessUpdateArgsType, } from "./acl";

package/src/models/state.d.ts

@@ -21,6 +21,8 @@ export declare class StateIdlModel implements StateModelType {
     owner: PublicKey | null;
     portfolioManagerName: number[] | null;
     borrowable: PublicKey[] | null;
+    reduceOnly: boolean | null;
+    anyLst: boolean | null;
     timelockDuration: number | null;
     integrationAcls: IntegrationAcl[] | null;
     delegateAcls: DelegateAcl[] | null;

package/src/react/cluster-provider.d.ts

@@ -1,6 +1,6 @@
 import { ReactNode } from "react";
 import { ClusterNetwork } from "../clientConfig";
-interface Cluster {
+export interface Cluster {
     name: string;
     endpoint: string;
     network?: ClusterNetwork;
@@ -18,4 +18,5 @@ export declare function ClusterProvider({ children }: {
     children: ReactNode;
 }): import("react/jsx-runtime").JSX.Element;
 export declare function useCluster(): ClusterProviderContext;
+export declare function getClusterUrlParam(cluster: Cluster): string;
 export {};

package/src/react/glam.d.ts

@@ -3,7 +3,8 @@ import { GlamClient } from "../client";
 import { PublicKey } from "@solana/web3.js";
 import { DriftMarketConfigs } from "../client/drift";
 import { TokenAccount } from "../client/base";
-import { TokenListItem, TokenPrice } from "../utils/jupiterApi";
+import { JupTokenList } from "../utils/jupiterApi";
+import { VaultHoldings } from "../client/price";
 import { DriftUser } from "../deser";
 declare global {
     interface Window {
@@ -15,13 +16,13 @@ declare global {
 interface GlamProviderContext {
     glamClient: GlamClient;
     vault: Vault;
+    vaultHoldings?: VaultHoldings;
     activeGlamState?: GlamStateCache;
     glamStatesList: GlamStateCache[];
     delegateAcls: DelegateAcl[];
     integrationAcls: IntegrationAcl[];
     allGlamStates: StateModel[];
-    prices: TokenPrice[];
-    jupTokenList: TokenListItem[];
+    jupTokenList?: JupTokenList;
     driftMarketConfigs?: DriftMarketConfigs;
     setActiveGlamState: (f: GlamStateCache) => void;
     refresh: () => Promise<void>;

package/src/utils/bitmask.d.ts

@@ -36,3 +36,14 @@ export declare function parseProtocolPermissionsBitmask(integrationProgram: Publ
         name: string;
     }[];
 };
+/**
+ * Given the protocol name and a list of permission names, returns the permissions bitmask.
+ */
+export declare function parsePermissionNames({ protocolName, permissionNames, }: {
+    protocolName: string;
+    permissionNames: string[];
+}): {
+    integrationProgram: PublicKey;
+    protocolBitflag: number;
+    permissionsBitmask: BN;
+};