@lifi/perps-sdk 0.1.1-alpha.8 → 0.2.0-alpha.0

package/dist/cjs/client/PerpsClient.js

@@ -2,257 +2,726 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PerpsClient = void 0;
 const perps_types_1 = require("@lifi/perps-types");
-const registry_js_1 = require("../dex/registry.js");
-const constants_js_1 = require("../errors/constants.js");
+const viem_1 = require("viem");
+const storage_js_1 = require("../agent/storage.js");
 const PerpsError_js_1 = require("../errors/PerpsError.js");
-const cancelOrder_js_1 = require("../services/cancelOrder.js");
-const createAuthorization_js_1 = require("../services/createAuthorization.js");
-const createOrder_js_1 = require("../services/createOrder.js");
-const createWithdrawal_js_1 = require("../services/createWithdrawal.js");
-const submitAuthorization_js_1 = require("../services/submitAuthorization.js");
-const submitOrder_js_1 = require("../services/submitOrder.js");
-const submitWithdrawal_js_1 = require("../services/submitWithdrawal.js");
+const createAction_js_1 = require("../services/createAction.js");
+const executeAction_js_1 = require("../services/executeAction.js");
+const getAccount_js_1 = require("../services/getAccount.js");
+const getProviders_js_1 = require("../services/getProviders.js");
+const index_js_1 = require("../signers/lighter/index.js");
 const signTypedData_js_1 = require("../utils/signTypedData.js");
 const createPerpsClient_js_1 = require("./createPerpsClient.js");
