@n1xyz/nord-ts 0.1.6 → 0.1.8

package/dist/{nord/client → client}/NordAdmin.js

@@ -1,57 +1,26 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NordAdmin = exports.AclRole = void 0;
-const protobuf_1 = require("@bufbuild/protobuf");
-const proto = __importStar(require("../../gen/nord_pb"));
-const utils_1 = require("../../utils");
-const actions_1 = require("../api/actions");
-const NordError_1 = require("../utils/NordError");
+import { create } from "@bufbuild/protobuf";
+import * as proto from "../gen/nord_pb";
+import { decodeHex, signUserPayload } from "../utils";
+import { createAction, sendAction, expectReceiptKind } from "../actions";
+import { NordError } from "../error";
 // NOTE: keep in sync with `acl.rs`.
-// NOTE: don't forget `number` as int is internally a u32.
-var AclRole;
+export var AclRole;
 (function (AclRole) {
+    // note: use 2 ** n instead of 1 << n since js internally
+    // casts number to a signed int for bitwise ops. when merging
+    // these roles, make sure to use += instead of |=. this will
+    // only work when the roles are powers of two.
     AclRole[AclRole["FEE_MANAGER"] = 1] = "FEE_MANAGER";
     AclRole[AclRole["MARKET_MANAGER"] = 2] = "MARKET_MANAGER";
-    // TODO: unsure about this?
-    AclRole[AclRole["ADMIN"] = -2147483648] = "ADMIN";
-})(AclRole || (exports.AclRole = AclRole = {}));
+    AclRole[AclRole["ADMIN"] = 2147483648] = "ADMIN";
+})(AclRole || (AclRole = {}));
 /**
  * Administrative client capable of submitting privileged configuration actions.
  */
