@lifi/perps-sdk 0.2.0-alpha.0 → 1.0.0

package/dist/cjs/client/PerpsClient.js

@@ -2,19 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PerpsClient = void 0;
 const perps_types_1 = require("@lifi/perps-types");
-const viem_1 = require("viem");
-const storage_js_1 = require("../agent/storage.js");
 const PerpsError_js_1 = require("../errors/PerpsError.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;
+const requireProvider_js_1 = require("./requireProvider.js");
 function findActionDescriptor(metadata, action) {
     const descriptor = [
         ...metadata.setup,
@@ -28,64 +22,26 @@ function findActionDescriptor(metadata, action) {
 }
 class PerpsClient {
     sdkClient;
-    storage;
-    signingModes = new Map();
     providerMetadataCache = new Map();
-    _signer;
-    lighterConfig;
-    lighterReadOnlyTokenOptions;
-    _lighterSigner;
-    _lighterKeyStore;
-    _lighterReadOnlyTokenManager;
+    _userWallet;
     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: 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,
+    setUserWallet(userWallet) {
+        this._userWallet = userWallet;
+        Object.defineProperty(this.sdkClient, 'userWallet', {
+            get: () => this._userWallet,
             configurable: true,
         });
     }
     get client() {
         return this.sdkClient;
     }
-    modeKey(address, provider) {
-        return `${address.toLowerCase()}:${provider.toLowerCase()}`;
-    }
-    signingModeStorageKey(address, provider) {
-        return `lifi-perps-mode:${address.toLowerCase()}:${provider.toLowerCase()}`;
-    }
     async getProviderMetadata(provider) {
         const cached = this.providerMetadataCache.get(provider);
         if (cached) {
@@ -103,368 +59,64 @@ class PerpsClient {
         }
         return metadata;
     }
-    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 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 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));
+    requireProvider(provider) {
+        return (0, requireProvider_js_1.requireProvider)(this.sdkClient, provider);
     }
-    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 resolveActionRequest(provider, descriptor, address) {
+        const plugin = this.requireProvider(provider);
+        if (typeof plugin.resolveActionRequest !== 'function') {
+            return {};
         }
+        return plugin.resolveActionRequest(descriptor.type, address, descriptor.signers);
     }
-    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),
-            };
-        }
-        if ('wasmSignParams' in step) {
-            const [signed] = await this.signWasmBlobActions(provider, address, [step]);
-            return signed;
+    async delegateSignActions(provider, address, descriptor, actions) {
+        const plugin = this.requireProvider(provider);
+        if (typeof plugin.signActions !== 'function') {
+            throw new PerpsError_js_1.PerpsError(perps_types_1.PerpsErrorCode.SDKError, `Provider '${provider}' does not implement signActions for ` +
+                `signingMethod '${descriptor.signingMethod}'.`);
         }
-        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.');
+        return plugin.signActions(descriptor.signingMethod, actions, address, this.buildSignActionsContext(descriptor));
     }
-    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).');
+    buildSignActionsContext(descriptor) {
+        const ctx = { signers: descriptor.signers };
+        if (this.sdkClient.userWallet !== undefined) {
+            ctx.userWallet = this.sdkClient.userWallet;
         }
-        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 signed;
+        return ctx;
     }
-    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));
-            }
-        }
+    async signProviderSetupAction(provider, address, step) {
+        const metadata = await this.getProviderMetadata(provider);
+        const descriptor = findActionDescriptor(metadata, step.action);
+        const [signed] = await this.delegateSignActions(provider, address, descriptor, [step]);
         return signed;
     }
-    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.');
-        }
-        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 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 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 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 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;
-            }
-        }
-        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,
-        });
-    }
-    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 isLighterReadOnlyTokenExpiringSoon(address, accountIndex, thresholdDays) {
-        return this.getLighterReadOnlyTokenManager().isReadOnlyTokenExpiringSoon(address, accountIndex, thresholdDays);
-    }
     async buildAction(action, params) {
-        const signerAddress = await this.resolveSignerForAction(action, params.address, params.provider);
+        const metadata = await this.getProviderMetadata(params.provider);
+        const descriptor = findActionDescriptor(metadata, action);
+        const { signerAddress, params: signerParams } = await this.resolveActionRequest(params.provider, descriptor, params.address);
         return (0, createAction_js_1.createAction)(this.sdkClient, {
             provider: params.provider,
             address: params.address,
             signerAddress,
             action,
-            params: params.params,
+            params: {
+                ...params.params,
+                ...signerParams,
+            },
         });
     }
-    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 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 plugin = this.requireProvider(params.provider);
         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);
+        const settings = plugin.projectConfig(response.config, metadata.setup, metadata.options);
         return { ...response, settings };
     }
+    getAccountSummary(account, positions) {
+        return this.requireProvider(account.provider).getAccountSummary(account, positions);
+    }
     async accountExists(provider, address) {
         try {
             await (0, getAccount_js_1.getAccount)(this.sdkClient, { provider, address });
@@ -480,192 +132,82 @@ class PerpsClient {
     }
     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 === types_js_1.SigningMode.USER_AGENT && usesAgent) {
-            const agent = await this.sdkClient.agentManager.getOrCreateAgent(address, provider);
-            agentAddress = agent.address;
-        }
-        const allInputs = this.buildPrerequisiteInputs(metadata.setup, mode, agentAddress);
-        if (allInputs.length === 0) {
-            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.buildPrerequisites({
-            provider,
-            address,
-            signerAddress: agentAddress,
-        });
-        if (actions.length === 0) {
-            return { userPrerequisites: [], agentPrerequisites: [], isReady: true };
-        }
-        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);
-        });
+        const { actions } = await this.buildProviderSetup({ provider, address });
         return {
-            userPrerequisites,
-            agentPrerequisites,
-            isReady: false,
+            setup: actions,
+            isReady: actions.length === 0,
         };
     }
