@n1xyz/nord-ts 0.0.1

package/dist/nord/NordUser.js

@@ -0,0 +1,249 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NordUser = void 0;
+const ethers_1 = require("ethers");
+const secp256k1_1 = __importDefault(require("secp256k1"));
+const const_1 = require("../const");
+const utils_1 = require("../utils");
+const abis_1 = require("../abis");
+const actions_1 = require("./actions");
+class NordUser {
+    constructor(params) {
+        this.balances = {};
+        this.orders = {};
+        this.lastTs = 0;
+        this.lastNonce = 0;
+        this.nord = params.nord;
+        this.address = params.address;
+        this.walletSignFn = params.walletSignFn;
+        this.sessionSignFn = params.sessionSignFn;
+    }
+    clone() {
+        const newUser = new NordUser({
+            nord: this.nord,
+            address: this.address,
+            walletSignFn: this.walletSignFn,
+            sessionSignFn: this.sessionSignFn,
+        });
+        newUser.publicKey = this.publicKey;
+        newUser.lastTs = this.lastTs;
+        newUser.lastNonce = this.lastNonce;
+        newUser.accountIds = this.accountIds;
+        newUser.sessionId = this.sessionId;
+        return newUser;
+    }
+    /**
+     * Generates a nonce based on the current timestamp.
+     * @returns Generated nonce as a number.
+     */
+    getNonce() {
+        const ts = Date.now() / 1000;
+        if (ts === this.lastTs) {
+            this.lastNonce += 1;
+        }
+        else {
+            this.lastTs = ts;
+            this.lastNonce = 0;
+        }
+        return this.lastNonce;
+    }
+    async updateAccountId() {
+        const hexPubkey = ethers_1.ethers
+            .hexlify((0, utils_1.optExpect)(this.publicKey, "No user public key"))
+            .slice(2);
+        const accountIds_ = await (await (0, utils_1.checkedFetch)(`${this.nord.webServerUrl}/user_account_ids?pubkey=${hexPubkey}`)).json();
+        (0, utils_1.assert)(Array.isArray(accountIds_), "Unexpected response");
+        const accountIds = accountIds_;
+        this.accountIds = accountIds;
+    }
+    async fetchInfo() {
+        if (this.accountIds !== undefined) {
+            // todo:implement class
+            const accountsData = await Promise.all(this.accountIds.map(async (accountId) => {
+                const response = await (0, utils_1.checkedFetch)(`${this.nord.webServerUrl}/account?account_id=${accountId}`);
+                return {
+                    accountId,
+                    ...(await response.json()),
+                };
+            }));
+            for (const accountData of accountsData) {
+                this.balances[accountData.accountId] = [];
+                for (const balance of accountData.balances) {
+                    this.balances[accountData.accountId].push({
+                        accountId: accountData.accountId,
+                        balance: balance.amount,
+                        symbol: balance.token,
+                    });
+                }
+                this.orders[accountData.accountId] = accountData.orders.map((order) => {
+                    return {
+                        orderId: order.orderId,
+                        isLong: order.side === "bid",
+                        size: order.size,
+                        price: order.price,
+                        marketId: order.marketId,
+                    };
+                });
+            }
+        }
+    }
+    async setPublicKey() {
+        const message = "Layer N - Nord";
+        const msgHash = ethers_1.ethers.hashMessage(message);
+        const msgHashBytes = ethers_1.ethers.getBytes(msgHash);
+        const signature = await this.walletSignFn(message);
+        const recoveredPubKey = ethers_1.SigningKey.recoverPublicKey(msgHashBytes, signature);
+        const publicKeyBuffer = Buffer.from(recoveredPubKey.slice(2), "hex");
+        this.publicKey = secp256k1_1.default.publicKeyConvert(publicKeyBuffer, true);
+    }
+    async fundEthWallet() {
+        const provider = new ethers_1.ethers.JsonRpcProvider(this.nord.evmUrl);
+        const wallet = new ethers_1.ethers.Wallet(const_1.FAUCET_PRIVATE_ADDRESS, provider);
+        (0, utils_1.assert)(const_1.DEFAULT_FUNDING_AMOUNTS["ETH"] != null);
+        const ethTx = await wallet.sendTransaction({
+            to: this.address,
+            value: ethers_1.ethers.parseEther(const_1.DEFAULT_FUNDING_AMOUNTS["ETH"][0]),
+        });
+        await ethTx.wait();
+    }
+    async fundErc20Wallet() {
+        const provider = new ethers_1.ethers.JsonRpcProvider(this.nord.evmUrl);
+        const wallet = new ethers_1.ethers.Wallet(const_1.FAUCET_PRIVATE_ADDRESS, provider);
+        (0, utils_1.assert)(const_1.DEFAULT_FUNDING_AMOUNTS["ETH"] != null);
+        for (const tokenInfo of this.nord.tokenInfos) {
+            const erc20Contract = new ethers_1.ethers.Contract(tokenInfo.address, abis_1.ERC20_ABI, wallet);
+            if (const_1.DEFAULT_FUNDING_AMOUNTS[tokenInfo.address]) {
+                const defaultFundingAmount = const_1.DEFAULT_FUNDING_AMOUNTS[tokenInfo.address];
+                const tokenTx = await erc20Contract.transfer(this.address, ethers_1.ethers.parseUnits(defaultFundingAmount[0], defaultFundingAmount[1]), {
+                    maxFeePerGas: ethers_1.ethers.parseUnits("30", "gwei"),
+                    maxPriorityFeePerGas: ethers_1.ethers.parseUnits("0.001", "gwei"),
+                });
+                await tokenTx.wait();
+            }
+        }
+    }
+    async refreshSession(sessionPk) {
+        this.sessionId = await (0, actions_1.createSession)(this.nord.webServerUrl, this.walletSignFn, await this.nord.impl.getTimestamp(), this.getNonce(), {
+            userPubkey: (0, utils_1.optExpect)(this.publicKey, "No user's public key"),
+            sessionPubkey: sessionPk,
+        });
+    }
+    /**
+     * Revokes session previously created by user
+     *
+     * @param sessionId - session identifier
+     */
+    async revokeSession(sessionId) {
+        return (0, actions_1.revokeSession)(this.nord.webServerUrl, this.walletSignFn, await this.nord.impl.getTimestamp(), this.getNonce(), {
+            sessionId,
+        });
+    }
+    async deposit(provider, amount, tokenId) {
+        const erc20 = this.nord.tokenInfos[tokenId];
+        const erc20Contract = new ethers_1.ethers.Contract(erc20.address, abis_1.ERC20_ABI, await provider.getSigner());
+        const approveTx = await erc20Contract.approve(this.nord.contractAddress, ethers_1.MaxUint256, {
+            maxFeePerGas: ethers_1.ethers.parseUnits("30", "gwei"),
+            maxPriorityFeePerGas: ethers_1.ethers.parseUnits("0.001", "gwei"),
+        });
+        await approveTx.wait();
+        const nordContract = new ethers_1.ethers.Contract(this.nord.contractAddress, abis_1.NORD_RAMP_FACET_ABI, await provider.getSigner());
+        const depositTx = await nordContract.depositUnchecked(this.publicKey, BigInt(0), ethers_1.ethers.parseUnits(amount.toString(), erc20.precision), {
+            maxFeePerGas: ethers_1.ethers.parseUnits("30", "gwei"),
+            maxPriorityFeePerGas: ethers_1.ethers.parseUnits("0.001", "gwei"),
+        });
+        await depositTx.wait();
+    }
+    async depositApproveTx(provider, amount, tokenId) {
+        const erc20 = this.nord.tokenInfos[tokenId];
+        const erc20Contract = new ethers_1.ethers.Contract(erc20.address, abis_1.ERC20_ABI, await provider.getSigner());
+        const approveTx = await erc20Contract.approve(this.nord.contractAddress, ethers_1.MaxUint256, {
+            maxFeePerGas: ethers_1.ethers.parseUnits("30", "gwei"),
+            maxPriorityFeePerGas: ethers_1.ethers.parseUnits("0.001", "gwei"),
+        });
+        return approveTx.hash;
+    }
+    async depositOnlyTx(provider, amount, tokenId) {
+        const erc20 = this.nord.tokenInfos[tokenId];
+        const nordContract = new ethers_1.ethers.Contract(this.nord.contractAddress, abis_1.NORD_RAMP_FACET_ABI, await provider.getSigner());
+        const depositTx = await nordContract.depositUnchecked(this.publicKey, BigInt(0), ethers_1.ethers.parseUnits(amount.toString(), erc20.precision), {
+            maxFeePerGas: ethers_1.ethers.parseUnits("30", "gwei"),
+            maxPriorityFeePerGas: ethers_1.ethers.parseUnits("0.001", "gwei"),
+        });
+        return depositTx.hash;
+    }
+    async depositEth(provider, amount, tokenId) {
+        if (tokenId || tokenId == 0) {
+            const nordContract = new ethers_1.ethers.Contract(this.nord.contractAddress, abis_1.NORD_RAMP_FACET_ABI, await provider.getSigner());
+            const depositTx = await nordContract.depositUnchecked(this.publicKey, BigInt(1), ethers_1.ethers.parseUnits(amount.toString(), 18), {
+                maxFeePerGas: ethers_1.ethers.parseUnits("30", "gwei"),
+                maxPriorityFeePerGas: ethers_1.ethers.parseUnits("0.001", "gwei"),
+            });
+            await depositTx.wait();
+        }
+        else {
+            //     todo:implement eth deposits
+        }
+    }
+    async withdraw(tokenId, amount) {
+        (0, actions_1.withdraw)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.impl.getTimestamp(), this.getNonce(), {
+            sizeDecimals: (0, utils_1.findToken)(this.nord.tokens, tokenId).decimals,
+            sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
+            tokenId: tokenId,
+            amount,
+        });
+    }
+    async placeOrder(params) {
+        const market = (0, utils_1.findMarket)(this.nord.markets, params.marketId);
+        return (0, actions_1.placeOrder)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.impl.getTimestamp(), this.getNonce(), {
+            sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
+            senderId: params.accountId,
+            sizeDecimals: market.sizeDecimals,
+            priceDecimals: market.priceDecimals,
+            marketId: params.marketId,
+            side: params.side,
+            fillMode: params.fillMode,
+            isReduceOnly: params.isReduceOnly,
+            size: params.size,
+            price: params.price,
+            quoteSize: params.quoteSize,
+        });
+    }
+    async cancelOrder(orderId, accountId) {
+        return (0, actions_1.cancelOrder)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.impl.getTimestamp(), this.getNonce(), {
+            sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
+            senderId: accountId,
+            orderId,
+        });
+    }
+    async transferToAccount(params) {
+        const token = (0, utils_1.findToken)(this.nord.tokens, params.tokenId);
+        await (0, actions_1.transfer)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.impl.getTimestamp(), this.getNonce(), {
+            sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
+            fromAccountId: (0, utils_1.optExpect)(params.fromAccountId, "No source account"),
+            toAccountId: (0, utils_1.optExpect)(params.toAccountId, "No target account"),
+            tokenId: params.tokenId,
+            tokenDecimals: token.decimals,
+            amount: params.amount,
+        });
+    }
+    async createAccount(params) {
+        const token = (0, utils_1.findToken)(this.nord.tokens, params.tokenId);
+        const maybeToAccountId = await (0, actions_1.transfer)(this.nord.webServerUrl, this.sessionSignFn, await this.nord.impl.getTimestamp(), this.getNonce(), {
+            sessionId: (0, utils_1.optExpect)(this.sessionId, "No session"),
+            fromAccountId: (0, utils_1.optExpect)(this.accountIds?.[0], "No source account"),
+            toAccountId: undefined,
+            tokenId: params.tokenId,
+            tokenDecimals: token.decimals,
+            amount: params.amount,
+        });
+        const toAccountId = (0, utils_1.optExpect)(maybeToAccountId, "New account should have been created");
+        const newUser = this.clone();
+        newUser.accountIds?.push(toAccountId);
+        await newUser.fetchInfo();
+        return newUser;
+    }
+}
+exports.NordUser = NordUser;