+const projectAccountConfigSettings_js_1 = require("./projectAccountConfigSettings.js");
+const types_js_1 = require("./types.js");
+const MAX_NONCE_RETRIES = 3;
+function findActionDescriptor(metadata, action) {
+    const descriptor = [
+        ...metadata.setup,
+        ...metadata.options,
+        ...metadata.actions,
+    ].find((d) => d.type === action);
+    if (!descriptor) {
+        throw new PerpsError_js_1.PerpsError(perps_types_1.PerpsErrorCode.SDKError, `Provider '${metadata.key}' does not declare action '${action}'.`);
+    }
+    return descriptor;
+}
 class PerpsClient {
     sdkClient;
+    storage;
     signingModes = new Map();
+    providerMetadataCache = new Map();
+    _signer;
+    lighterConfig;
+    lighterReadOnlyTokenOptions;
+    _lighterSigner;
+    _lighterKeyStore;
+    _lighterReadOnlyTokenManager;
     constructor(options) {
+        this.storage = options.storage ?? storage_js_1.localStorageAdapter;
+        this.lighterConfig = options.lighter;
+        this.lighterReadOnlyTokenOptions = options.lighterReadOnlyToken;
         this.sdkClient = (0, createPerpsClient_js_1.createPerpsClient)({
             integrator: options.integrator,
             apiKey: options.apiKey,
             apiUrl: options.apiUrl,
-            storage: options.storage,
+            storage: this.storage,
+            providers: options.providers,
+        });
+    }
+    getLighterSigner() {
+        if (!this._lighterSigner) {
+            this._lighterSigner = new index_js_1.LighterSigner(this.lighterConfig);
+        }
+        return this._lighterSigner;
+    }
+    getLighterKeyStore() {
+        if (!this._lighterKeyStore) {
+            this._lighterKeyStore = new index_js_1.LighterKeyStore(this.storage);
+        }
+        return this._lighterKeyStore;
+    }
+    getLighterReadOnlyTokenManager() {
+        if (!this._lighterReadOnlyTokenManager) {
+            this._lighterReadOnlyTokenManager = new index_js_1.LighterReadOnlyTokenManager({
+                storage: this.storage,
+                ...this.lighterReadOnlyTokenOptions,
+            });
+        }
+        return this._lighterReadOnlyTokenManager;
+    }
+    setSigner(signer) {
+        this._signer = signer;
+        Object.defineProperty(this.sdkClient, 'signer', {
+            get: () => this._signer,
+            configurable: true,
         });
     }
     get client() {
         return this.sdkClient;
     }
-    modeKey(address, dex) {
-        return `${address.toLowerCase()}:${dex.toLowerCase()}`;
+    modeKey(address, provider) {
+        return `${address.toLowerCase()}:${provider.toLowerCase()}`;
     }
-    async setSigningMode(address, dex, mode) {
-        const key = this.modeKey(address, dex);
-        this.signingModes.set(key, mode);
-        if (mode === 'USER_AGENT') {
-            await this.sdkClient.agentManager.getOrCreateAgent(address, dex);
+    signingModeStorageKey(address, provider) {
+        return `lifi-perps-mode:${address.toLowerCase()}:${provider.toLowerCase()}`;
+    }
+    async getProviderMetadata(provider) {
+        const cached = this.providerMetadataCache.get(provider);
+        if (cached) {
+            return cached;
+        }
+        const { providers } = await (0, getProviders_js_1.getProviders)(this.sdkClient);
+        for (const d of providers) {
+            this.providerMetadataCache.set(d.key, d);
         }
+        const metadata = this.providerMetadataCache.get(provider);
+        if (!metadata) {
+            const error = new PerpsError_js_1.PerpsError(perps_types_1.PerpsErrorCode.SDKError, `Unsupported provider: ${provider}`);
+            error.tool = '@lifi/perps-sdk';
+            throw error;
+        }
+        return metadata;
     }
-    getSigningMode(address, dex) {
-        return this.signingModes.get(this.modeKey(address, dex)) ?? 'USER';
+    static EXPLICIT_INPUT_PREREQUISITES = new Set([perps_types_1.ActionType.ACCOUNT_MODE, perps_types_1.ActionType.ACCOUNT_TYPE]);
+    buildPrerequisiteInputs(prerequisites, mode, agentAddress) {
+        return prerequisites
+            .filter((p) => {
+            if (PerpsClient.EXPLICIT_INPUT_PREREQUISITES.has(p.type)) {
+                return false;
+            }
+            if (mode === types_js_1.SigningMode.USER) {
+                if (!p.signers.includes(perps_types_1.PerpsSigner.USER)) {
+                    return false;
+                }
+                if (p.type === perps_types_1.ActionType.APPROVE_AGENT) {
+                    return false;
+                }
+                return true;
+            }
+            return true;
+        })
+            .map((p) => {
+            const params = {};
+            if (p.type === perps_types_1.ActionType.APPROVE_AGENT && agentAddress) {
+                params.agentAddress = agentAddress;
+            }
+            return {
+                key: p.type,
+                ...(Object.keys(params).length > 0 ? { params } : {}),
+            };
+        });
     }
-    async getAgentAddress(address, dex) {
-        const agent = await this.sdkClient.agentManager.getAgent(address, dex);
+    async resolveSignerForAction(action, address, provider) {
+        const mode = await this.loadSigningMode(address, provider);
+        if (mode !== types_js_1.SigningMode.USER_AGENT) {
+            return undefined;
+        }
+        const metadata = await this.getProviderMetadata(provider);
+        const allActions = [
+            ...metadata.setup,
+            ...metadata.options,
+            ...metadata.actions,
+        ];
+        const descriptor = allActions.find((d) => d.type === action);
+        if (!descriptor?.signers.includes(perps_types_1.PerpsSigner.AGENT)) {
+            return undefined;
+        }
+        const agent = await this.sdkClient.agentManager.getAgent(address, provider);
         return agent.address;
     }
-    async hasAgent(address, dex) {
-        return this.sdkClient.agentManager.hasAgent(address, dex);
+    async providerUsesAgent(provider) {
+        const metadata = await this.getProviderMetadata(provider);
+        const all = [...metadata.setup, ...metadata.options, ...metadata.actions];
+        return all.some((d) => d.signers.includes(perps_types_1.PerpsSigner.AGENT));
     }
-    async removeAgent(address, dex) {
-        await this.sdkClient.agentManager.removeAgent(address, dex);
-        this.signingModes.delete(this.modeKey(address, dex));
+    async autoSignAndExecute(provider, address, action, actions, descriptor) {
+        switch (descriptor.signingMethod) {
+            case perps_types_1.SigningMethod.EIP712: {
+                const eip712Actions = actions;
+                if (descriptor.signers.includes(perps_types_1.PerpsSigner.AGENT)) {
+                    const agent = await this.sdkClient.agentManager.getAgent(address, provider);
+                    const signedActions = await Promise.all(eip712Actions.map(async (a) => ({
+                        action: a.action,
+                        typedData: a.typedData,
+                        signature: await (0, signTypedData_js_1.signTypedData)(agent.privateKey, a.typedData),
+                    })));
+                    return (0, executeAction_js_1.executeAction)(this.sdkClient, {
+                        provider,
+                        address,
+                        signerAddress: agent.address,
+                        action,
+                        actions: signedActions,
+                    });
+                }
+                if (descriptor.signers.includes(perps_types_1.PerpsSigner.USER)) {
+                    const signer = this.sdkClient.signer;
+                    if (!signer) {
+                        throw new PerpsError_js_1.PerpsError(perps_types_1.PerpsErrorCode.SDKError, `Action '${action}' requires a user-wallet signature, but no signer was configured. Pass a WalletClient to createPerpsClient({ signer }).`);
+                    }
+                    const signedActions = await Promise.all(eip712Actions.map(async (a) => ({
+                        action: a.action,
+                        typedData: a.typedData,
+                        signature: await (0, signTypedData_js_1.signTypedDataWithSigner)(signer, a.typedData),
+                    })));
+                    return (0, executeAction_js_1.executeAction)(this.sdkClient, {
+                        provider,
+                        address,
+                        signerAddress: address,
+                        action,
+                        actions: signedActions,
+                    });
+                }
+                throw new PerpsError_js_1.PerpsError(perps_types_1.PerpsErrorCode.SDKError, `Action '${action}' descriptor names no supported signer (signers=[${descriptor.signers.join(', ')}]).`);
+            }
+            case perps_types_1.SigningMethod.WASM_BLOB: {
+                const wasmActions = actions;
+                const signedActions = await this.signWasmBlobActions(provider, address, wasmActions);
+                return (0, executeAction_js_1.executeAction)(this.sdkClient, {
+                    provider,
+                    address,
+                    signerAddress: address,
+                    action,
+                    actions: signedActions,
+                });
+            }
+            case perps_types_1.SigningMethod.EVM_TX: {
+                const evmActions = actions;
+                const signedActions = await this.signEvmTxActions(evmActions);
+                return (0, executeAction_js_1.executeAction)(this.sdkClient, {
+                    provider,
+                    address,
+                    signerAddress: address,
+                    action,
+                    actions: signedActions,
+                });
+            }
+            default:
+                throw new Error(`Unknown signingMethod: ${descriptor.signingMethod}`);
+        }
     }
-    async buildAuthorization(params) {
-        const mode = this.getSigningMode(params.address, params.dex);
-        let { signerAddress } = params;
-        if (mode === 'USER_AGENT') {
-            const agent = await this.sdkClient.agentManager.getAgent(params.address, params.dex);
-            signerAddress = signerAddress ?? agent.address;
+    async signPrerequisite(provider, address, step) {
+        if ('typedData' in step) {
+            if (!this.sdkClient.signer) {
+                throw new PerpsError_js_1.PerpsError(perps_types_1.PerpsErrorCode.SDKError, 'EIP-712 prerequisite signing requires a wallet signer. Pass ' +
+                    '`signer` to createPerpsClient or call setSigner(walletClient).');
+            }
+            return {
+                action: step.action,
+                typedData: step.typedData,
+                signature: await (0, signTypedData_js_1.signTypedDataWithSigner)(this.sdkClient.signer, step.typedData),
+            };
         }
-        return (0, createAuthorization_js_1.createAuthorization)(this.sdkClient, {
-            ...params,
-            signerAddress,
-        });
+        if ('wasmSignParams' in step) {
+            const [signed] = await this.signWasmBlobActions(provider, address, [step]);
+            return signed;
+        }
+        if ('txParams' in step) {
+            const [signed] = await this.signEvmTxActions([step]);
+            return signed;
+        }
+        throw new PerpsError_js_1.PerpsError(perps_types_1.PerpsErrorCode.SDKError, 'Unknown ActionStep shape — expected typedData, wasmSignParams, or txParams.');
     }
-    async submitAuthorizations(params) {
-        const mode = this.getSigningMode(params.address, params.dex);
-        let { signerAddress } = params;
-        if (mode === 'USER_AGENT') {
-            const agent = await this.sdkClient.agentManager.getAgent(params.address, params.dex);
-            signerAddress = signerAddress ?? agent.address;
+    async signEvmTxActions(actions) {
+        if (!this.sdkClient.signer) {
+            throw new PerpsError_js_1.PerpsError(perps_types_1.PerpsErrorCode.SDKError, 'EVM_TX signing requires a wallet signer. Pass `signer` to ' +
+                'createPerpsClient or call setSigner(walletClient).');
+        }
+        const { signer } = this.sdkClient;
+        const signed = [];
+        for (const step of actions) {
+            const params = step.txParams;
+            const txHash = await signer.writeContract({
+                address: params.to,
+                abi: (0, viem_1.parseAbi)(params.abi),
+                functionName: params.functionName,
+                args: params.args,
+                chain: signer.chain,
+                account: signer.account,
+            });
+            signed.push({
+                action: step.action,
+                txParams: step.txParams,
+                txHash,
+            });
         }
-        return (0, submitAuthorization_js_1.submitAuthorization)(this.sdkClient, { ...params, signerAddress });
+        return signed;
     }
-    async buildOrder(params) {
-        const mode = this.getSigningMode(params.address, params.dex);
-        let signerAddress;
-        if (mode === 'USER_AGENT') {
-            const agent = await this.sdkClient.agentManager.getAgent(params.address, params.dex);
-            signerAddress = agent.address;
+    async signWasmBlobActions(provider, address, actions) {
+        const signed = [];
+        for (const step of actions) {
+            if (step.action === perps_types_1.ActionType.REGISTER_API_KEY) {
+                signed.push(await this.signRegisterApiKey(provider, address, step));
+            }
+            else if (step.action === perps_types_1.ActionType.ACCOUNT_TYPE) {
+                signed.push(await this.signAccountTierChange(address, step));
+            }
+            else {
+                signed.push(await this.signStandardWasmAction(provider, address, step));
+            }
         }
-        return (0, createOrder_js_1.createOrder)(this.sdkClient, {
-            dex: params.dex,
-            address: params.address,
-            signerAddress,
-            clientOrderId: params.clientOrderId,
-            symbol: params.symbol,
-            side: params.side,
-            type: params.type,
-            size: params.size,
-            price: params.price,
-            leverage: params.leverage,
-            reduceOnly: params.reduceOnly,
-            timeInForce: params.timeInForce,
-            expiresAt: params.expiresAt,
-            takeProfit: params.takeProfit,
-            stopLoss: params.stopLoss,
-        });
+        return signed;
     }
-    async buildCancelOrder(params) {
-        const mode = this.getSigningMode(params.address, params.dex);
-        let signerAddress;
-        if (mode === 'USER_AGENT') {
-            const agent = await this.sdkClient.agentManager.getAgent(params.address, params.dex);
-            signerAddress = agent.address;
+    async signStandardWasmAction(provider, address, step) {
+        const apiKey = await this.getLighterKeyStore().get(address);
+        if (!apiKey) {
+            throw new PerpsError_js_1.PerpsError(perps_types_1.PerpsErrorCode.SDKError, `No Lighter API key registered for ${address}. ` +
+                'Run prepareAccount / REGISTER_API_KEY first.');
         }
-        return (0, cancelOrder_js_1.cancelOrder)(this.sdkClient, {
-            dex: params.dex,
-            address: params.address,
-            signerAddress,
-            ids: params.ids,
+        const signer = this.getLighterSigner();
+        const signedTx = await signer.sign(step.action, step.wasmSignParams, {
+            apiKeyPrivateKey: apiKey.apiKeyPrivateKey,
+            apiKeyIndex: apiKey.apiKeyIndex,
+            accountIndex: apiKey.accountIndex,
         });
+        void provider;
+        return {
+            action: step.action,
+            wasmSignParams: step.wasmSignParams,
+            signedTx,
+        };
     }
-    async placeOrder(params) {
-        const mode = this.getSigningMode(params.address, params.dex);
-        if (mode !== 'USER_AGENT') {
-            throw new PerpsError_js_1.PerpsError(perps_types_1.PerpsErrorCode.ValidationError, `${constants_js_1.PerpsErrorMessage.InvalidSigningMode} placeOrder() requires USER_AGENT mode. Use createOrder() + submitOrder() for USER mode.`);
+    async signRegisterApiKey(provider, address, step) {
+        if (!this.sdkClient.signer) {
+            throw new PerpsError_js_1.PerpsError(perps_types_1.PerpsErrorCode.SDKError, 'REGISTER_API_KEY requires a wallet signer — pass `signer` to ' +
+                'createPerpsClient or call setSigner(walletClient).');
         }
-        const agent = await this.sdkClient.agentManager.getAgent(params.address, params.dex);
-        const { actions } = await (0, createOrder_js_1.createOrder)(this.sdkClient, {
-            dex: params.dex,
-            address: params.address,
-            signerAddress: agent.address,
-            clientOrderId: params.clientOrderId,
-            symbol: params.symbol,
-            side: params.side,
-            type: params.type,
-            size: params.size,
-            price: params.price,
-            leverage: params.leverage,
-            reduceOnly: params.reduceOnly,
-            timeInForce: params.timeInForce,
-            expiresAt: params.expiresAt,
-            takeProfit: params.takeProfit,
-            stopLoss: params.stopLoss,
+        const params = step.wasmSignParams;
+        const apiKeyIndex = params.api_key_index ?? index_js_1.DEFAULT_API_KEY_INDEX;
+        const nonce = params.nonce;
+        if (typeof nonce !== 'number') {
+            throw new PerpsError_js_1.PerpsError(perps_types_1.PerpsErrorCode.SDKError, 'REGISTER_API_KEY wasmSignParams is missing `nonce`.');
+        }
+        const account = await (0, getAccount_js_1.getAccount)(this.sdkClient, { provider, address });
+        if (account.config.provider !== 'lighter') {
+            throw new PerpsError_js_1.PerpsError(perps_types_1.PerpsErrorCode.SDKError, `REGISTER_API_KEY requires a Lighter account, but getAccount ` +
+                `returned config for provider '${account.config.provider}'.`);
+        }
+        const accountIndex = account.config.accountIndex;
+        const signer = this.getLighterSigner();
+        const keypair = await signer.generateAPIKey();
+        const changePubKey = await signer.signChangePubKey(keypair.publicKey, keypair.privateKey, nonce, apiKeyIndex, accountIndex);
+        const l1Signature = await this.sdkClient.signer.signMessage({
+            account: this.sdkClient.signer.account,
+            message: changePubKey.messageToSign,
         });
-        const signedActions = await Promise.all(actions.map(async (a) => ({
-            action: a.action,
-            typedData: a.typedData,
-            signature: await (0, signTypedData_js_1.signTypedData)(agent.privateKey, a.typedData),
-        })));
-        return (0, submitOrder_js_1.submitOrder)(this.sdkClient, {
-            dex: params.dex,
-            address: params.address,
-            signerAddress: agent.address,
-            actions: signedActions,
+        const txInfoWithL1Sig = signer.embedL1Signature(changePubKey.txInfo, l1Signature);
+        const apiKey = {
+            accountIndex,
+            apiKeyIndex,
+            apiKeyPrivateKey: keypair.privateKey,
+            apiKeyPublicKey: keypair.publicKey,
+        };
+        await this.getLighterKeyStore().set(address, apiKey);
+        return {
+            action: step.action,
+            wasmSignParams: {
+                ...step.wasmSignParams,
+                new_public_key: keypair.publicKey,
+            },
+            signedTx: {
+                txType: changePubKey.txType,
+                txInfo: txInfoWithL1Sig,
+                txHash: changePubKey.txHash,
+            },
+        };
+    }
+    async signAccountTierChange(address, step) {
+        const apiKey = await this.getLighterKeyStore().get(address);
+        if (!apiKey) {
+            throw new PerpsError_js_1.PerpsError(perps_types_1.PerpsErrorCode.SDKError, `No Lighter API key registered for ${address}. ` +
+                'Run prepareAccount / REGISTER_API_KEY first.');
+        }
+        const signer = this.getLighterSigner();
+        const deadline = Math.floor(Date.now() / 1000) + 60 * 60;
+        const authToken = await signer.createAuthToken(deadline, {
+            apiKeyPrivateKey: apiKey.apiKeyPrivateKey,
+            apiKeyIndex: apiKey.apiKeyIndex,
+            accountIndex: apiKey.accountIndex,
         });
+        return {
+            action: step.action,
+            wasmSignParams: step.wasmSignParams,
+            signedTx: {
+                txType: 0,
+                txInfo: authToken,
+                txHash: '',
+            },
+        };
     }
-    async cancelOrders(params) {
-        const mode = this.getSigningMode(params.address, params.dex);
-        if (mode !== 'USER_AGENT') {
-            throw new PerpsError_js_1.PerpsError(perps_types_1.PerpsErrorCode.ValidationError, `${constants_js_1.PerpsErrorMessage.InvalidSigningMode} cancelOrders() requires USER_AGENT mode. Use cancelOrder() + submitOrder() for USER mode.`);
+    async createLighterAuthToken(address, deadlineSeconds, accountIndex) {
+        const apiKey = await this.getLighterKeyStore().get(address);
+        const resolvedAccountIndex = accountIndex ?? apiKey?.accountIndex;
+        if (resolvedAccountIndex !== undefined) {
+            const stored = await this.getLighterReadOnlyTokenManager().get(address, resolvedAccountIndex);
+            if (stored) {
+                return stored.token;
+            }
         }
-        const agent = await this.sdkClient.agentManager.getAgent(params.address, params.dex);
-        const { actions } = await (0, cancelOrder_js_1.cancelOrder)(this.sdkClient, {
-            dex: params.dex,
-            address: params.address,
-            signerAddress: agent.address,
-            ids: params.ids,
+        if (!apiKey) {
+            return undefined;
+        }
+        const deadline = deadlineSeconds ?? Math.floor(Date.now() / 1000) + 60 * 60;
+        const signer = this.getLighterSigner();
+        return signer.createAuthToken(deadline, {
+            apiKeyPrivateKey: apiKey.apiKeyPrivateKey,
+            apiKeyIndex: apiKey.apiKeyIndex,
+            accountIndex: apiKey.accountIndex,
         });
-        const signedActions = await Promise.all(actions.map(async (a) => ({
-            action: a.action,
-            typedData: a.typedData,
-            signature: await (0, signTypedData_js_1.signTypedData)(agent.privateKey, a.typedData),
-        })));
-        return (0, submitOrder_js_1.submitOrder)(this.sdkClient, {
-            dex: params.dex,
-            address: params.address,
-            signerAddress: agent.address,
-            actions: signedActions,
+    }
+    async approveReadOnlyToken(address, params) {
+        if (!this.sdkClient.signer) {
+            throw new PerpsError_js_1.PerpsError(perps_types_1.PerpsErrorCode.SDKError, 'approveReadOnlyToken requires a wallet signer — pass `signer` to ' +
+                'createPerpsClient or call setSigner(walletClient).');
+        }
+        const signer = (0, index_js_1.walletClientSigner)(this.sdkClient.signer);
+        return this.getLighterReadOnlyTokenManager().approve(signer, {
+            address,
+            ...params,
         });
     }
-    async submitSignedOrder(params) {
-        return (0, submitOrder_js_1.submitOrder)(this.sdkClient, params);
+    async isLighterReadOnlyTokenExpiringSoon(address, accountIndex, thresholdDays) {
+        return this.getLighterReadOnlyTokenManager().isReadOnlyTokenExpiringSoon(address, accountIndex, thresholdDays);
     }
-    async buildWithdrawal(params) {
-        return (0, createWithdrawal_js_1.createWithdrawal)(this.sdkClient, {
-            dex: params.dex,
+    async buildAction(action, params) {
+        const signerAddress = await this.resolveSignerForAction(action, params.address, params.provider);
+        return (0, createAction_js_1.createAction)(this.sdkClient, {
+            provider: params.provider,
             address: params.address,
-            withdrawal: params.withdrawal,
+            signerAddress,
+            action,
+            params: params.params,
         });
     }
-    async submitWithdrawal(params) {
-        return (0, submitWithdrawal_js_1.submitWithdrawal)(this.sdkClient, params);
+    async setSigningMode(address, provider, mode) {
+        const key = this.modeKey(address, provider);
+        this.signingModes.set(key, mode);
+        await this.storage.set(this.signingModeStorageKey(address, provider), mode);
+        if (mode === types_js_1.SigningMode.USER_AGENT &&
+            (await this.providerUsesAgent(provider))) {
+            await this.sdkClient.agentManager.getOrCreateAgent(address, provider);
+        }
+    }
+    getSigningMode(address, provider) {
+        return (this.signingModes.get(this.modeKey(address, provider)) ??
+            types_js_1.SigningMode.USER_AGENT);
+    }
+    async loadSigningMode(address, provider) {
+        const key = this.modeKey(address, provider);
+        if (this.signingModes.has(key)) {
+            return this.signingModes.get(key);
+        }
+        const stored = await this.storage.get(this.signingModeStorageKey(address, provider));
+        const mode = stored === types_js_1.SigningMode.USER_AGENT || stored === types_js_1.SigningMode.USER
+            ? stored
+            : types_js_1.SigningMode.USER_AGENT;
+        this.signingModes.set(key, mode);
+        return mode;
+    }
+    async loadAgentMode(address, provider) {
+        const mode = await this.loadSigningMode(address, provider);
+        return mode === types_js_1.SigningMode.USER_AGENT;
+    }
+    async setAgentMode(address, provider, useAgent) {
+        await this.setSigningMode(address, provider, useAgent ? types_js_1.SigningMode.USER_AGENT : types_js_1.SigningMode.USER);
+    }
+    async getAgentAddress(address, provider) {
+        const agent = await this.sdkClient.agentManager.getAgent(address, provider);
+        return agent.address;
     }
-    async getRequiredAuthorizations(params) {
-        const { dex, address } = params;
-        const mode = this.getSigningMode(address, dex);
-        const provider = (0, registry_js_1.getDexAuthProvider)(dex);
+    async hasAgent(address, provider) {
+        return this.sdkClient.agentManager.hasAgent(address, provider);
+    }
+    async removeAgent(address, provider) {
+        await this.sdkClient.agentManager.removeAgent(address, provider);
+        this.signingModes.delete(this.modeKey(address, provider));
+        await this.storage.remove(this.signingModeStorageKey(address, provider));
+    }
+    async getAccount(params) {
+        const [response, metadata] = await Promise.all([
+            (0, getAccount_js_1.getAccount)(this.sdkClient, params),
+            this.getProviderMetadata(params.provider),
+        ]);
+        const settings = (0, projectAccountConfigSettings_js_1.projectAccountConfigSettings)(response.config, metadata.setup, metadata.options);
+        return { ...response, settings };
+    }
+    async accountExists(provider, address) {
+        try {
+            await (0, getAccount_js_1.getAccount)(this.sdkClient, { provider, address });
+            return true;
+        }
+        catch (err) {
+            if (err instanceof PerpsError_js_1.PerpsError &&
+                err.code === perps_types_1.PerpsErrorCode.AccountNotFound) {
+                return false;
+            }
+            throw err;
+        }
+    }
+    async checkSetup(params) {
+        const { provider, address } = params;
+        const mode = await this.loadSigningMode(address, provider);
+        const metadata = await this.getProviderMetadata(provider);
+        const usesAgent = [
+            ...metadata.setup,
+            ...metadata.options,
+            ...metadata.actions,
+        ].some((d) => d.signers.includes(perps_types_1.PerpsSigner.AGENT));
         let agentAddress;
-        if (mode === 'USER_AGENT') {
-            const agent = await this.sdkClient.agentManager.getOrCreateAgent(address, dex);
+        if (mode === types_js_1.SigningMode.USER_AGENT && usesAgent) {
+            const agent = await this.sdkClient.agentManager.getOrCreateAgent(address, provider);
             agentAddress = agent.address;
         }
-        const authInputs = provider.getAuthorizationInputs({
-            signingMode: mode,
-            agentAddress,
-        });
-        const allInputs = [...authInputs.user, ...authInputs.agent];
+        const allInputs = this.buildPrerequisiteInputs(metadata.setup, mode, agentAddress);
         if (allInputs.length === 0) {
-            return { userAuthorizations: [], agentAuthorizations: [], isReady: true };
+            return { userPrerequisites: [], agentPrerequisites: [], isReady: true };
+        }
+        const signersByAction = new Map();
+        for (const desc of metadata.setup) {
+            signersByAction.set(desc.type, desc.signers);
         }
-        const { actions } = await this.buildAuthorization({
-            dex,
+        const { actions } = await this.buildPrerequisites({
+            provider,
             address,
-            authorizations: allInputs,
+            signerAddress: agentAddress,
         });
         if (actions.length === 0) {
-            return { userAuthorizations: [], agentAuthorizations: [], isReady: true };
+            return { userPrerequisites: [], agentPrerequisites: [], isReady: true };
         }
-        const agentKeys = new Set(authInputs.agent.map((a) => a.key));
-        const userAuthorizations = actions.filter((a) => !agentKeys.has(a.action));
-        const agentAuthorizations = actions.filter((a) => agentKeys.has(a.action));
+        const userPrerequisites = actions.filter((a) => {
+            const signers = signersByAction.get(a.action) ?? [];
+            return signers.includes(perps_types_1.PerpsSigner.USER);
+        });
+        const agentPrerequisites = actions.filter((a) => {
+            const signers = signersByAction.get(a.action) ?? [];
+            return signers.includes(perps_types_1.PerpsSigner.AGENT);
+        });
         return {
-            userAuthorizations,
-            agentAuthorizations,
+            userPrerequisites,
+            agentPrerequisites,
             isReady: false,
         };
     }
-    async executeAuthorizations(params) {
-        const { dex, address, required, userSignedActions } = params;
-        const mode = this.getSigningMode(address, dex);
+    async buildPrerequisites(params) {
+        const mode = await this.loadSigningMode(params.address, params.provider);
+        let { signerAddress } = params;
+        if (mode === types_js_1.SigningMode.USER_AGENT && !signerAddress) {
+            const agent = await this.sdkClient.agentManager.getAgent(params.address, params.provider);
+            signerAddress = agent.address;
+        }
+        const metadata = await this.getProviderMetadata(params.provider);
+        const allInputs = this.buildPrerequisiteInputs(metadata.setup, mode, signerAddress);
+        const allActions = [];
+        for (const input of allInputs) {
+            const { actions } = await (0, createAction_js_1.createAction)(this.sdkClient, {
+                provider: params.provider,
+                address: params.address,
+                signerAddress,
+                action: input.key,
+                params: (input.params ?? {}),
+            });
+            allActions.push(...actions);
+        }
+        return { actions: allActions };
+    }
+    static DEFAULT_ACCOUNT_MODE = 'unifiedAccount';
+    async prepareAccountModeChange(provider, address, mode) {
+        const account = await (0, getAccount_js_1.getAccount)(this.sdkClient, { provider, address });
+        if (account.config.provider !== 'hyperliquid') {
+            throw new PerpsError_js_1.PerpsError(perps_types_1.PerpsErrorCode.SDKError, `prepareAccountModeChange is Hyperliquid-specific, but ` +
+                `getAccount returned config for provider ` +
+                `'${account.config.provider}'.`);
+        }
+        const currentStatus = account.config.abstractionMode;
+        if (currentStatus === mode) {
+            return {};
+        }
+        if (currentStatus == null) {
+            const agent = await this.sdkClient.agentManager.getAgent(address, provider);
+            const { actions } = await (0, createAction_js_1.createAction)(this.sdkClient, {
+                provider,
+                address,
+                signerAddress: agent.address,
+                action: perps_types_1.ActionType.ACCOUNT_MODE,
+                params: { mode },
+            });
+            if (actions.length === 0) {
+                return { results: { results: [] } };
+            }
+            const signedActions = await Promise.all(actions.map(async (a) => ({
+                action: a.action,
+                typedData: a.typedData,
+                signature: await (0, signTypedData_js_1.signTypedData)(agent.privateKey, a.typedData),
+            })));
+            const results = await (0, executeAction_js_1.executeAction)(this.sdkClient, {
+                provider,
+                address,
+                signerAddress: agent.address,
+                action: perps_types_1.ActionType.ACCOUNT_MODE,
+                actions: signedActions,
+            });
+            return { results };
+        }
+        const { actions: fallbackActions } = await (0, createAction_js_1.createAction)(this.sdkClient, {
+            provider,
+            address,
+            action: perps_types_1.ActionType.ACCOUNT_MODE,
+            params: { mode },
+        });
+        return {
+            fallback: fallbackActions.length > 0 ? fallbackActions : undefined,
+        };
+    }
+    static hasWritableAccountMode(metadata) {
+        const item = [...metadata.setup, ...metadata.options].find((i) => i.type === perps_types_1.ActionType.ACCOUNT_MODE);
+        if (!item) {
+            return false;
+        }
+        const modeParam = item.params.find((p) => p.name === 'mode');
+        if (!modeParam) {
+            return false;
+        }
+        if (!modeParam.values || modeParam.values.length === 0) {
+            return false;
+        }
+        return !modeParam.readOnly;
+    }
+    async satisfySetup(params) {
+        const { provider, address, required, userSignedActions } = params;
+        const mode = await this.loadSigningMode(address, provider);
         let userResults = { results: [] };
         if (userSignedActions.length > 0) {
-            const signerAddress = mode === 'USER_AGENT'
-                ? (await this.sdkClient.agentManager.getAgent(address, dex)).address
+            const signerAddress = mode === types_js_1.SigningMode.USER_AGENT
+                ? (await this.sdkClient.agentManager.getAgent(address, provider))
+                    .address
                 : address;
-            userResults = await (0, submitAuthorization_js_1.submitAuthorization)(this.sdkClient, {
-                dex,
+            const firstAction = required.userPrerequisites[0]?.action;
+            userResults = await (0, executeAction_js_1.executeAction)(this.sdkClient, {
+                provider,
                 address,
                 signerAddress,
+                action: (firstAction ?? perps_types_1.ActionType.APPROVE_AGENT),
                 actions: userSignedActions,
             });
-            const failed = userResults.results.find((r) => !r.success);
-            if (failed) {
+            const mandatoryFailure = userResults.results.find((r) => !r.success);
+            if (mandatoryFailure) {
                 return { userResults };
             }
         }
-        if (required.agentAuthorizations.length > 0 && mode === 'USER_AGENT') {
-            const agent = await this.sdkClient.agentManager.getAgent(address, dex);
-            const signedAgentActions = await Promise.all(required.agentAuthorizations.map(async (action) => ({
+        let agentResults;
+        let fallbackUserPrerequisites;
+        if (mode === types_js_1.SigningMode.USER_AGENT) {
+            const justApprovedAgent = userResults.results.some((r) => r.success && r.action === perps_types_1.ActionType.APPROVE_AGENT);
+            if (justApprovedAgent) {
+                const metadata = await this.getProviderMetadata(provider);
+                if (PerpsClient.hasWritableAccountMode(metadata)) {
+                    const upgrade = await this.prepareAccountModeChange(provider, address, PerpsClient.DEFAULT_ACCOUNT_MODE);
+                    agentResults = upgrade.results;
+                    fallbackUserPrerequisites = upgrade.fallback;
+                }
+            }
+        }
+        if (required.agentPrerequisites.length > 0 &&
+            mode === types_js_1.SigningMode.USER_AGENT) {
+            const agent = await this.sdkClient.agentManager.getAgent(address, provider);
+            const signedAgentActions = await Promise.all(required.agentPrerequisites.map(async (action) => ({
                 action: action.action,
                 typedData: action.typedData,
                 signature: await (0, signTypedData_js_1.signTypedData)(agent.privateKey, action.typedData),
             })));
-            const agentResults = await (0, submitAuthorization_js_1.submitAuthorization)(this.sdkClient, {
-                dex,
+            const firstAction = required.agentPrerequisites[0]?.action;
+            const stagedResults = await (0, executeAction_js_1.executeAction)(this.sdkClient, {
+                provider,
                 address,
                 signerAddress: agent.address,
+                action: (firstAction ?? perps_types_1.ActionType.ACCOUNT_MODE),
                 actions: signedAgentActions,
             });
-            return { userResults, agentResults };
+            agentResults = {
+                results: [...(agentResults?.results ?? []), ...stagedResults.results],
+            };
+        }
+        return {
+            userResults,
+            ...(agentResults ? { agentResults } : {}),
+            ...(fallbackUserPrerequisites ? { fallbackUserPrerequisites } : {}),
+        };
+    }
+    async placeOrder(params) {
+        return this.execute({ ...params, action: perps_types_1.ActionType.PLACE_ORDER, params });
+    }
+    async placeTriggerOrder(params) {
+        return this.execute({
+            ...params,
+            action: perps_types_1.ActionType.PLACE_TRIGGER_ORDER,
+            params,
+        });
+    }
+    async cancelOrders(params) {
+        return this.execute({ ...params, action: perps_types_1.ActionType.CANCEL_ORDER, params });
+    }
+    async modifyOrders(params) {
+        return this.execute({ ...params, action: perps_types_1.ActionType.MODIFY_ORDER, params });
+    }
+    async updatePositionMargin(params) {
+        return this.execute({
+            ...params,
+            action: perps_types_1.ActionType.UPDATE_POSITION_MARGIN,
+            params,
+        });
+    }
+    async withdraw(params) {
+        return this.execute({
+            provider: params.provider,
+            address: params.address,
+            action: perps_types_1.ActionType.WITHDRAWAL,
+            params: params.withdrawal,
+        });
+    }
+    async execute(params) {
+        await this.loadSigningMode(params.address, params.provider);
+        const metadata = await this.getProviderMetadata(params.provider);
+        const descriptor = findActionDescriptor(metadata, params.action);
+        let lastError;
+        for (let attempt = 0; attempt < MAX_NONCE_RETRIES; attempt++) {
+            const { actions } = await this.buildAction(params.action, {
+                provider: params.provider,
+                address: params.address,
+                params: params.params,
+            });
+            try {
+                return await this.autoSignAndExecute(params.provider, params.address, params.action, actions, descriptor);
+            }
+            catch (err) {
+                if (err instanceof PerpsError_js_1.PerpsError &&
+                    err.code === perps_types_1.PerpsErrorCode.InvalidNonce) {
+                    lastError = err;
+                    continue;
+                }
+                throw err;
+            }
         }
-        return { userResults };
+        throw lastError;
     }
 }
 exports.PerpsClient = PerpsClient;