@derivexyz/derive-ts 3.0.4

package/dist/codecs/index.d.ts

@@ -0,0 +1,264 @@
+import { D as DecimalLike, P as ProtocolScopeCode } from '../scopes-RzGb3xH6.js';
+import { D as Direction } from '../generated-DwMaydIF.js';
+
+/**
+ * Inputs to the trade (order) action payload, verified by the trade
+ * module (`network.modules.trade`).
+ */
+interface TradeActionFields {
+    /** Protocol asset contract of the instrument (`base_asset_address`). */
+    assetAddress: string;
+    /** Asset sub id (`base_asset_sub_id`): 0 for perps/spot, the option id for options. */
+    subId: string | number | bigint;
+    limitPrice: DecimalLike;
+    amount: DecimalLike;
+    /** Worst acceptable fee per unit traded the signature allows. */
+    maxFee: DecimalLike;
+    /** Subaccount credited with the fill — the trading subaccount itself. */
+    recipientSubaccountId: number | bigint;
+    isBid: boolean;
+}
+/**
+ * Encodes the order action data: seven static words — asset, subId,
+ * limitPrice, amount, maxFee, recipientId, isBid — with
+ * prices/amounts/fee e18-scaled.
+ */
+declare function encodeTradeData(fields: TradeActionFields): string;
+
+/**
+ * Spot transfer between subaccounts of the same owner, verified by the
+ * transfer module. Position transfers are booked as RFQ trades — this
+ * action only ever moves a single spot asset.
+ */
+interface TransferFields {
+    toSubaccountId: number | bigint;
+    /**
+     * Routing sentinel: 0 credits the existing `toSubaccountId`; non-zero
+     * creates a new subaccount under this manager id instead (the
+     * destination id is then ignored).
+     */
+    newSubaccountManager: number | bigint;
+    /** Protocol spot-asset address (not the underlying ERC-20). */
+    asset: string;
+    subId: number | bigint;
+    /** Strictly positive; signed at e18. */
+    amount: DecimalLike;
+    /** Maximum fee the signer authorises, in USD; signed at e18. */
+    maxFeeUsd: DecimalLike;
+}
+/** ABI-encodes transfer action data: six static 32-byte words. */
+declare function encodeTransfer(fields: TransferFields): string;
+
+/**
+ * Spot transfer to another owner's wallet, verified by the external
+ * transfer module: the six transfer words plus a seventh holding the
+ * recipient wallet.
+ */
+interface ExternalTransferFields extends TransferFields {
+    /**
+     * Destination owner wallet. `toSubaccountId` must be one of its existing
+     * subaccounts, or 0 to create one for it under `newSubaccountManager`.
+     */
+    recipient: string;
+}
+/**
+ * All seven words are static, so the encoding is exactly the transfer
+ * payload with the recipient appended as a left-padded address word.
+ */
+declare function encodeExternalTransfer(fields: ExternalTransferFields): string;
+
+/** Withdrawal to L1, verified by the withdrawal module. */
+interface WithdrawalFields {
+    /** Protocol asset contract address (not the underlying ERC-20). */
+    protocolAsset: string;
+    /** Maximum fee the signer authorises, in USD; signed at e18 like every other action value. */
+    maxFeeUsd: DecimalLike;
+    /** L1 payout recipient. The exchange only constructs withdrawals paying out to the action signer. */
+    recipient: string;
+    /**
+     * Withdrawal amount in the ERC-20's NATIVE decimals (USDC = 6) — the
+     * protocol's only never-scaled amount, since it is the L1 payout value.
+     */
+    amount: DecimalLike;
+    /** The underlying ERC-20's decimals, used to scale `amount`. */
+    decimals: number;
+    /** Pay a higher fee for immediate batch proving. */
+    forceBatch: boolean;
+}
+/** ABI-encodes withdrawal action data: five static 32-byte words. */
+declare function encodeWithdrawal(fields: WithdrawalFields): string;
+
+/**
+ * RFQ action-data codecs.
+ *
+ * Maker and taker must hash byte-identical leg bundles: legs are sorted
+ * lexicographically by instrument name, and each signed leg amount is
+ * `amount × legDirectionSign × directionSign × perspectiveSign`. The maker
+ * encodes with their own quote direction (perspective +1); the taker
+ * executes with the opposite direction and perspective −1, which cancels
+ * back to the maker's exact values — the server rebuilds the taker's
+ * order hash from the maker's stored quote.
+ */
+/** A quoted leg carrying everything the signature commits to. */
+interface RfqSignedLeg {
+    /** Canonical ordering key — both sides sign legs sorted by this. */
+    instrumentName: string;
+    /** Protocol asset contract for the instrument (option or perp). */
+    assetAddress: string;
+    /** Asset sub id: '0' for perps, the option's encoded sub id otherwise. */
+    subId: string | bigint;
+    /** Per-unit price, always positive; e18-scaled into the signed bytes. */
+    price: DecimalLike;
+    /** Unsigned size — direction carries the sign. */
+    amount: DecimalLike;
+    direction: Direction;
+}
+interface RfqQuoteFields {
+    /** Worst fee the signer accepts, in USD; e18 in the signed bytes. */
+    maxFee: DecimalLike;
+    /** The maker's quote direction (taker execute: the taker's own direction). */
+    direction: Direction;
+    legs: RfqSignedLeg[];
+}
+/** Sorts legs into the canonical order both counterparties sign and send. */
+declare function sortRfqLegs<T extends {
+    instrumentName: string;
+}>(legs: readonly T[]): T[];
+/**
+ * Maker quote data: `abi.encode(RfqOrder{ maxFee, trades[] })` —
+ * `[0x20][maxFee][0x40][N][4 words per leg]`. Unlike the trade codec's
+ * low-16-byte i128 amount words, a negative leg amount here is a full
+ * sign-extended int256 (high 16 bytes 0xff), which is standard AbiCoder
+ * output.
+ */
+declare function encodeRfqQuote(fields: RfqQuoteFields): string;
+/**
+ * Taker execute data: `abi.encode(bytes32 orderHash, uint256 maxFee)` where
+ * `orderHash = keccak256(abi.encode(trades[]))` — the maker's legs only,
+ * maker maxFee excluded. `fields.direction` is the TAKER's direction
+ * (opposite of the quote's); `fields.maxFee` is the taker's own fee cap.
+ */
+declare function encodeRfqExecute(fields: RfqQuoteFields): string;
+
+/** Word-0 kind discriminators. */
+declare const VAULT_ACTION_KIND: {
+    readonly create: 0;
+    readonly deposit: 1;
+    readonly withdraw: 2;
+    readonly cancel: 3;
+    readonly mintShares: 4;
+    readonly burnShares: 5;
+};
+interface VaultDepositFields {
+    vaultSubaccountId: number | bigint;
+    /** Must equal the vault's configured deposit asset (protocol spot-asset address). */
+    depositSpotAsset: string;
+    /** Deposit amount in the deposit asset's units; max 12 decimal places. */
+    amount: DecimalLike;
+}
+/** VaultDepositData (kind = 1, 4 words): [kind, vaultSubaccountId, depositSpotAsset, amountE18]. */
+declare function encodeVaultDeposit(fields: VaultDepositFields): string;
+interface VaultWithdrawFields {
+    vaultSubaccountId: number | bigint;
+    /** Vault shares to redeem; max 12 decimal places. */
+    sharesToBurn: DecimalLike;
+}
+/** VaultWithdrawData (kind = 2, 3 words): [kind, vaultSubaccountId, sharesToBurnE18]. */
+declare function encodeVaultWithdraw(fields: VaultWithdrawFields): string;
+/**
+ * VaultCancelData (kind = 3, 2 words): [kind, vaultSubaccountId].
+ * Invalidates ALL of the signer's pending intents for the vault by
+ * bumping their per-(vault, holder) nonce to the envelope's nonce.
+ */
+declare function encodeVaultCancel(vaultSubaccountId: number | bigint): string;
+interface VaultCreateFields {
+    managerId: number;
+    depositSpotAsset: string;
+    /** Initial deposit moved funding subaccount → vault; max 12 decimal places. */
+    initialDeposit: DecimalLike;
+    managementFeeBps: number;
+    performanceFeeBps: number;
+    maxSlippageBps: number;
+    cooldownSec: number | bigint;
+    /** Maximum settlement fee authorised, in USD; max 12 decimal places. */
+    maxFeeUsd: DecimalLike;
+    /** Share price the vault is seeded at, in USD; max 12 decimal places. */
+    initialSharePriceUsd: DecimalLike;
+    /**
+     * Spot asset the high-water mark is denominated in. Omit for the
+     * feed-less USD default — presence drives the encoded hasBenchmark
+     * flag, exactly as the exchange derives it from the wire param.
+     */
+    benchmarkAsset?: string;
+}
+/**
+ * Create-vault action data (kind = 0, 12 words):
+ * [kind, managerId, depositSpotAsset, initialDepositE18,
+ *  managementFeeBps, performanceFeeBps, maxSlippageBps, cooldownSec,
+ *  maxFeeUsdE18, initialSharePriceUsdE18, benchmarkAsset, hasBenchmark].
+ * bps rates and cooldownSec are plain integers, not e18.
+ */
+declare function encodeVaultCreate(fields: VaultCreateFields): string;
+interface VaultMintSharesFields {
+    /** Quoted share price in USD per share; max 12 decimal places. */
+    sharePrice: DecimalLike;
+    /** keccak256 of the user's exact encoded deposit action (0x hex, 32 bytes). */
+    depositHash: string;
+}
+/** MintSharesActionData (kind = 4): the curator's approval to settle one queued deposit. */
+declare function encodeVaultMintShares(fields: VaultMintSharesFields): string;
+interface VaultBurnSharesFields {
+    /** Quoted share price in USD per share; max 12 decimal places. */
+    sharePrice: DecimalLike;
+    /** keccak256 of the user's exact encoded withdraw action (0x hex, 32 bytes). */
+    withdrawHash: string;
+}
+/** BurnSharesActionData (kind = 5): the curator's approval to settle one queued withdrawal. */
+declare function encodeVaultBurnShares(fields: VaultBurnSharesFields): string;
+
+interface CreateSessionKeyData {
+    /** Address of the key being authorized. */
+    sessionKey: string;
+    /**
+     * The KEY's lifetime as a unix-seconds timestamp — distinct from the
+     * envelope's signature expiry. The key stops working once `expirySec <= now`;
+     * pass 0 to deactivate an existing key of this address.
+     */
+    expirySec: number;
+    /**
+     * Scope codes granted to the key (auth/scopes.ts). Typed as `number` at
+     * this low level so raw codes pass through — the typed
+     * `ProtocolScopeCode` enum guides callers, and the server is the
+     * authority on which codes are valid.
+     */
+    scopes: readonly (ProtocolScopeCode | number)[];
+    /** Subaccounts the key may act on; empty = ALL current and future subaccounts. */
+    subaccountIds: readonly (number | bigint)[];
+}
+/**
+ * Encodes the create-session-key action data.
+ *
+ * Hand-packed 32-byte words — NOT standard dynamic ABI (no offset or
+ * length-prefix head): `[session_key][expiry_sec][S][A][scope codes…]
+ * [subaccount ids…]`, every value right-aligned in its word.
+ */
+declare function encodeCreateSessionKeyActionData(data: CreateSessionKeyData): string;
+
+/**
+ * Whitelisted-recipient delta, verified by the whitelisted-recipient
+ * module: the resulting list is `(current ∪ add) \ remove`.
+ */
+interface WhitelistedRecipientsFields {
+    add: string[];
+    remove: string[];
+}
+/**
+ * Hand-packed layout (2 + A + R words), NOT standard ABI dynamic arrays:
+ *   word 0     : add count A
+ *   word 1     : remove count R
+ *   word 2+i   : add[i]     (address, left-padded)
+ *   word 2+A+j : remove[j]  (address, left-padded)
+ */
+declare function encodeUpdateWhitelistedRecipients(fields: WhitelistedRecipientsFields): string;
+
+export { type CreateSessionKeyData, type ExternalTransferFields, type RfqQuoteFields, type RfqSignedLeg, type TradeActionFields, type TransferFields, VAULT_ACTION_KIND, type VaultBurnSharesFields, type VaultCreateFields, type VaultDepositFields, type VaultMintSharesFields, type VaultWithdrawFields, type WhitelistedRecipientsFields, type WithdrawalFields, encodeCreateSessionKeyActionData, encodeExternalTransfer, encodeRfqExecute, encodeRfqQuote, encodeTradeData, encodeTransfer, encodeUpdateWhitelistedRecipients, encodeVaultBurnShares, encodeVaultCancel, encodeVaultCreate, encodeVaultDeposit, encodeVaultMintShares, encodeVaultWithdraw, encodeWithdrawal, sortRfqLegs };