package/dist/nord/actions.d.ts

@@ -0,0 +1,101 @@
+import { FillMode, Side } from "../types";
+import { BigIntValue } from "../utils";
+import Decimal from "decimal.js";
+declare function createSessionImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, walletSignFn: (message: string | Uint8Array) => Promise<string>, currentTimestamp: bigint, nonce: number, params: {
+    userPubkey: Uint8Array;
+    sessionPubkey: Uint8Array;
+    expiryTimestamp?: bigint;
+}): Promise<bigint>;
+export declare function createSession(serverUrl: string, walletSignFn: (message: string | Uint8Array) => Promise<string>, currentTimestamp: bigint, nonce: number, params: {
+    userPubkey: Uint8Array;
+    sessionPubkey: Uint8Array;
+    expiryTimestamp?: bigint;
+}): Promise<bigint>;
+declare function revokeSessionImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, walletSignFn: (message: string | Uint8Array) => Promise<string>, currentTimestamp: bigint, nonce: number, params: {
+    sessionId: BigIntValue;
+}): Promise<void>;
+export declare function revokeSession(serverUrl: string, walletSignFn: (message: string | Uint8Array) => Promise<string>, currentTimestamp: bigint, nonce: number, params: {
+    sessionId: BigIntValue;
+}): Promise<void>;
+declare function withdrawImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
+    sizeDecimals: number;
+    sessionId: BigIntValue;
+    tokenId: number;
+    amount: Decimal.Value;
+}): Promise<void>;
+export declare function withdraw(serverUrl: string, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
+    sizeDecimals: number;
+    sessionId: BigIntValue;
+    tokenId: number;
+    amount: number;
+}): Promise<void>;
+declare function placeOrderImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
+    sessionId: BigIntValue;
+    senderId?: number;
+    liquidateeId?: number;
+    sizeDecimals: number;
+    priceDecimals: number;
+    marketId: number;
+    side: Side;
+    fillMode: FillMode;
+    isReduceOnly: boolean;
+    size?: Decimal.Value;
+    price?: Decimal.Value;
+    quoteSize?: Decimal.Value;
+    clientOrderId?: BigIntValue;
+}): Promise<bigint | undefined>;
+export declare function placeOrder(serverUrl: string, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
+    sessionId: BigIntValue;
+    senderId?: number;
+    sizeDecimals: number;
+    priceDecimals: number;
+    marketId: number;
+    side: Side;
+    fillMode: FillMode;
+    isReduceOnly: boolean;
+    size?: Decimal.Value;
+    price?: Decimal.Value;
+    quoteSize?: Decimal.Value;
+    liquidateeId?: number;
+    clientOrderId?: BigIntValue;
+}): Promise<bigint | undefined>;
+declare function cancelOrderImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
+    sessionId: BigIntValue;
+    senderId?: number;
+    orderId: BigIntValue;
+    liquidateeId?: number;
+}): Promise<bigint>;
+export declare function cancelOrder(serverUrl: string, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
+    sessionId: BigIntValue;
+    senderId?: number;
+    orderId: BigIntValue;
+    liquidateeId?: number;
+}): Promise<bigint>;
+declare function transferImpl(sendFn: (encoded: Uint8Array) => Promise<Uint8Array>, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
+    sessionId: BigIntValue;
+    fromAccountId: number;
+    toAccountId?: number;
+    tokenId: number;
+    tokenDecimals: number;
+    amount: Decimal.Value;
+}): Promise<number | undefined>;
+export declare function transfer(serverUrl: string, signFn: (message: Uint8Array) => Promise<Uint8Array>, currentTimestamp: bigint, nonce: number, params: {
+    sessionId: BigIntValue;
+    fromAccountId: number;
+    toAccountId?: number;
+    tokenId: number;
+    tokenDecimals: number;
+    amount: Decimal.Value;
+}): Promise<number | undefined>;
+/**
+ * For testing purposes
+ */
+export declare const _private: {
+    createSessionImpl: typeof createSessionImpl;
+    revokeSessionImpl: typeof revokeSessionImpl;
+    withdrawImpl: typeof withdrawImpl;
+    placeOrderImpl: typeof placeOrderImpl;
+    cancelOrderImpl: typeof cancelOrderImpl;
+    transferImpl: typeof transferImpl;
+};
+export {};

