refactor: make delegate public

src/contracts/Contracts.ts

@@ -143,6 +143,7 @@ export class Contracts {
                 contract: value.contract.connect(signer),
             })
         })
+        this.delegateApproval = this.delegateApproval.connect(signer)
     }
 
     createIERC20Token(tokenAddress: string) {

src/core/PerpetualProtocol.ts

@@ -42,6 +42,7 @@ export interface PerpetualProtocolConnected extends PerpetualProtocolInitialized
     positions: Positions
     liquidities: Liquidities
     vault: Vault
+    delegateApproval: DelegateApproval
 }
 
 /**

src/core/clearingHouse/DelegateApproval.ts

@@ -20,7 +20,7 @@ export interface DelegateApprovalConfigs {
 export class DelegateApproval extends Channel<DelegateApprovalEventName> {
     private readonly _contractReader: ContractReader
     private _cache: Map<CacheKey, CacheValue> = new Map()
-    private _delegate: string
+    public delegate: string
 
     constructor(
         protected readonly _perp: PerpetualProtocol,
@@ -29,38 +29,47 @@ export class DelegateApproval extends Channel<DelegateApprovalEventName> {
     ) {
         super(_perp.channelRegistry)
         this._contractReader = _perp.contractReader
-        this._delegate = configs ? configs.delegate : _perp.metadata.contracts.LimitOrderBook.address
+        this.delegate = configs ? configs.delegate : _perp.metadata.contracts.LimitOrderBook.address
     }
 
-    async approveOpenPosition(delegate: string) {
+    async approveOpenPosition() {
         const openPositionAction = await this._perp.contractReader.getClearingHouseOpenPositionAction()
-        await this.approve(delegate, openPositionAction)
+        return this.approve(openPositionAction)
     }
 
-    async approve(delegate: string, actions: number) {
+    async revokeOpenPosition() {
+        const openPositionAction = await this._perp.contractReader.getClearingHouseOpenPositionAction()
+        return this.revoke(openPositionAction)
+    }
+
+    async approve(actions: number) {
         invariant(this._perp.hasConnected(), () => new UnauthorizedError({ functionName: "approve" }))
 
         return getTransaction<ContractDelegateApproval, "approve">({
             account: this._perp.wallet.account,
             contract: this._perp.contracts.delegateApproval,
             contractName: ContractName.DelegateApproval,
             contractFunctionName: "approve",
-            args: [delegate, actions],
+            args: [this.delegate, actions],
         })
     }
 
-    async revoke(delegate: string, actions: number) {
-        invariant(this._perp.hasConnected(), () => new UnauthorizedError({ functionName: "approve" }))
+    async revoke(actions: number) {
+        invariant(this._perp.hasConnected(), () => new UnauthorizedError({ functionName: "revoke" }))
 
         return getTransaction<ContractDelegateApproval, "revoke">({
             account: this._perp.wallet.account,
             contract: this._perp.contracts.delegateApproval,
             contractName: ContractName.DelegateApproval,
             contractFunctionName: "revoke",
-            args: [delegate, actions],
+            args: [this.delegate, actions],
         })
     }
 
+    async delegateApprovalForOpenPosition({ cache = true } = {}) {
+        return await this._fetch("openPosition", { cache })
+    }
+
     protected _getEventSourceMap() {
         const fetchAndEmitDelegateApprovalUpdated = this._createFetchAndEmitDelegateApprovalUpdated()
         const delegateApprovalUpdated = new ChannelEventSource({
@@ -95,7 +104,7 @@ export class DelegateApproval extends Channel<DelegateApprovalEventName> {
         let result
         switch (key) {
             case "openPosition": {
-                result = await this._contractReader.canOpenPositionFor(this.account, this._delegate)
+                result = await this._contractReader.canOpenPositionFor(this.account, this.delegate)
                 break
             }
         }