@andy-liquid-labs/lighter-ts-sdk 1.0.0

package/src/types/txInfoPools.ts

@@ -0,0 +1,502 @@
+/**
+ * Additional Transaction Info types for pools and grouped orders
+ */
+
+import {GoldilocksElement} from '../crypto/goldilocks';
+import {hashNoPad, hashNToOne, hashToQuinticExtension} from '../crypto/poseidon2';
+import * as constants from './constants';
+import * as errors from './errors';
+import {OrderInfo, TxInfo} from './txInfo';
+
+/**
+ * L2 Create Grouped Orders Transaction Info
+ */
+export class L2CreateGroupedOrdersTxInfo implements TxInfo {
+    accountIndex: bigint;
+    apiKeyIndex: number;
+    groupingType: number;
+    orders: OrderInfo[];
+    expiredAt: bigint;
+    nonce: bigint;
+    signature?: Uint8Array;
+    signedHash?: string;
+
+    constructor(params: {
+        accountIndex: bigint;
+        apiKeyIndex: number;
+        groupingType: number;
+        orders: OrderInfo[];
+        expiredAt: bigint;
+        nonce: bigint;
+    }) {
+        this.accountIndex = params.accountIndex;
+        this.apiKeyIndex = params.apiKeyIndex;
+        this.groupingType = params.groupingType;
+        this.orders = params.orders;
+        this.expiredAt = params.expiredAt;
+        this.nonce = params.nonce;
+    }
+
+    getTxType(): number {
+        return constants.TxType.L2CreateGroupedOrders;
+    }
+
+    validate(): void {
+        // AccountIndex
+        if (this.accountIndex < constants.MIN_ACCOUNT_INDEX) {
+            throw errors.ErrAccountIndexTooLow;
+        }
+        if (this.accountIndex > constants.MAX_ACCOUNT_INDEX) {
+            throw errors.ErrAccountIndexTooHigh;
+        }
+
+        // ApiKeyIndex
+        if (this.apiKeyIndex < constants.MIN_API_KEY_INDEX) {
+            throw errors.ErrApiKeyIndexTooLow;
+        }
+        if (this.apiKeyIndex > constants.MAX_API_KEY_INDEX) {
+            throw errors.ErrApiKeyIndexTooHigh;
+        }
+
+        // GroupingType
+        if (
+            this.groupingType !== constants.GroupingType.None &&
+            this.groupingType !== constants.GroupingType.OneTriggersTheOther &&
+            this.groupingType !== constants.GroupingType.OneCancelsTheOther &&
+            this.groupingType !== constants.GroupingType.OneTriggersAOneCancelsTheOther
+        ) {
+            throw errors.ErrGroupingTypeInvalid;
+        }
+
+        // Orders
+        if (this.orders.length === 0) {
+            throw errors.ErrNoOrdersInGroup;
+        }
+        if (this.orders.length > constants.MAX_GROUPED_ORDER_COUNT) {
+            throw errors.ErrTooManyGroupedOrders;
+        }
+
+        // Nonce
+        if (this.nonce < constants.MIN_NONCE) {
+            throw errors.ErrNonceTooLow;
+        }
+
+        // ExpiredAt
+        if (this.expiredAt < 0n || this.expiredAt > constants.MAX_TIMESTAMP) {
+            throw errors.ErrExpiredAtInvalid;
+        }
+    }
+
+    hash(chainId: number): Uint8Array {
+        const elements: GoldilocksElement[] = [];
+
+        elements.push(GoldilocksElement.fromUint32(chainId));
+        elements.push(
+            GoldilocksElement.fromUint32(constants.TxType.L2CreateGroupedOrders)
+        );
+        elements.push(GoldilocksElement.fromInt64(this.nonce));
+        elements.push(GoldilocksElement.fromInt64(this.expiredAt));
+
+        elements.push(GoldilocksElement.fromInt64(this.accountIndex));
+        elements.push(GoldilocksElement.fromUint32(this.apiKeyIndex));
+        elements.push(GoldilocksElement.fromUint32(this.groupingType));
+
+        // Hash each order separately and aggregate them
+        const orderHashes: GoldilocksElement[][] = [];
+        for (const order of this.orders) {
+            const orderElements: GoldilocksElement[] = [
+                GoldilocksElement.fromUint32(order.marketIndex),
+                GoldilocksElement.fromInt64(order.clientOrderIndex),
+                GoldilocksElement.fromInt64(order.baseAmount),
+                GoldilocksElement.fromUint32(order.price),
+                GoldilocksElement.fromUint32(order.isAsk),
+                GoldilocksElement.fromUint32(order.type),
+                GoldilocksElement.fromUint32(order.timeInForce),
+                GoldilocksElement.fromUint32(order.reduceOnly),
+                GoldilocksElement.fromUint32(order.triggerPrice),
+                GoldilocksElement.fromInt64(order.orderExpiry),
+            ];
+            orderHashes.push(hashNoPad(orderElements));
+        }
+
+        // Aggregate order hashes
+        const aggregatedOrderHash = hashNToOne(orderHashes);
+
+        // Add all 4 elements from the aggregated hash
+        elements.push(...aggregatedOrderHash);
+
+        return hashToQuinticExtension(elements);
+    }
+}
+
+/**
+ * L2 Create Public Pool Transaction Info
+ */
+export class L2CreatePublicPoolTxInfo implements TxInfo {
+    accountIndex: bigint;
+    apiKeyIndex: number;
+    operatorFee: bigint;
+    initialTotalShares: bigint;
+    minOperatorShareRate: number;
+    expiredAt: bigint;
+    nonce: bigint;
+    signature?: Uint8Array;
+    signedHash?: string;
+
+    constructor(params: {
+        accountIndex: bigint;
+        apiKeyIndex: number;
+        operatorFee: bigint;
+        initialTotalShares: bigint;
+        minOperatorShareRate: number;
+        expiredAt: bigint;
+        nonce: bigint;
+    }) {
+        this.accountIndex = params.accountIndex;
+        this.apiKeyIndex = params.apiKeyIndex;
+        this.operatorFee = params.operatorFee;
+        this.initialTotalShares = params.initialTotalShares;
+        this.minOperatorShareRate = params.minOperatorShareRate;
+        this.expiredAt = params.expiredAt;
+        this.nonce = params.nonce;
+    }
+
+    getTxType(): number {
+        return constants.TxType.L2CreatePublicPool;
+    }
+
+    validate(): void {
+        // AccountIndex
+        if (this.accountIndex < constants.MIN_ACCOUNT_INDEX) {
+            throw errors.ErrAccountIndexTooLow;
+        }
+        if (this.accountIndex > constants.MAX_ACCOUNT_INDEX) {
+            throw errors.ErrAccountIndexTooHigh;
+        }
+
+        // ApiKeyIndex
+        if (this.apiKeyIndex < constants.MIN_API_KEY_INDEX) {
+            throw errors.ErrApiKeyIndexTooLow;
+        }
+        if (this.apiKeyIndex > constants.MAX_API_KEY_INDEX) {
+            throw errors.ErrApiKeyIndexTooHigh;
+        }
+
+        // InitialTotalShares
+        if (this.initialTotalShares < constants.MIN_INITIAL_TOTAL_SHARES) {
+            throw errors.ErrInitialTotalSharesTooLow;
+        }
+        if (this.initialTotalShares > constants.MAX_INITIAL_TOTAL_SHARES) {
+            throw errors.ErrInitialTotalSharesTooHigh;
+        }
+
+        // MinOperatorShareRate
+        if (this.minOperatorShareRate > constants.SHARE_TICK) {
+            throw errors.ErrMinOperatorShareRateTooHigh;
+        }
+
+        // Nonce
+        if (this.nonce < constants.MIN_NONCE) {
+            throw errors.ErrNonceTooLow;
+        }
+
+        // ExpiredAt
+        if (this.expiredAt < 0n || this.expiredAt > constants.MAX_TIMESTAMP) {
+            throw errors.ErrExpiredAtInvalid;
+        }
+    }
+
+    hash(chainId: number): Uint8Array {
+        const elements: GoldilocksElement[] = [];
+
+        elements.push(GoldilocksElement.fromUint32(chainId));
+        elements.push(
+            GoldilocksElement.fromUint32(constants.TxType.L2CreatePublicPool)
+        );
+        elements.push(GoldilocksElement.fromInt64(this.nonce));
+        elements.push(GoldilocksElement.fromInt64(this.expiredAt));
+
+        elements.push(GoldilocksElement.fromInt64(this.accountIndex));
+        elements.push(GoldilocksElement.fromUint32(this.apiKeyIndex));
+        elements.push(GoldilocksElement.fromInt64(this.operatorFee));
+        elements.push(GoldilocksElement.fromInt64(this.initialTotalShares));
+        elements.push(GoldilocksElement.fromUint32(this.minOperatorShareRate));
+
+        return hashToQuinticExtension(elements);
+    }
+}
+
+/**
+ * L2 Update Public Pool Transaction Info
+ */
+export class L2UpdatePublicPoolTxInfo implements TxInfo {
+    accountIndex: bigint;
+    apiKeyIndex: number;
+    publicPoolIndex: bigint;
+    status: number;
+    operatorFee: bigint;
+    minOperatorShareRate: number;
+    expiredAt: bigint;
+    nonce: bigint;
+    signature?: Uint8Array;
+    signedHash?: string;
+
+    constructor(params: {
+        accountIndex: bigint;
+        apiKeyIndex: number;
+        publicPoolIndex: bigint;
+        status: number;
+        operatorFee: bigint;
+        minOperatorShareRate: number;
+        expiredAt: bigint;
+        nonce: bigint;
+    }) {
+        this.accountIndex = params.accountIndex;
+        this.apiKeyIndex = params.apiKeyIndex;
+        this.publicPoolIndex = params.publicPoolIndex;
+        this.status = params.status;
+        this.operatorFee = params.operatorFee;
+        this.minOperatorShareRate = params.minOperatorShareRate;
+        this.expiredAt = params.expiredAt;
+        this.nonce = params.nonce;
+    }
+
+    getTxType(): number {
+        return constants.TxType.L2UpdatePublicPool;
+    }
+
+    validate(): void {
+        // AccountIndex
+        if (this.accountIndex < constants.MIN_ACCOUNT_INDEX) {
+            throw errors.ErrAccountIndexTooLow;
+        }
+        if (this.accountIndex > constants.MAX_ACCOUNT_INDEX) {
+            throw errors.ErrAccountIndexTooHigh;
+        }
+
+        // ApiKeyIndex
+        if (this.apiKeyIndex < constants.MIN_API_KEY_INDEX) {
+            throw errors.ErrApiKeyIndexTooLow;
+        }
+        if (this.apiKeyIndex > constants.MAX_API_KEY_INDEX) {
+            throw errors.ErrApiKeyIndexTooHigh;
+        }
+
+        // PublicPoolIndex
+        if (this.publicPoolIndex < 0n) {
+            throw errors.ErrPublicPoolIndexTooLow;
+        }
+
+        // Nonce
+        if (this.nonce < constants.MIN_NONCE) {
+            throw errors.ErrNonceTooLow;
+        }
+
+        // ExpiredAt
+        if (this.expiredAt < 0n || this.expiredAt > constants.MAX_TIMESTAMP) {
+            throw errors.ErrExpiredAtInvalid;
+        }
+    }
+
+    hash(chainId: number): Uint8Array {
+        const elements: GoldilocksElement[] = [];
+
+        elements.push(GoldilocksElement.fromUint32(chainId));
+        elements.push(
+            GoldilocksElement.fromUint32(constants.TxType.L2UpdatePublicPool)
+        );
+        elements.push(GoldilocksElement.fromInt64(this.nonce));
+        elements.push(GoldilocksElement.fromInt64(this.expiredAt));
+
+        elements.push(GoldilocksElement.fromInt64(this.accountIndex));
+        elements.push(GoldilocksElement.fromUint32(this.apiKeyIndex));
+        elements.push(GoldilocksElement.fromInt64(this.publicPoolIndex));
+        elements.push(GoldilocksElement.fromUint32(this.status));
+        elements.push(GoldilocksElement.fromInt64(this.operatorFee));
+        elements.push(GoldilocksElement.fromUint32(this.minOperatorShareRate));
+
+        return hashToQuinticExtension(elements);
+    }
+}
+
+/**
+ * L2 Mint Shares Transaction Info
+ */
+export class L2MintSharesTxInfo implements TxInfo {
+    accountIndex: bigint;
+    apiKeyIndex: number;
+    publicPoolIndex: bigint;
+    shareAmount: bigint;
+    expiredAt: bigint;
+    nonce: bigint;
+    signature?: Uint8Array;
+    signedHash?: string;
+
+    constructor(params: {
+        accountIndex: bigint;
+        apiKeyIndex: number;
+        publicPoolIndex: bigint;
+        shareAmount: bigint;
+        expiredAt: bigint;
+        nonce: bigint;
+    }) {
+        this.accountIndex = params.accountIndex;
+        this.apiKeyIndex = params.apiKeyIndex;
+        this.publicPoolIndex = params.publicPoolIndex;
+        this.shareAmount = params.shareAmount;
+        this.expiredAt = params.expiredAt;
+        this.nonce = params.nonce;
+    }
+
+    getTxType(): number {
+        return constants.TxType.L2MintShares;
+    }
+
+    validate(): void {
+        // AccountIndex
+        if (this.accountIndex < constants.MIN_ACCOUNT_INDEX) {
+            throw errors.ErrAccountIndexTooLow;
+        }
+        if (this.accountIndex > constants.MAX_ACCOUNT_INDEX) {
+            throw errors.ErrAccountIndexTooHigh;
+        }
+
+        // ApiKeyIndex
+        if (this.apiKeyIndex < constants.MIN_API_KEY_INDEX) {
+            throw errors.ErrApiKeyIndexTooLow;
+        }
+        if (this.apiKeyIndex > constants.MAX_API_KEY_INDEX) {
+            throw errors.ErrApiKeyIndexTooHigh;
+        }
+
+        // PublicPoolIndex
+        if (this.publicPoolIndex < 0n) {
+            throw errors.ErrPublicPoolIndexTooLow;
+        }
+
+        // ShareAmount
+        if (this.shareAmount < constants.MIN_POOL_SHARES_TO_MINT_OR_BURN) {
+            throw errors.ErrShareAmountTooLow;
+        }
+        if (this.shareAmount > constants.MAX_POOL_SHARES_TO_MINT_OR_BURN) {
+            throw errors.ErrShareAmountTooHigh;
+        }
+
+        // Nonce
+        if (this.nonce < constants.MIN_NONCE) {
+            throw errors.ErrNonceTooLow;
+        }
+
+        // ExpiredAt
+        if (this.expiredAt < 0n || this.expiredAt > constants.MAX_TIMESTAMP) {
+            throw errors.ErrExpiredAtInvalid;
+        }
+    }
+
+    hash(chainId: number): Uint8Array {
+        const elements: GoldilocksElement[] = [];
+
+        elements.push(GoldilocksElement.fromUint32(chainId));
+        elements.push(GoldilocksElement.fromUint32(constants.TxType.L2MintShares));
+        elements.push(GoldilocksElement.fromInt64(this.nonce));
+        elements.push(GoldilocksElement.fromInt64(this.expiredAt));
+
+        elements.push(GoldilocksElement.fromInt64(this.accountIndex));
+        elements.push(GoldilocksElement.fromUint32(this.apiKeyIndex));
+        elements.push(GoldilocksElement.fromInt64(this.publicPoolIndex));
+        elements.push(GoldilocksElement.fromInt64(this.shareAmount));
+
+        return hashToQuinticExtension(elements);
+    }
+}
+
+/**
+ * L2 Burn Shares Transaction Info
+ */
+export class L2BurnSharesTxInfo implements TxInfo {
+    accountIndex: bigint;
+    apiKeyIndex: number;
+    publicPoolIndex: bigint;
+    shareAmount: bigint;
+    expiredAt: bigint;
+    nonce: bigint;
+    signature?: Uint8Array;
+    signedHash?: string;
+
+    constructor(params: {
+        accountIndex: bigint;
+        apiKeyIndex: number;
+        publicPoolIndex: bigint;
+        shareAmount: bigint;
+        expiredAt: bigint;
+        nonce: bigint;
+    }) {
+        this.accountIndex = params.accountIndex;
+        this.apiKeyIndex = params.apiKeyIndex;
+        this.publicPoolIndex = params.publicPoolIndex;
+        this.shareAmount = params.shareAmount;
+        this.expiredAt = params.expiredAt;
+        this.nonce = params.nonce;
+    }
+
+    getTxType(): number {
+        return constants.TxType.L2BurnShares;
+    }
+
+    validate(): void {
+        // AccountIndex
+        if (this.accountIndex < constants.MIN_ACCOUNT_INDEX) {
+            throw errors.ErrAccountIndexTooLow;
+        }
+        if (this.accountIndex > constants.MAX_ACCOUNT_INDEX) {
+            throw errors.ErrAccountIndexTooHigh;
+        }
+
+        // ApiKeyIndex
+        if (this.apiKeyIndex < constants.MIN_API_KEY_INDEX) {
+            throw errors.ErrApiKeyIndexTooLow;
+        }
+        if (this.apiKeyIndex > constants.MAX_API_KEY_INDEX) {
+            throw errors.ErrApiKeyIndexTooHigh;
+        }
+
+        // PublicPoolIndex
+        if (this.publicPoolIndex < 0n) {
+            throw errors.ErrPublicPoolIndexTooLow;
+        }
+
+        // ShareAmount
+        if (this.shareAmount < constants.MIN_POOL_SHARES_TO_MINT_OR_BURN) {
+            throw errors.ErrShareAmountTooLow;
+        }
+        if (this.shareAmount > constants.MAX_POOL_SHARES_TO_MINT_OR_BURN) {
+            throw errors.ErrShareAmountTooHigh;
+        }
+
+        // Nonce
+        if (this.nonce < constants.MIN_NONCE) {
+            throw errors.ErrNonceTooLow;
+        }
+
+        // ExpiredAt
+        if (this.expiredAt < 0n || this.expiredAt > constants.MAX_TIMESTAMP) {
+            throw errors.ErrExpiredAtInvalid;
+        }
+    }
+
+    hash(chainId: number): Uint8Array {
+        const elements: GoldilocksElement[] = [];
+
+        elements.push(GoldilocksElement.fromUint32(chainId));
+        elements.push(GoldilocksElement.fromUint32(constants.TxType.L2BurnShares));
+        elements.push(GoldilocksElement.fromInt64(this.nonce));
+        elements.push(GoldilocksElement.fromInt64(this.expiredAt));
+
+        elements.push(GoldilocksElement.fromInt64(this.accountIndex));
+        elements.push(GoldilocksElement.fromUint32(this.apiKeyIndex));
+        elements.push(GoldilocksElement.fromInt64(this.publicPoolIndex));
+        elements.push(GoldilocksElement.fromInt64(this.shareAmount));
+
+        return hashToQuinticExtension(elements);
+    }
+}