package/dist/nord/actions.js

@@ -0,0 +1,254 @@
+"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._private = void 0;
+exports.createSession = createSession;
+exports.revokeSession = revokeSession;
+exports.withdraw = withdraw;
+exports.placeOrder = placeOrder;
+exports.cancelOrder = cancelOrder;
+exports.transfer = transfer;
+const ethers_1 = require("ethers");
+const types_1 = require("../types");
+const utils_1 = require("../utils");
+const proto = __importStar(require("../gen/nord"));
+async function sessionSign(signFn, message) {
+    const signature = await signFn(message);
+    return new Uint8Array([...message, ...signature]);
+}
+async function walletSign(walletSignFn, message) {
+    const signature = await walletSignFn(message);
+    return new Uint8Array([
+        ...message,
+        ...ethers_1.ethers.getBytes(signature.slice(0, -2)),
+    ]);
+}
+function makeSendHttp(serverUrl) {
+    return async (body) => {
+        const response = await (0, utils_1.checkedFetch)(`${serverUrl}/action`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body,
+        });
+        return new Uint8Array(await response.arrayBuffer());
+    };
+}
+async function sendAction(sendFn, makeSignedMessage, action, actionErrorDesc) {
+    const encoded = (0, utils_1.encodeLengthDelimited)(action, proto.Action);
+    const body = await makeSignedMessage(encoded);
+    const rawResp = await sendFn(body);
+    const resp = (0, utils_1.decodeLengthDelimited)(rawResp, proto.Receipt);
+    if (resp.kind?.$case === "err") {
+        throw new Error(`Could not ${actionErrorDesc}, reason: ${proto.errorToJSON(resp.kind.value)}`);
+    }
+    return resp;
+}
+async function createSessionImpl(sendFn, walletSignFn, currentTimestamp, nonce, params) {
+    (0, utils_1.checkPubKeyLength)(types_1.KeyType.Secp256k1, params.userPubkey.length);
+    (0, utils_1.checkPubKeyLength)(types_1.KeyType.Ed25519, params.sessionPubkey.length);
+    let expiry = 0n;
+    if (params.expiryTimestamp !== undefined) {
+        expiry = params.expiryTimestamp;
+        (0, utils_1.assert)(expiry > currentTimestamp, "Cannot set expiry timestamp in the past");
+    }
+    else {
+        expiry = currentTimestamp + utils_1.SESSION_TTL;
+    }
+    const action = {
+        currentTimestamp,
+        nonce,
+        kind: {
+            $case: "createSession",
+            value: {
+                userPubkey: params.userPubkey,
+                blstPubkey: params.sessionPubkey,
+                expiryTimestamp: expiry,
+            },
+        },
+    };
+    const resp = await sendAction(sendFn, (m) => walletSign(walletSignFn, m), action, "create a new session");
+    if (resp.kind?.$case === "createSessionResult") {
+        return resp.kind.value.sessionId;
+    }
+    else {
+        throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+    }
+}
+async function createSession(serverUrl, walletSignFn, currentTimestamp, nonce, params) {
+    return createSessionImpl(makeSendHttp(serverUrl), walletSignFn, currentTimestamp, nonce, params);
+}
+async function revokeSessionImpl(sendFn, walletSignFn, currentTimestamp, nonce, params) {
+    const action = {
+        currentTimestamp,
+        nonce,
+        kind: {
+            $case: "revokeSession",
+            value: {
+                sessionId: BigInt(params.sessionId),
+            },
+        },
+    };
+    await sendAction(sendFn, (m) => walletSign(walletSignFn, m), action, "create a new session");
+}
+async function revokeSession(serverUrl, walletSignFn, currentTimestamp, nonce, params) {
+    return revokeSessionImpl(makeSendHttp(serverUrl), walletSignFn, currentTimestamp, nonce, params);
+}
+async function withdrawImpl(sendFn, signFn, currentTimestamp, nonce, params) {
+    const amount = (0, utils_1.toScaledU64)(params.amount, params.sizeDecimals);
+    if (amount <= 0) {
+        throw new Error("Withdraw amount must be positive");
+    }
+    const action = {
+        currentTimestamp,
+        nonce,
+        kind: {
+            $case: "withdraw",
+            value: {
+                sessionId: BigInt(params.sessionId),
+                tokenId: params.tokenId,
+                amount,
+            },
+        },
+    };
+    await sendAction(sendFn, (m) => sessionSign(signFn, m), action, "withdraw");
+}
+async function withdraw(serverUrl, signFn, currentTimestamp, nonce, params) {
+    return withdrawImpl(makeSendHttp(serverUrl), signFn, currentTimestamp, nonce, params);
+}
+async function placeOrderImpl(sendFn, signFn, currentTimestamp, nonce, params) {
+    const price = (0, utils_1.toScaledU64)(params.price ?? 0, params.priceDecimals);
+    const size = (0, utils_1.toScaledU64)(params.size ?? 0, params.sizeDecimals);
+    const quoteSize = (0, utils_1.toScaledU128)(params.quoteSize ?? 0, params.priceDecimals + params.sizeDecimals);
+    // Compose action object
+    const action = {
+        currentTimestamp,
+        nonce,
+        kind: {
+            $case: "placeOrder",
+            value: {
+                sessionId: BigInt(params.sessionId),
+                senderAccountId: params.senderId,
+                marketId: params.marketId,
+                side: params.side === types_1.Side.Bid ? proto.Side.BID : proto.Side.ASK,
+                fillMode: (0, types_1.fillModeToProtoFillMode)(params.fillMode),
+                isReduceOnly: params.isReduceOnly,
+                price,
+                size,
+                quoteSize: (0, utils_1.bigIntToProtoU128)(quoteSize),
+                clientOrderId: (0, utils_1.optMap)(params.clientOrderId, (x) => BigInt(x)),
+                delegatorAccountId: params.liquidateeId,
+            },
+        },
+    };
+    const resp = await sendAction(sendFn, (m) => sessionSign(signFn, m), action, "place the order");
+    if (resp.kind?.$case === "placeOrderResult") {
+        return resp.kind.value.posted?.orderId;
+    }
+    else {
+        throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+    }
+}
+async function placeOrder(serverUrl, signFn, currentTimestamp, nonce, params) {
+    return placeOrderImpl(makeSendHttp(serverUrl), signFn, currentTimestamp, nonce, params);
+}
+async function cancelOrderImpl(sendFn, signFn, currentTimestamp, nonce, params) {
+    const action = {
+        currentTimestamp,
+        nonce: nonce,
+        kind: {
+            $case: "cancelOrderById",
+            value: {
+                orderId: BigInt(params.orderId),
+                sessionId: BigInt(params.sessionId),
+                senderAccountId: params.senderId,
+                delegatorAccountId: params.liquidateeId,
+            },
+        },
+    };
+    const resp = await sendAction(sendFn, (m) => sessionSign(signFn, m), action, "cancel the order");
+    if (resp.kind?.$case === "cancelOrderResult") {
+        return resp.kind.value.orderId;
+    }
+    else {
+        throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+    }
+}
+async function cancelOrder(serverUrl, signFn, currentTimestamp, nonce, params) {
+    return cancelOrderImpl(makeSendHttp(serverUrl), signFn, currentTimestamp, nonce, params);
+}
+async function transferImpl(sendFn, signFn, currentTimestamp, nonce, params) {
+    const action = {
+        currentTimestamp,
+        nonce: nonce,
+        kind: {
+            $case: "transfer",
+            value: {
+                sessionId: BigInt(params.sessionId),
+                fromAccountId: params.fromAccountId,
+                toAccountId: params.toAccountId,
+                tokenId: params.tokenId,
+                amount: (0, utils_1.toScaledU64)(params.amount ?? 0, params.tokenDecimals),
+            },
+        },
+    };
+    const resp = await sendAction(sendFn, (m) => sessionSign(signFn, m), action, "transfer asset to other account");
+    if (resp.kind?.$case === "transferred") {
+        if (resp.kind.value.accountCreated) {
+            return resp.kind.value.toAccountId;
+        }
+        else {
+            return undefined;
+        }
+    }
+    else {
+        throw new Error(`Unexpected receipt kind ${resp.kind?.$case}`);
+    }
+}
+async function transfer(serverUrl, signFn, currentTimestamp, nonce, params) {
+    return transferImpl(makeSendHttp(serverUrl), signFn, currentTimestamp, nonce, params);
+}
+/**
+ * For testing purposes
+ */
+exports._private = {
+    createSessionImpl,
+    revokeSessionImpl,
+    withdrawImpl,
+    placeOrderImpl,
+    cancelOrderImpl,
+    transferImpl,
+};

package/dist/nord/index.d.ts

@@ -0,0 +1,2 @@
+export { NordUser } from "./NordUser";
+export { Nord, createWebSocketSubscription, Subscriber } from "./Nord";

package/dist/nord/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subscriber = exports.createWebSocketSubscription = exports.Nord = exports.NordUser = void 0;
+var NordUser_1 = require("./NordUser");
+Object.defineProperty(exports, "NordUser", { enumerable: true, get: function () { return NordUser_1.NordUser; } });
+var Nord_1 = require("./Nord");
+Object.defineProperty(exports, "Nord", { enumerable: true, get: function () { return Nord_1.Nord; } });
+Object.defineProperty(exports, "createWebSocketSubscription", { enumerable: true, get: function () { return Nord_1.createWebSocketSubscription; } });
+Object.defineProperty(exports, "Subscriber", { enumerable: true, get: function () { return Nord_1.Subscriber; } });