-    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);
+    async buildProviderSetup(params) {
+        const { provider, address } = params;
+        const metadata = await this.getProviderMetadata(provider);
+        const orderedSetup = [...metadata.setup].sort((a, b) => (a.sequence ?? Number.MAX_SAFE_INTEGER) -
+            (b.sequence ?? Number.MAX_SAFE_INTEGER));
+        const plugin = this.sdkClient.getProvider(provider);
         const allActions = [];
-        for (const input of allInputs) {
+        for (const descriptor of orderedSetup) {
+            const action = descriptor.type;
+            const { signerAddress, params: signerParams } = await this.resolveActionRequest(provider, descriptor, address);
+            const localParams = plugin?.resolveSetupParams
+                ? await plugin.resolveSetupParams(action, address)
+                : {};
             const { actions } = await (0, createAction_js_1.createAction)(this.sdkClient, {
-                provider: params.provider,
-                address: params.address,
+                provider,
+                address,
                 signerAddress,
-                action: input.key,
-                params: (input.params ?? {}),
+                action,
+                params: {
+                    ...signerParams,
+                    ...localParams,
+                },
             });
             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 };
+    async executeProviderSetup(params) {
+        const { provider, address, setup, signedActions } = params;
+        if (signedActions.length === 0) {
+            return { results: { results: [] } };
         }
-        const { actions: fallbackActions } = await (0, createAction_js_1.createAction)(this.sdkClient, {
+        const action = setup[0]?.action ?? signedActions[0].action;
+        const metadata = await this.getProviderMetadata(provider);
+        const descriptor = findActionDescriptor(metadata, action);
+        const { signerAddress } = await this.resolveActionRequest(provider, descriptor, address);
+        const results = await (0, executeAction_js_1.executeAction)(this.sdkClient, {
             provider,
             address,
-            action: perps_types_1.ActionType.ACCOUNT_MODE,
-            params: { mode },
+            signerAddress: signerAddress ?? address,
+            action,
+            actions: signedActions,
         });
-        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;
+        const failure = results.results.find((r) => !r.success);
+        if (failure) {
+            throw new PerpsError_js_1.PerpsError(perps_types_1.PerpsErrorCode.ExchangeRejected, failure.error);
         }
-        if (!modeParam.values || modeParam.values.length === 0) {
-            return false;
-        }
-        return !modeParam.readOnly;
+        return { results };
     }
-    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 === types_js_1.SigningMode.USER_AGENT
-                ? (await this.sdkClient.agentManager.getAgent(address, provider))
-                    .address
-                : address;
-            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 mandatoryFailure = userResults.results.find((r) => !r.success);
-            if (mandatoryFailure) {
-                return { userResults };
-            }
-        }
-        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;
-                }
-            }
+    async executeProviderSetupAction(params) {
+        const { provider, address, step } = params;
+        const metadata = await this.getProviderMetadata(provider);
+        const descriptor = metadata.setup.find((d) => d.type === step.action);
+        if (!descriptor) {
+            throw new PerpsError_js_1.PerpsError(perps_types_1.PerpsErrorCode.SDKError, `Action '${step.action}' is not in '${provider}'.setup`);
         }
-        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 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,
-            });
-            agentResults = {
-                results: [...(agentResults?.results ?? []), ...stagedResults.results],
-            };
+        const signed = await this.signProviderSetupAction(provider, address, step);
+        await this.executeProviderSetup({
+            provider,
+            address,
+            setup: [step],
+            signedActions: [signed],
+        });
+    }
+    async executeProviderOption(params) {
+        const { results } = await this.execute(params);
+        const failure = results.find((r) => !r.success);
+        if (failure) {
+            throw new PerpsError_js_1.PerpsError(perps_types_1.PerpsErrorCode.ExchangeRejected, failure.error);
         }
-        return {
-            userResults,
-            ...(agentResults ? { agentResults } : {}),
-            ...(fallbackUserPrerequisites ? { fallbackUserPrerequisites } : {}),
-        };
     }
     async placeOrder(params) {
         return this.execute({ ...params, action: perps_types_1.ActionType.PLACE_ORDER, params });
@@ -699,29 +241,28 @@ class PerpsClient {
         });
     }
     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;
-            }
-        }
-        throw lastError;
+        const { provider, address, action } = params;
+        const metadata = await this.getProviderMetadata(provider);
+        const descriptor = findActionDescriptor(metadata, action);
+        const { signerAddress, params: signerParams } = await this.resolveActionRequest(provider, descriptor, address);
+        const { actions } = await (0, createAction_js_1.createAction)(this.sdkClient, {
+            provider,
+            address,
+            signerAddress,
+            action,
+            params: {
+                ...params.params,
+                ...signerParams,
+            },
+        });
+        const signedActions = await this.delegateSignActions(provider, address, descriptor, actions);
+        return (0, executeAction_js_1.executeAction)(this.sdkClient, {
+            provider,
+            address,
+            signerAddress: signerAddress ?? address,
+            action,
+            actions: signedActions,
+        });
     }
 }
 exports.PerpsClient = PerpsClient;