-class NordAdmin {
+export class NordAdmin {
+    nord;
+    admin;
+    signFn;
     constructor({ nord, admin, signFn, }) {
         this.nord = nord;
         this.admin = admin;
@@ -62,25 +31,8 @@ class NordAdmin {
      * @param nord - Nord instance
      * @param admin - The user that will be signing actions.
      * @param signFn - Function to sign messages with the admin's wallet.
-     *
-     * `signFn` must sign the _hex-encoded_ message, not the raw message itself, for
-     * the purpose of being compatible with Solana wallets.
-     *
-     * In practice, you will do something along the lines of:
-     *
-     * ```typescript
-     * (x) => wallet.signMessage(new TextEncoder().encode(x.toHex()));
-     * ```
-     *
-     * For a software signing key, this might look more like:
-     *
-     * ```typescript
-     * (x) => nacl.sign.detached(new TextEncoder().encode(x.toHex()), sk);
-     * ``
-     *
-     * where `nacl` is the tweetnacl library.
      */
-    static new({ nord, admin, signFn, }) {
+    static async new({ nord, admin, signFn, }) {
         return new NordAdmin({
             nord,
             admin,
@@ -95,12 +47,13 @@ class NordAdmin {
      */
     async submitAction(kind) {
         const timestamp = await this.nord.getTimestamp();
-        const action = (0, actions_1.createAction)(timestamp, 0, kind);
-        return (0, actions_1.sendAction)(this.nord.webServerUrl, async (xs) => {
-            const signature = await this.signFn(xs);
-            if (signature.length !== 64) {
-                throw new NordError_1.NordError("invalid signature length; must be 64 bytes");
-            }
+        const action = createAction(timestamp, 0, kind);
+        return sendAction(this.nord.httpClient, async (xs) => {
+            const signature = await signUserPayload({
+                payload: xs,
+                user: this.admin,
+                signTransaction: this.signFn,
+            });
             return Uint8Array.from([...xs, ...signature]);
         }, action);
     }
@@ -115,37 +68,43 @@ class NordAdmin {
     async updateAcl({ target, addRoles, removeRoles, }) {
         const allRoles = addRoles.concat(removeRoles);
         if (allRoles.length !== new Set(allRoles).size) {
-            throw new NordError_1.NordError("duplicate roles in acl update; must be unique");
+            throw new NordError("duplicate roles in acl update; must be unique");
         }
         let mask = 0;
         let values = 0;
-        for (const role of allRoles) {
-            mask |= role;
-        }
-        for (const role of addRoles) {
-            values |= role;
-        }
+        // using += instead of |= to avoid the internal cast to i32 >:(
+        // this works because our roles are powers of two.
+        for (const role of allRoles)
+            mask += role;
+        for (const role of addRoles)
+            values += role;
         const receipt = await this.submitAction({
             case: "updateAcl",
-            value: (0, protobuf_1.create)(proto.Action_UpdateAclSchema, {
+            value: create(proto.Action_UpdateAclSchema, {
                 aclPubkey: this.admin.toBytes(),
                 targetPubkey: target.toBytes(),
+                rolesValue: values,
+                rolesMask: mask,
             }),
         });
-        (0, actions_1.expectReceiptKind)(receipt, "aclUpdated", "update acl");
+        expectReceiptKind(receipt, "aclUpdated", "update acl");
         return { ...receipt.kind.value, actionId: receipt.actionId };
     }
     /**
      * Register a new token that can be listed on Nord.
      *
-     * @param params - Token configuration values
+     * @param tokenDecimals - Decimal shift used when parsing deposits/withdrawals
+     * @param weightBps - Risk weight in basis points applied in account value calculations
+     * @param viewSymbol - Symbol surfaced to Nord clients
+     * @param oracleSymbol - Symbol resolved by the oracle adapter
+     * @param mintAddr - Solana mint backing this token
      * @returns Action identifier and resulting token metadata
      * @throws {NordError} If the action submission fails
      */
     async createToken({ tokenDecimals, weightBps, viewSymbol, oracleSymbol, mintAddr, }) {
         const receipt = await this.submitAction({
             case: "createToken",
-            value: (0, protobuf_1.create)(proto.Action_CreateTokenSchema, {
+            value: create(proto.Action_CreateTokenSchema, {
                 aclPubkey: this.admin.toBytes(),
                 tokenDecimals,
                 weightBps,
@@ -154,33 +113,41 @@ class NordAdmin {
                 solAddr: mintAddr.toBytes(),
             }),
         });
-        (0, actions_1.expectReceiptKind)(receipt, "insertTokenResult", "create token");
+        expectReceiptKind(receipt, "insertTokenResult", "create token");
         return { actionId: receipt.actionId, ...receipt.kind.value };
     }
     /**
      * Open a new market with the provided trading parameters.
      *
-     * @param params - Market configuration to apply
+     * @param sizeDecimals - Decimal shift for contract sizes
+     * @param priceDecimals - Decimal shift for price ticks
+     * @param imfBps - Base initial margin fraction (IMF) in basis points, see docs/MARKETS.md
+     * @param cmfBps - Cancel margin fraction (CMF) in basis points, see docs/MARKETS.md
+     * @param mmfBps - Maintenance margin fraction (MMF) in basis points, see docs/MARKETS.md
+     * @param marketType - Spot or perpetual market type
+     * @param viewSymbol - Symbol exposed to Nord clients
+     * @param oracleSymbol - Symbol resolved by the oracle adapter
+     * @param baseTokenId - Registered base token backing this market
      * @returns Action identifier and resulting market metadata
      * @throws {NordError} If the action submission fails
      */
-    async createMarket(params) {
+    async createMarket({ sizeDecimals, priceDecimals, imfBps, cmfBps, mmfBps, marketType, viewSymbol, oracleSymbol, baseTokenId, }) {
         const receipt = await this.submitAction({
             case: "createMarket",
-            value: (0, protobuf_1.create)(proto.Action_CreateMarketSchema, {
+            value: create(proto.Action_CreateMarketSchema, {
                 aclPubkey: this.admin.toBytes(),
-                sizeDecimals: params.sizeDecimals,
-                priceDecimals: params.priceDecimals,
-                imfBps: params.imfBps,
-                cmfBps: params.cmfBps,
-                mmfBps: params.mmfBps,
-                marketType: params.marketType,
-                viewSymbol: params.viewSymbol,
-                oracleSymbol: params.oracleSymbol,
-                baseTokenId: params.baseTokenId,
+                sizeDecimals,
+                priceDecimals,
+                imfBps,
+                cmfBps,
+                mmfBps,
+                marketType,
+                viewSymbol,
+                oracleSymbol,
+                baseTokenId,
             }),
         });
-        (0, actions_1.expectReceiptKind)(receipt, "insertMarketResult", "create market");
+        expectReceiptKind(receipt, "insertMarketResult", "create market");
         return { actionId: receipt.actionId, ...receipt.kind.value };
     }
     /**
@@ -190,32 +157,33 @@ class NordAdmin {
      * leading `0x` prefix). The engine validates the supplied guardian set index
      * before applying the update.
      *
-     * @param params - Guardian set index and guardian addresses
+     * @param guardianSetIndex - Wormhole guardian set index that must already exist
+     * @param addresses - 20-byte hex-encoded guardian addresses
      * @returns Action identifier and guardian update receipt
      * @throws {NordError} If the action submission fails
      */
-    async pythSetWormholeGuardians(params) {
-        const addresses = params.addresses.map((address) => {
+    async pythSetWormholeGuardians({ guardianSetIndex, addresses, }) {
+        const parsedAddresses = addresses.map((address) => {
             try {
-                const decoded = (0, utils_1.decodeHex)(address);
+                const decoded = decodeHex(address);
                 if (decoded.length !== 20) {
                     throw new Error("guardian address must be 20 bytes");
                 }
                 return decoded;
             }
             catch (e) {
-                throw new NordError_1.NordError("invalid guardian address; must be a 20 byte hex address", { cause: e });
+                throw new NordError("invalid guardian address; must be a 20 byte hex address", { cause: e });
             }
         });
         const receipt = await this.submitAction({
             case: "pythSetWormholeGuardians",
-            value: (0, protobuf_1.create)(proto.Action_PythSetWormholeGuardiansSchema, {
+            value: create(proto.Action_PythSetWormholeGuardiansSchema, {
                 aclPubkey: this.admin.toBytes(),
-                guardianSetIndex: params.guardianSetIndex,
-                addresses,
+                guardianSetIndex,
+                addresses: parsedAddresses,
             }),
         });
-        (0, actions_1.expectReceiptKind)(receipt, "updateGuardianSetResult", "update wormhole guardians");
+        expectReceiptKind(receipt, "updateGuardianSetResult", "update wormhole guardians");
         return { actionId: receipt.actionId, ...receipt.kind.value };
     }
     /**
@@ -225,32 +193,33 @@ class NordAdmin {
      * leading `0x` prefix). Use this call to create or update the mapping used
      * by the oracle integration.
      *
-     * @param params - Oracle symbol and price feed identifier
+     * @param oracleSymbol - Symbol resolved by the oracle adapter
+     * @param priceFeedId - 32-byte hex-encoded Pyth price feed identifier
      * @returns Action identifier and symbol feed receipt
      * @throws {NordError} If the action submission fails
      */
-    async pythSetSymbolFeed(params) {
+    async pythSetSymbolFeed({ oracleSymbol, priceFeedId: priceFeedIdHex, }) {
         let priceFeedId;
         try {
-            priceFeedId = (0, utils_1.decodeHex)(params.priceFeedId);
+            priceFeedId = decodeHex(priceFeedIdHex);
             if (priceFeedId.length !== 32) {
                 throw new Error("price feed id must be 32 bytes");
             }
         }
         catch (e) {
-            throw new NordError_1.NordError("invalid price feed id; must be a 32 byte hex id", {
+            throw new NordError("invalid price feed id; must be a 32 byte hex id", {
                 cause: e,
             });
         }
         const receipt = await this.submitAction({
             case: "pythSetSymbolFeed",
-            value: (0, protobuf_1.create)(proto.Action_PythSetSymbolFeedSchema, {
+            value: create(proto.Action_PythSetSymbolFeedSchema, {
                 aclPubkey: this.admin.toBytes(),
-                oracleSymbol: params.oracleSymbol,
+                oracleSymbol,
                 priceFeedId,
             }),
         });
-        (0, actions_1.expectReceiptKind)(receipt, "oracleSymbolFeedResult", "set symbol feed");
+        expectReceiptKind(receipt, "oracleSymbolFeedResult", "set symbol feed");
         return { actionId: receipt.actionId, ...receipt.kind.value };
     }
     /**
@@ -262,11 +231,11 @@ class NordAdmin {
     async pause() {
         const receipt = await this.submitAction({
             case: "pause",
-            value: (0, protobuf_1.create)(proto.Action_PauseSchema, {
+            value: create(proto.Action_PauseSchema, {
                 aclPubkey: this.admin.toBytes(),
             }),
         });
-        (0, actions_1.expectReceiptKind)(receipt, "paused", "pause");
+        expectReceiptKind(receipt, "paused", "pause");
         return { actionId: receipt.actionId };
     }
     /**
@@ -278,47 +247,47 @@ class NordAdmin {
     async unpause() {
         const receipt = await this.submitAction({
             case: "unpause",
-            value: (0, protobuf_1.create)(proto.Action_UnpauseSchema, {
+            value: create(proto.Action_UnpauseSchema, {
                 aclPubkey: this.admin.toBytes(),
             }),
         });
-        (0, actions_1.expectReceiptKind)(receipt, "unpaused", "unpause");
+        expectReceiptKind(receipt, "unpaused", "unpause");
         return { actionId: receipt.actionId };
     }
     /**
      * Freeze an individual market, preventing new trades and orders.
      *
-     * @param params - Target market identifier
+     * @param marketId - Target market identifier
      * @returns Action identifier and freeze receipt
      * @throws {NordError} If the action submission fails
      */
-    async freezeMarket(params) {
+    async freezeMarket({ marketId, }) {
         const receipt = await this.submitAction({
             case: "freezeMarket",
-            value: (0, protobuf_1.create)(proto.Action_FreezeMarketSchema, {
-                marketId: params.marketId,
+            value: create(proto.Action_FreezeMarketSchema, {
+                marketId,
                 aclPubkey: this.admin.toBytes(),
             }),
         });
-        (0, actions_1.expectReceiptKind)(receipt, "marketFreezeUpdated", "freeze market");
+        expectReceiptKind(receipt, "marketFreezeUpdated", "freeze market");
         return { actionId: receipt.actionId, ...receipt.kind.value };
     }
     /**
      * Unfreeze a market that was previously halted.
      *
-     * @param params - Target market identifier
+     * @param marketId - Target market identifier
      * @returns Action identifier and freeze receipt
      * @throws {NordError} If the action submission fails
      */
-    async unfreezeMarket(params) {
+    async unfreezeMarket({ marketId, }) {
         const receipt = await this.submitAction({
             case: "unfreezeMarket",
-            value: (0, protobuf_1.create)(proto.Action_UnfreezeMarketSchema, {
-                marketId: params.marketId,
+            value: create(proto.Action_UnfreezeMarketSchema, {
+                marketId,
                 aclPubkey: this.admin.toBytes(),
             }),
         });
-        (0, actions_1.expectReceiptKind)(receipt, "marketFreezeUpdated", "unfreeze market");
+        expectReceiptKind(receipt, "marketFreezeUpdated", "unfreeze market");
         return { actionId: receipt.actionId, ...receipt.kind.value };
     }
     /**
@@ -328,19 +297,19 @@ class NordAdmin {
      *   the default Nord fees; use `updateFeeTier` if you need to change it.
      * - The first appended tier receives id 1, and subsequent tiers increment the id.
      *
-     * @param params - Fee tier configuration to insert
+     * @param config - Fee tier configuration to insert
      * @returns Action identifier and fee tier addition receipt
      * @throws {NordError} If the action submission fails or the new tier exceeds the maximum range (0-15).
      */
-    async addFeeTier(params) {
+    async addFeeTier({ config, }) {
         const receipt = await this.submitAction({
             case: "addFeeTier",
-            value: (0, protobuf_1.create)(proto.Action_AddFeeTierSchema, {
+            value: create(proto.Action_AddFeeTierSchema, {
                 aclPubkey: this.admin.toBytes(),
-                config: (0, protobuf_1.create)(proto.FeeTierConfigSchema, params.config),
+                config: create(proto.FeeTierConfigSchema, config),
             }),
         });
-        (0, actions_1.expectReceiptKind)(receipt, "feeTierAdded", "add fee tier");
+        expectReceiptKind(receipt, "feeTierAdded", "add fee tier");
         return { actionId: receipt.actionId, ...receipt.kind.value };
     }
     /**
@@ -349,20 +318,21 @@ class NordAdmin {
      * Tier identifiers must already exist; attempting to update a missing tier
      * causes the action to fail.
      *
-     * @param params - Fee tier identifier and updated configuration
+     * @param tierId - Existing fee tier identifier to update
+     * @param config - Replacement configuration for the tier
      * @returns Action identifier and fee tier update receipt
      * @throws {NordError} If the action submission fails or the tier ID exceeds the configured range.
      */
-    async updateFeeTier(params) {
+    async updateFeeTier({ tierId, config, }) {
         const receipt = await this.submitAction({
             case: "updateFeeTier",
-            value: (0, protobuf_1.create)(proto.Action_UpdateFeeTierSchema, {
+            value: create(proto.Action_UpdateFeeTierSchema, {
                 aclPubkey: this.admin.toBytes(),
-                id: params.tierId,
-                config: (0, protobuf_1.create)(proto.FeeTierConfigSchema, params.config),
+                id: tierId,
+                config: create(proto.FeeTierConfigSchema, config),
             }),
         });
-        (0, actions_1.expectReceiptKind)(receipt, "feeTierUpdated", "update fee tier");
+        expectReceiptKind(receipt, "feeTierUpdated", "update fee tier");
         return { actionId: receipt.actionId, ...receipt.kind.value };
     }
     /**
@@ -380,14 +350,13 @@ class NordAdmin {
     async updateAccountsTier(accounts, tierId) {
         const receipt = await this.submitAction({
             case: "updateAccountsTier",
-            value: (0, protobuf_1.create)(proto.Action_UpdateAccountsTierSchema, {
+            value: create(proto.Action_UpdateAccountsTierSchema, {
                 aclPubkey: this.admin.toBytes(),
                 accounts,
                 tierId,
             }),
         });
-        (0, actions_1.expectReceiptKind)(receipt, "accountsTierUpdated", "update accounts tier");
+        expectReceiptKind(receipt, "accountsTierUpdated", "update accounts tier");
         return { actionId: receipt.actionId, ...receipt.kind.value };
     }
 }
-exports.NordAdmin = NordAdmin;