package/dist/codecs/index.js

@@ -0,0 +1,37 @@
+import {
+  VAULT_ACTION_KIND,
+  encodeCreateSessionKeyActionData,
+  encodeExternalTransfer,
+  encodeRfqExecute,
+  encodeRfqQuote,
+  encodeTradeData,
+  encodeTransfer,
+  encodeUpdateWhitelistedRecipients,
+  encodeVaultBurnShares,
+  encodeVaultCancel,
+  encodeVaultCreate,
+  encodeVaultDeposit,
+  encodeVaultMintShares,
+  encodeVaultWithdraw,
+  encodeWithdrawal,
+  sortRfqLegs
+} from "../chunk-WR2IIVUC.js";
+export {
+  VAULT_ACTION_KIND,
+  encodeCreateSessionKeyActionData,
+  encodeExternalTransfer,
+  encodeRfqExecute,
+  encodeRfqQuote,
+  encodeTradeData,
+  encodeTransfer,
+  encodeUpdateWhitelistedRecipients,
+  encodeVaultBurnShares,
+  encodeVaultCancel,
+  encodeVaultCreate,
+  encodeVaultDeposit,
+  encodeVaultMintShares,
+  encodeVaultWithdraw,
+  encodeWithdrawal,
+  sortRfqLegs
+};
+//# sourceMappingURL=index.js.map

package/dist/codecs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/endpointMap-BBTkarIm.d.cts

@@ -0,0 +1,45 @@
+import { ak as EndpointMap } from './generated-DwMaydIF.cjs';
+
+/** Extracts the method literal from a EndpointMap entry. */
+type MethodOf<T> = T extends {
+    request: {
+        method: infer M;
+    };
+} ? M : never;
+/** Extracts the request params type from a EndpointMap entry. */
+type RequestParamsType<T> = T extends {
+    request: {
+        params: infer P;
+    };
+} ? P : never;
+/** Extracts the full response type (result-or-error union) from a EndpointMap entry. */
+type ResponseType<T> = T extends {
+    response: infer S;
+} ? S : never;
+/** Extracts the response `result` payload from a EndpointMap entry. */
+type ResultOf<T> = ResponseType<T> extends infer S ? (S extends {
+    result: infer R;
+} ? R : never) : never;
+/** Extracts the notification `data` payload from a ChannelSchemaMap entry. */
+type ChannelDataOf<T> = T extends {
+    data: infer D;
+} ? D : never;
+/** Extracts the address params from a ChannelSchemaMap entry. */
+type ChannelParamsOf<T> = T extends {
+    params: infer P;
+} ? P : never;
+
+/**
+ * The endpoint map — request/response type for every public RPC method,
+ * keyed by method string. Import this to get fully-typed params/results
+ * without pulling in the runtime client. See the "Type-only usage" README section.
+ */
+
+/** Every public RPC method literal. */
+type RpcMethod = keyof EndpointMap & string;
+/** Request params type for a method. */
+type ParamsOf<M extends RpcMethod> = RequestParamsType<EndpointMap[M]>;
+/** Result payload type for a method. */
+type ResultFor<M extends RpcMethod> = ResultOf<EndpointMap[M]>;
+
+export type { ChannelParamsOf as C, MethodOf as M, ParamsOf as P, RpcMethod as R, ResultFor as a, ChannelDataOf as b, RequestParamsType as c, ResponseType as d, ResultOf as e };

package/dist/endpointMap-BOOWiqXf.d.ts

@@ -0,0 +1,45 @@
+import { ak as EndpointMap } from './generated-DwMaydIF.js';
+
+/** Extracts the method literal from a EndpointMap entry. */
+type MethodOf<T> = T extends {
+    request: {
+        method: infer M;
+    };
+} ? M : never;
+/** Extracts the request params type from a EndpointMap entry. */
+type RequestParamsType<T> = T extends {
+    request: {
+        params: infer P;
+    };
+} ? P : never;
+/** Extracts the full response type (result-or-error union) from a EndpointMap entry. */
+type ResponseType<T> = T extends {
+    response: infer S;
+} ? S : never;
+/** Extracts the response `result` payload from a EndpointMap entry. */
+type ResultOf<T> = ResponseType<T> extends infer S ? (S extends {
+    result: infer R;
+} ? R : never) : never;
+/** Extracts the notification `data` payload from a ChannelSchemaMap entry. */
+type ChannelDataOf<T> = T extends {
+    data: infer D;
+} ? D : never;
+/** Extracts the address params from a ChannelSchemaMap entry. */
+type ChannelParamsOf<T> = T extends {
+    params: infer P;
+} ? P : never;
+
+/**
+ * The endpoint map — request/response type for every public RPC method,
+ * keyed by method string. Import this to get fully-typed params/results
+ * without pulling in the runtime client. See the "Type-only usage" README section.
+ */
+
+/** Every public RPC method literal. */
+type RpcMethod = keyof EndpointMap & string;
+/** Request params type for a method. */
+type ParamsOf<M extends RpcMethod> = RequestParamsType<EndpointMap[M]>;
+/** Result payload type for a method. */
+type ResultFor<M extends RpcMethod> = ResultOf<EndpointMap[M]>;
+
+export type { ChannelParamsOf as C, MethodOf as M, ParamsOf as P, RpcMethod as R, ResultFor as a, ChannelDataOf as b, RequestParamsType as c, ResponseType as d, ResultOf as e };