@autonomys/auto-consensus 1.5.13 → 1.5.14

package/README.md

@@ -22,7 +22,7 @@ The **Autonomys Auto Consensus SDK** (`@autonomys/auto-consensus`) offers a suit
 - **Account Management**: Access detailed account information, including nonce and balance data.
 - **Balance Operations**: Retrieve account balances and the total issuance of tokens in the network.
 - **Token Transfers**: Transfer tokens securely between addresses.
-- **Staking Functionality**: Register operators, nominate operators, and manage staking operations.
+- **Staking Functionality**: Register operators, nominate operators, manage staking operations, and withdraw by all/percent/value via helpers.
 - **Blockchain Information Access**: Fetch current block numbers, block hashes, and network timestamps.
 - **Domain Interactions**: Access domain registry information and staking summaries.
 - **TypeScript Support**: Fully typed for enhanced developer experience.
@@ -188,6 +188,46 @@ import { activate, activateWallet, signAndSendTx, disconnect } from '@autonomys/
 
 ### 4. Staking Operations
 
+#### Withdraw Stake Helpers (all / percent / value)
+
+```typescript
+import {
+  withdrawStakeAll,
+  withdrawStakeByPercent,
+  withdrawStakeByValue,
+  events,
+} from '@autonomys/auto-consensus'
+import { activate, activateWallet, signAndSendTx } from '@autonomys/auto-utils'
+;(async () => {
+  const api = await activate({ networkId: 'your_network_id' })
+  const { accounts } = await activateWallet({ networkId: 'your_network_id', mnemonic: '...' })
+  const sender = accounts[0]
+  const operatorId = '1'
+  const account = sender.address
+
+  // Withdraw all
+  const txAll = await withdrawStakeAll({ api, operatorId, account })
+  await signAndSendTx(sender, txAll, [events.withdrawStake])
+
+  // Withdraw by percent (e.g., 25%)
+  const txPct = await withdrawStakeByPercent({ api, operatorId, account, percent: 25 })
+  await signAndSendTx(sender, txPct, [events.withdrawStake])
+
+  // Withdraw by target value (amount in smallest units)
+  // Note: Value is storage-inclusive. Estimated receive uses
+  // totalPayoutValue = currentStakedValue + storageFeeDeposit.currentValue.
+  // Shares are computed at snapshot; if price rises before inclusion,
+  // actual received may exceed the requested amount.
+  const txVal = await withdrawStakeByValue({
+    api,
+    operatorId,
+    account,
+    amountToWithdraw: '500000000000000000',
+  })
+  await signAndSendTx(sender, txVal, [events.withdrawStake])
+})()
+```
+
 #### **Register an Operator**
 
 Register a new operator for staking.

package/dist/position/price.js

@@ -11,7 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.instantSharePrice = exports.operatorEpochSharePrice = void 0;
 const domain_1 = require("../domain");
-const staking_1 = require("../staking");
+const staking_1 = require("../staking/staking");
 const parse_1 = require("../utils/parse");
 const storage_1 = require("../utils/storage");
 /**

package/dist/staking/index.d.ts

@@ -0,0 +1,3 @@
+export * from './staking';
+export * from './withdrawal-helpers';
+//# sourceMappingURL=index.d.ts.map

package/dist/staking/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/staking/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAA;AACzB,cAAc,sBAAsB,CAAA"}

package/dist/staking/index.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./staking"), exports);
+__exportStar(require("./withdrawal-helpers"), exports);

package/dist/staking/staking.d.ts

@@ -0,0 +1,43 @@
+import { Api } from '@autonomys/auto-utils';
+import type { NominateOperatorParams, RegisterOperatorParams, StakingParams, StringNumberOrBigInt, WithdrawStakeParams } from '../types/staking';
+/**
+ * Retrieves all registered operators on the network.
+ */
+export declare const operators: (api: Api) => Promise<import("../types/staking").Operator[]>;
+/**
+ * Retrieves detailed information about a specific operator.
+ */
+export declare const operator: (api: Api, operatorId: StringNumberOrBigInt) => Promise<import("../types/staking").OperatorDetails>;
+/**
+ * Retrieves deposit information for an operator.
+ */
+export declare const deposits: (api: Api, operatorId: StringNumberOrBigInt, account?: string | undefined) => Promise<import("../types/staking").Deposit[]>;
+/**
+ * Retrieves withdrawal information for an operator.
+ */
+export declare const withdrawals: (api: Api, operatorId: StringNumberOrBigInt, account?: string | undefined) => Promise<import("../types/staking").Withdrawal[]>;
+/**
+ * Creates a transaction to register a new operator.
+ */
+export declare const registerOperator: (params: RegisterOperatorParams) => import("@autonomys/auto-utils").SubmittableExtrinsic<"promise", import("@autonomys/auto-utils").ISubmittableResult>;
+/**
+ * Creates a transaction to nominate (stake to) an existing operator.
+ */
+export declare const nominateOperator: (params: NominateOperatorParams) => import("@autonomys/auto-utils").SubmittableExtrinsic<"promise", import("@autonomys/auto-utils").ISubmittableResult>;
+/**
+ * Creates a transaction to withdraw stake from an operator (shares-only).
+ */
+export declare const withdrawStake: (params: WithdrawStakeParams) => import("@autonomys/auto-utils").SubmittableExtrinsic<"promise", import("@autonomys/auto-utils").ISubmittableResult>;
+/**
+ * Creates a transaction to deregister an operator.
+ */
+export declare const deregisterOperator: (params: StakingParams) => import("@autonomys/auto-utils").SubmittableExtrinsic<"promise", import("@autonomys/auto-utils").ISubmittableResult>;
+/**
+ * Creates a transaction to unlock funds from an operator.
+ */
+export declare const unlockFunds: (params: StakingParams) => import("@autonomys/auto-utils").SubmittableExtrinsic<"promise", import("@autonomys/auto-utils").ISubmittableResult>;
+/**
+ * Creates a transaction to unlock a nominator from an operator.
+ */
+export declare const unlockNominator: (params: StakingParams) => import("@autonomys/auto-utils").SubmittableExtrinsic<"promise", import("@autonomys/auto-utils").ISubmittableResult>;
+//# sourceMappingURL=staking.d.ts.map

package/dist/staking/staking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"staking.d.ts","sourceRoot":"","sources":["../../src/staking/staking.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,GAAG,EAA8B,MAAM,uBAAuB,CAAA;AACvE,OAAO,KAAK,EACV,sBAAsB,EACtB,sBAAsB,EACtB,aAAa,EACb,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,kBAAkB,CAAA;AASzB;;GAEG;AACH,eAAO,MAAM,SAAS,GAAU,KAAK,GAAG,mDAQvC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,GAAU,KAAK,GAAG,EAAE,YAAY,oBAAoB,wDAQxE,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,GACnB,KAAK,GAAG,EACR,YAAY,oBAAoB,EAChC,UAAS,MAAM,GAAG,SAAqB,kDAcxC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,WAAW,GACtB,KAAK,GAAG,EACR,YAAY,oBAAoB,EAChC,UAAS,MAAM,GAAG,SAAqB,qDAgBxC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,gBAAgB,GAAI,QAAQ,sBAAsB,wHAmB9D,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,gBAAgB,GAAI,QAAQ,sBAAsB,wHAS9D,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,aAAa,GAAI,QAAQ,mBAAmB,wHAWxD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAAI,QAAQ,aAAa,wHASvD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,WAAW,GAAI,QAAQ,aAAa,wHAShD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,eAAe,GAAI,QAAQ,aAAa,wHASpD,CAAA"}

package/dist/staking/staking.js

@@ -0,0 +1,182 @@
+"use strict";
+// file: src/staking/staking.ts
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unlockNominator = exports.unlockFunds = exports.deregisterOperator = exports.withdrawStake = exports.nominateOperator = exports.registerOperator = exports.withdrawals = exports.deposits = exports.operator = exports.operators = void 0;
+const auto_utils_1 = require("@autonomys/auto-utils");
+const parse_1 = require("../utils/parse");
+/**
+ * Retrieves all registered operators on the network.
+ */
+const operators = (api) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const _operators = yield api.query.domains.operators.entries();
+        return _operators.map((o) => (0, parse_1.parseOperator)(o));
+    }
+    catch (error) {
+        console.error('error', error);
+        throw new Error('Error querying operators list.' + error);
+    }
+});
+exports.operators = operators;
+/**
+ * Retrieves detailed information about a specific operator.
+ */
+const operator = (api, operatorId) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const _operator = yield api.query.domains.operators((0, parse_1.parseString)(operatorId));
+        return (0, parse_1.parseOperatorDetails)(_operator);
+    }
+    catch (error) {
+        console.error('error', error);
+        throw new Error(`Error querying operatorId: ${operatorId} with error: ${error}`);
+    }
+});
+exports.operator = operator;
+/**
+ * Retrieves deposit information for an operator.
+ */
+const deposits = (api_1, operatorId_1, ...args_1) => __awaiter(void 0, [api_1, operatorId_1, ...args_1], void 0, function* (api, operatorId, account = undefined) {
+    try {
+        if (account) {
+            const _deposits = yield api.query.domains.deposits.entries((0, parse_1.parseString)(operatorId));
+            return _deposits.map((o) => (0, parse_1.parseDeposit)(o)).filter((deposit) => deposit.account === account);
+        }
+        else {
+            const _deposits = yield api.query.domains.deposits.entries((0, parse_1.parseString)(operatorId));
+            return _deposits.map((o) => (0, parse_1.parseDeposit)(o));
+        }
+    }
+    catch (error) {
+        console.error('error', error);
+        throw new Error('Error querying deposits list.' + error);
+    }
+});
+exports.deposits = deposits;
+/**
+ * Retrieves withdrawal information for an operator.
+ */
+const withdrawals = (api_1, operatorId_1, ...args_1) => __awaiter(void 0, [api_1, operatorId_1, ...args_1], void 0, function* (api, operatorId, account = undefined) {
+    try {
+        if (account) {
+            const _withdrawals = yield api.query.domains.withdrawals.entries((0, parse_1.parseString)(operatorId));
+            return _withdrawals
+                .map((o) => (0, parse_1.parseWithdrawal)(o))
+                .filter((withdrawal) => withdrawal.account === account);
+        }
+        else {
+            const _withdrawals = yield api.query.domains.withdrawals.entries((0, parse_1.parseString)(operatorId));
+            return _withdrawals.map((o) => (0, parse_1.parseWithdrawal)(o));
+        }
+    }
+    catch (error) {
+        console.error('error', error);
+        throw new Error('Error querying withdrawals list.' + error);
+    }
+});
+exports.withdrawals = withdrawals;
+/**
+ * Creates a transaction to register a new operator.
+ */
+const registerOperator = (params) => {
+    try {
+        const { api, domainId, amountToStake, minimumNominatorStake, nominationTax, publicKey } = params;
+        let signingKey = params.signingKey;
+        if (!signingKey && !publicKey)
+            throw new Error('Signing key or public key not provided');
+        else if (!signingKey && publicKey)
+            signingKey = (0, auto_utils_1.signingKey)(publicKey);
+        if (!signingKey)
+            throw new Error('Signing key not provided');
+        return api.tx.domains.registerOperator((0, parse_1.parseString)(domainId), (0, parse_1.parseString)(amountToStake), {
+            signingKey,
+            minimumNominatorStake: (0, parse_1.parseString)(minimumNominatorStake),
+            nominationTax: (0, parse_1.parseString)(nominationTax),
+        });
+    }
+    catch (error) {
+        console.error('error', error);
+        throw new Error('Error creating register operator tx.' + error);
+    }
+};
+exports.registerOperator = registerOperator;
+/**
+ * Creates a transaction to nominate (stake to) an existing operator.
+ */
+const nominateOperator = (params) => {
+    try {
+        const { api, operatorId, amountToStake } = params;
+        return api.tx.domains.nominateOperator((0, parse_1.parseString)(operatorId), (0, parse_1.parseString)(amountToStake));
+    }
+    catch (error) {
+        console.error('error', error);
+        throw new Error('Error creating nominate operator tx.' + error);
+    }
+};
+exports.nominateOperator = nominateOperator;
+/**
+ * Creates a transaction to withdraw stake from an operator (shares-only).
+ */
+const withdrawStake = (params) => {
+    try {
+        const { api, operatorId, shares } = params;
+        if (shares === undefined || shares === null)
+            throw new Error('Provide shares(string/number/bigint) to withdraw stake');
+        return api.tx.domains.withdrawStake((0, parse_1.parseString)(operatorId), (0, parse_1.parseString)(shares));
+    }
+    catch (error) {
+        console.error('error', error);
+        throw new Error('Error creating withdraw stake tx.' + error);
+    }
+};
+exports.withdrawStake = withdrawStake;
+/**
+ * Creates a transaction to deregister an operator.
+ */
+const deregisterOperator = (params) => {
+    try {
+        const { api, operatorId } = params;
+        return api.tx.domains.deregisterOperator((0, parse_1.parseString)(operatorId));
+    }
+    catch (error) {
+        console.error('error', error);
+        throw new Error('Error creating de-register operator tx.' + error);
+    }
+};
+exports.deregisterOperator = deregisterOperator;
+/**
+ * Creates a transaction to unlock funds from an operator.
+ */
+const unlockFunds = (params) => {
+    try {
+        const { api, operatorId } = params;
+        return api.tx.domains.unlockFunds((0, parse_1.parseString)(operatorId));
+    }
+    catch (error) {
+        console.error('error', error);
+        throw new Error('Error creating unlock funds tx.' + error);
+    }
+};
+exports.unlockFunds = unlockFunds;
+/**
+ * Creates a transaction to unlock a nominator from an operator.
+ */
+const unlockNominator = (params) => {
+    try {
+        const { api, operatorId } = params;
+        return api.tx.domains.unlockNominator((0, parse_1.parseString)(operatorId));
+    }
+    catch (error) {
+        console.error('error', error);
+        throw new Error('Error creating unlock nominator tx.' + error);
+    }
+};
+exports.unlockNominator = unlockNominator;

package/dist/staking/withdrawal-helpers.d.ts

@@ -0,0 +1,94 @@
+import type { ApiPromise } from '@autonomys/auto-utils';
+import type { StringNumberOrBigInt } from '../types/staking';
+/**
+ * Parameters to withdraw all stake for an account on an operator.
+ */
+export type WithdrawStakeAllParams = {
+    /** Connected API instance */
+    api: ApiPromise;
+    /** Operator ID to withdraw from */
+    operatorId: StringNumberOrBigInt;
+    /** Nominator account ID whose stake is being withdrawn */
+    account: string;
+};
+/**
+ * Parameters to withdraw a percentage of the current stake (rounded down in shares).
+ */
+export type WithdrawStakeByPercentParams = {
+    /** Connected API instance */
+    api: ApiPromise;
+    /** Operator ID to withdraw from */
+    operatorId: StringNumberOrBigInt;
+    /** Nominator account ID whose stake is being withdrawn */
+    account: string;
+    /** Percent in range 0..100 (values are clamped, shares are rounded down) */
+    percent: StringNumberOrBigInt;
+};
+/**
+ * Parameters to withdraw a target value amount (in balance units, not shares).
+ * The helper computes the equivalent shares using the current position.
+ */
+export type WithdrawStakeByValueParams = {
+    /** Connected API instance */
+    api: ApiPromise;
+    /** Operator ID to withdraw from */
+    operatorId: StringNumberOrBigInt;
+    /** Nominator account ID whose stake is being withdrawn */
+    account: string;
+    /** Target amount to withdraw in balance units (will be capped at current value) */
+    amountToWithdraw: StringNumberOrBigInt;
+};
+/**
+ * Creates a submittable extrinsic to withdraw ALL stake for a nominator on a given operator.
+ *
+ * This is a convenience wrapper that:
+ * 1) Fetches the nominator position to obtain totalShares
+ * 2) Calls protocol-native withdrawStake({ shares: totalShares })
+ *
+ * Edge cases:
+ * - Throws if the nominator has no shares
+ *
+ * @param params - {@link WithdrawStakeAllParams}
+ * @returns A submittable extrinsic prepared for submission
+ */
+export declare const withdrawStakeAll: (params: WithdrawStakeAllParams) => Promise<import("@autonomys/auto-utils").SubmittableExtrinsic<"promise", import("@autonomys/auto-utils").ISubmittableResult>>;
+/**
+ * Creates a submittable extrinsic to withdraw a percentage of the current stake.
+ *
+ * Share calculation:
+ * shares = floor(totalShares * clamp(percent, 0..100) / 100)
+ *
+ * Edge cases:
+ * - Percent is clamped to [0, 100]
+ * - Throws if computed shares is zero
+ * - Throws if the nominator has no shares
+ *
+ * @param params - {@link WithdrawStakeByPercentParams}
+ * @returns A submittable extrinsic prepared for submission
+ */
+export declare const withdrawStakeByPercent: (params: WithdrawStakeByPercentParams) => Promise<import("@autonomys/auto-utils").SubmittableExtrinsic<"promise", import("@autonomys/auto-utils").ISubmittableResult>>;
+/**
+ * Creates a submittable extrinsic to withdraw a target value (in balance units) from the current position.
+ *
+ * Storage-inclusive value: This helper uses total payout value = current staked value + current storage fee refund value.
+ * The storage fee refund component is valued at the current bundle storage fund redeem price and varies with time.
+ *
+ * Share calculation (using floor, "at most at snapshot"):
+ *   totalPayoutValue = currentStakedValue + storageFeeDeposit.currentValue
+ *   shares = floor(min(requestedAmount, totalPayoutValue) * totalShares / totalPayoutValue)
+ *
+ * Notes:
+ * - The number of shares is fixed in the extrinsic; actual received tokens may exceed the requested amount if prices rise between calculation and inclusion.
+ *
+ * Edge cases:
+ * - Throws if amountToWithdraw <= 0
+ * - Caps requested amount to totalPayoutValue
+ * - Throws if totalPayoutValue is zero
+ * - Throws if computed shares is zero
+ * - Throws if the nominator has no shares
+ *
+ * @param params - {@link WithdrawStakeByValueParams}
+ * @returns A submittable extrinsic prepared for submission
+ */
+export declare const withdrawStakeByValue: (params: WithdrawStakeByValueParams) => Promise<import("@autonomys/auto-utils").SubmittableExtrinsic<"promise", import("@autonomys/auto-utils").ISubmittableResult>>;
+//# sourceMappingURL=withdrawal-helpers.d.ts.map

package/dist/staking/withdrawal-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withdrawal-helpers.d.ts","sourceRoot":"","sources":["../../src/staking/withdrawal-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAEvD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAI5D;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,6BAA6B;IAC7B,GAAG,EAAE,UAAU,CAAA;IACf,mCAAmC;IACnC,UAAU,EAAE,oBAAoB,CAAA;IAChC,0DAA0D;IAC1D,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,4BAA4B,GAAG;IACzC,6BAA6B;IAC7B,GAAG,EAAE,UAAU,CAAA;IACf,mCAAmC;IACnC,UAAU,EAAE,oBAAoB,CAAA;IAChC,0DAA0D;IAC1D,OAAO,EAAE,MAAM,CAAA;IACf,4EAA4E;IAC5E,OAAO,EAAE,oBAAoB,CAAA;CAC9B,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,0BAA0B,GAAG;IACvC,6BAA6B;IAC7B,GAAG,EAAE,UAAU,CAAA;IACf,mCAAmC;IACnC,UAAU,EAAE,oBAAoB,CAAA;IAChC,0DAA0D;IAC1D,OAAO,EAAE,MAAM,CAAA;IACf,mFAAmF;IACnF,gBAAgB,EAAE,oBAAoB,CAAA;CACvC,CAAA;AAQD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,GAAU,QAAQ,sBAAsB,iIAQpE,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,sBAAsB,GAAU,QAAQ,4BAA4B,iIAehF,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,oBAAoB,GAAU,QAAQ,0BAA0B,iIAyB5E,CAAA"}

package/dist/staking/withdrawal-helpers.js

@@ -0,0 +1,114 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withdrawStakeByValue = exports.withdrawStakeByPercent = exports.withdrawStakeAll = void 0;
+const position_1 = require("../position");
+const parse_1 = require("../utils/parse");
+const staking_1 = require("./staking");
+const clampPercent = (percent) => {
+    if (percent < BigInt(0))
+        return BigInt(0);
+    if (percent > BigInt(100))
+        return BigInt(100);
+    return percent;
+};
+/**
+ * Creates a submittable extrinsic to withdraw ALL stake for a nominator on a given operator.
+ *
+ * This is a convenience wrapper that:
+ * 1) Fetches the nominator position to obtain totalShares
+ * 2) Calls protocol-native withdrawStake({ shares: totalShares })
+ *
+ * Edge cases:
+ * - Throws if the nominator has no shares
+ *
+ * @param params - {@link WithdrawStakeAllParams}
+ * @returns A submittable extrinsic prepared for submission
+ */
+const withdrawStakeAll = (params) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api, operatorId, account } = params;
+    const position = yield (0, position_1.nominatorPosition)(api, operatorId, account);
+    const totalShares = position.totalShares;
+    if (totalShares === BigInt(0))
+        throw new Error('No shares to withdraw for the given account');
+    return (0, staking_1.withdrawStake)({ api, operatorId, shares: totalShares });
+});
+exports.withdrawStakeAll = withdrawStakeAll;
+/**
+ * Creates a submittable extrinsic to withdraw a percentage of the current stake.
+ *
+ * Share calculation:
+ * shares = floor(totalShares * clamp(percent, 0..100) / 100)
+ *
+ * Edge cases:
+ * - Percent is clamped to [0, 100]
+ * - Throws if computed shares is zero
+ * - Throws if the nominator has no shares
+ *
+ * @param params - {@link WithdrawStakeByPercentParams}
+ * @returns A submittable extrinsic prepared for submission
+ */
+const withdrawStakeByPercent = (params) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api, operatorId, account } = params;
+    const rawPercent = BigInt((0, parse_1.parseString)(params.percent));
+    const percent = clampPercent(rawPercent);
+    const position = yield (0, position_1.nominatorPosition)(api, operatorId, account);
+    const totalShares = position.totalShares;
+    if (totalShares === BigInt(0))
+        throw new Error('No shares to withdraw for the given account');
+    const shares = (totalShares * percent) / BigInt(100);
+    if (shares === BigInt(0))
+        throw new Error('Computed zero shares to withdraw; increase percent');
+    return (0, staking_1.withdrawStake)({ api, operatorId, shares });
+});
+exports.withdrawStakeByPercent = withdrawStakeByPercent;
+/**
+ * Creates a submittable extrinsic to withdraw a target value (in balance units) from the current position.
+ *
+ * Storage-inclusive value: This helper uses total payout value = current staked value + current storage fee refund value.
+ * The storage fee refund component is valued at the current bundle storage fund redeem price and varies with time.
+ *
+ * Share calculation (using floor, "at most at snapshot"):
+ *   totalPayoutValue = currentStakedValue + storageFeeDeposit.currentValue
+ *   shares = floor(min(requestedAmount, totalPayoutValue) * totalShares / totalPayoutValue)
+ *
+ * Notes:
+ * - The number of shares is fixed in the extrinsic; actual received tokens may exceed the requested amount if prices rise between calculation and inclusion.
+ *
+ * Edge cases:
+ * - Throws if amountToWithdraw <= 0
+ * - Caps requested amount to totalPayoutValue
+ * - Throws if totalPayoutValue is zero
+ * - Throws if computed shares is zero
+ * - Throws if the nominator has no shares
+ *
+ * @param params - {@link WithdrawStakeByValueParams}
+ * @returns A submittable extrinsic prepared for submission
+ */
+const withdrawStakeByValue = (params) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api, operatorId, account } = params;
+    const requestedAmount = BigInt((0, parse_1.parseString)(params.amountToWithdraw));
+    if (requestedAmount <= BigInt(0))
+        throw new Error('amountToWithdraw must be greater than zero');
+    const position = yield (0, position_1.nominatorPosition)(api, operatorId, account);
+    const { totalShares, currentStakedValue, storageFeeDeposit } = position;
+    if (totalShares === BigInt(0))
+        throw new Error('No shares to withdraw for the given account');
+    const totalPayoutValue = currentStakedValue + storageFeeDeposit.currentValue;
+    if (totalPayoutValue === BigInt(0))
+        throw new Error('No redeemable value to withdraw; cannot compute shares');
+    const effectiveAmount = requestedAmount > totalPayoutValue ? totalPayoutValue : requestedAmount;
+    const shares = (effectiveAmount * totalShares) / totalPayoutValue;
+    if (shares === BigInt(0))
+        throw new Error('Computed zero shares to withdraw; requested amount too small for current price');
+    return (0, staking_1.withdrawStake)({ api, operatorId, shares });
+});
+exports.withdrawStakeByValue = withdrawStakeByValue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autonomys/auto-consensus",
-  "version": "1.5.13",
+  "version": "1.5.14",
   "license": "MIT",
   "main": "dist/index.js",
   "repository": {
@@ -25,7 +25,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@autonomys/auto-utils": "^1.5.13"
+    "@autonomys/auto-utils": "^1.5.14"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",
@@ -35,5 +35,5 @@
     "ts-jest": "^29.3.1",
     "typescript": "^5.8.3"
   },
-  "gitHead": "ed410d97d09e708002b35264bf9f80faccc10d3b"
+  "gitHead": "6f87eed19ee289fad2ee16bd4900f7455ce56680"
 }

package/dist/staking.d.ts

@@ -1,315 +0,0 @@
-import { Api } from '@autonomys/auto-utils';
-import type { NominateOperatorParams, RegisterOperatorParams, StakingParams, StringNumberOrBigInt, WithdrawStakeParams } from './types/staking';
-/**
- * Retrieves all registered operators on the network.
- *
- * This function queries the blockchain to get information about all operators
- * that have been registered across all domains. Operators are entities that
- * process transactions and maintain domain chains.
- *
- * @param api - The connected API instance
- * @returns Promise that resolves to an array of Operator objects
- * @throws Error if the operators query fails
- *
- * @example
- * ```typescript
- * import { operators } from '@autonomys/auto-consensus'
- * import { activate } from '@autonomys/auto-utils'
- *
- * const api = await activate({ networkId: 'mainnet' })
- * const allOperators = await operators(api)
- *
- * allOperators.forEach(op => {
- *   console.log(`Operator ${op.operatorId}: Domain ${op.operatorDetails.currentDomainId}`)
- *   console.log(`Total Stake: ${op.operatorDetails.currentTotalStake}`)
- * })
- * ```
- */
-export declare const operators: (api: Api) => Promise<import("./types/staking").Operator[]>;
-/**
- * Retrieves detailed information about a specific operator.
- *
- * This function queries information about a single operator including their
- * signing key, domain assignment, stake amounts, and operational status.
- *
- * @param api - The connected API instance
- * @param operatorId - The ID of the operator to query
- * @returns Promise that resolves to OperatorDetails object
- * @throws Error if the operator query fails or operator doesn't exist
- *
- * @example
- * ```typescript
- * import { operator } from '@autonomys/auto-consensus'
- * import { activate } from '@autonomys/auto-utils'
- *
- * const api = await activate({ networkId: 'mainnet' })
- * const operatorInfo = await operator(api, '1')
- *
- * console.log(`Domain: ${operatorInfo.currentDomainId}`)
- * console.log(`Total Stake: ${operatorInfo.currentTotalStake}`)
- * console.log(`Minimum Nominator Stake: ${operatorInfo.minimumNominatorStake}`)
- * console.log(`Nomination Tax: ${operatorInfo.nominationTax}%`)
- * ```
- */
-export declare const operator: (api: Api, operatorId: StringNumberOrBigInt) => Promise<import("./types/staking").OperatorDetails>;
-/**
- * Retrieves deposit information for an operator.
- *
- * This function queries all deposits (stakes) made to a specific operator.
- * It can optionally filter deposits by a specific account address.
- *
- * @param api - The connected API instance
- * @param operatorId - The ID of the operator to query deposits for
- * @param account - Optional account address to filter deposits by
- * @returns Promise that resolves to an array of Deposit objects
- * @throws Error if the deposits query fails
- *
- * @example
- * ```typescript
- * import { deposits } from '@autonomys/auto-consensus'
- * import { activate } from '@autonomys/auto-utils'
- *
- * const api = await activate({ networkId: 'mainnet' })
- *
- * // Get all deposits for operator
- * const allDeposits = await deposits(api, '1')
- *
- * // Get deposits for specific account
- * const accountDeposits = await deposits(api, '1', 'account_address')
- *
- * allDeposits.forEach(deposit => {
- *   console.log(`Account: ${deposit.account}, Shares: ${deposit.shares}`)
- * })
- * ```
- */
-export declare const deposits: (api: Api, operatorId: StringNumberOrBigInt, account?: string | undefined) => Promise<import("./types/staking").Deposit[]>;
-/**
- * Retrieves withdrawal information for an operator.
- *
- * This function queries all pending withdrawals for a specific operator.
- * Withdrawals are stakes that have been requested to be unstaked but are
- * still in the withdrawal period. Can optionally filter by account.
- *
- * @param api - The connected API instance
- * @param operatorId - The ID of the operator to query withdrawals for
- * @param account - Optional account address to filter withdrawals by
- * @returns Promise that resolves to an array of Withdrawal objects
- * @throws Error if the withdrawals query fails
- *
- * @example
- * ```typescript
- * import { withdrawals } from '@autonomys/auto-consensus'
- * import { activate } from '@autonomys/auto-utils'
- *
- * const api = await activate({ networkId: 'mainnet' })
- *
- * // Get all withdrawals for operator
- * const allWithdrawals = await withdrawals(api, '1')
- *
- * // Get withdrawals for specific account
- * const accountWithdrawals = await withdrawals(api, '1', 'account_address')
- *
- * allWithdrawals.forEach(withdrawal => {
- *   console.log(`Account: ${withdrawal.account}`)
- *   console.log(`Total Withdrawal: ${withdrawal.totalWithdrawalAmount}`)
- * })
- * ```
- */
-export declare const withdrawals: (api: Api, operatorId: StringNumberOrBigInt, account?: string | undefined) => Promise<import("./types/staking").Withdrawal[]>;
-/**
- * Creates a transaction to register a new operator.
- *
- * This function creates a transaction to register a new operator on a specific domain.
- * The operator will be able to process transactions and earn rewards. Requires
- * initial stake, minimum nominator stake, and nomination tax settings.
- *
- * @param params - RegisterOperatorParams containing all registration parameters
- * @param params.api - The connected API promise instance
- * @param params.domainId - The domain ID where the operator will be registered
- * @param params.amountToStake - Initial amount to stake (in smallest token units)
- * @param params.minimumNominatorStake - Minimum stake required from nominators
- * @param params.nominationTax - Percentage fee charged to nominators
- * @param params.signingKey - Optional signing key (derived from publicKey if not provided)
- * @param params.publicKey - Optional public key (used to derive signingKey if needed)
- * @returns A submittable operator registration transaction
- * @throws Error if signing key/public key not provided or transaction creation fails
- *
- * @example
- * ```typescript
- * import { registerOperator } from '@autonomys/auto-consensus'
- * import { activate, activateWallet, signAndSendTx } from '@autonomys/auto-utils'
- *
- * const api = await activate({ networkId: 'mainnet' })
- * const { accounts } = await activateWallet({ networkId: 'mainnet', mnemonic })
- *
- * const registerTx = registerOperator({
- *   api,
- *   domainId: '0',
- *   amountToStake: '100000000000000000000', // 100 AI3
- *   minimumNominatorStake: '1000000000000000000', // 1 AI3
- *   nominationTax: '10', // 10%
- *   publicKey: accounts[0].publicKey
- * })
- *
- * await signAndSendTx(accounts[0], registerTx)
- * ```
- */
-export declare const registerOperator: (params: RegisterOperatorParams) => import("@autonomys/auto-utils").SubmittableExtrinsic<"promise", import("@autonomys/auto-utils").ISubmittableResult>;
-/**
- * Creates a transaction to nominate (stake to) an existing operator.
- *
- * This function creates a transaction to stake tokens to an existing operator.
- * Nominators earn rewards proportional to their stake, minus the operator's
- * nomination tax. The stake helps secure the network and the specific domain.
- *
- * @param params - NominateOperatorParams containing nomination parameters
- * @param params.api - The connected API promise instance
- * @param params.operatorId - The ID of the operator to nominate
- * @param params.amountToStake - Amount to stake (in smallest token units)
- * @returns A submittable operator nomination transaction
- * @throws Error if transaction creation fails
- *
- * @example
- * ```typescript
- * import { nominateOperator } from '@autonomys/auto-consensus'
- * import { activate, signAndSendTx } from '@autonomys/auto-utils'
- *
- * const api = await activate({ networkId: 'mainnet' })
- *
- * const nominateTx = nominateOperator({
- *   api,
- *   operatorId: '1',
- *   amountToStake: '50000000000000000000' // 50 AI3
- * })
- *
- * await signAndSendTx(nominator, nominateTx)
- * ```
- */
-export declare const nominateOperator: (params: NominateOperatorParams) => import("@autonomys/auto-utils").SubmittableExtrinsic<"promise", import("@autonomys/auto-utils").ISubmittableResult>;
-/**
- * Creates a transaction to withdraw stake from an operator.
- *
- * This function creates a transaction to withdraw staked tokens from an operator.
- * As per the latest protocol, withdrawals are specified strictly in shares.
- * Withdrawn stake enters a withdrawal period before being available.
- *
- * @param params - WithdrawStakeParams containing withdrawal parameters
- * @param params.api - The connected API promise instance
- * @param params.operatorId - The ID of the operator to withdraw stake from
- * @param params.shares - Number of shares to withdraw (string/number/bigint)
- * @returns A submittable stake withdrawal transaction
- * @throws Error if no withdrawal method specified or transaction creation fails
- *
- * @example
- * ```typescript
- * import { withdrawStake } from '@autonomys/auto-consensus'
- * import { activate, signAndSendTx } from '@autonomys/auto-utils'
- *
- * const api = await activate({ networkId: 'mainnet' })
- *
- * // Withdraw all stake
- * const withdrawAllTx = withdrawStake({ api, operatorId: '1', all: true })
- *
- * // Withdraw 50% of stake
- * const withdrawPercentTx = withdrawStake({ api, operatorId: '1', percent: '50' })
- *
- * // Withdraw specific amount
- * const withdrawAmountTx = withdrawStake({
- *   api,
- *   operatorId: '1',
- *   stake: '25000000000000000000'
- * })
- *
- * await signAndSendTx(staker, withdrawAllTx)
- * ```
- */
-export declare const withdrawStake: (params: WithdrawStakeParams) => import("@autonomys/auto-utils").SubmittableExtrinsic<"promise", import("@autonomys/auto-utils").ISubmittableResult>;
-/**
- * Creates a transaction to deregister an operator.
- *
- * This function creates a transaction to deregister an operator, removing them
- * from active service. The operator will no longer process transactions or earn
- * rewards. All stakes will enter the withdrawal period.
- *
- * @param params - StakingParams containing the operator information
- * @param params.api - The connected API promise instance
- * @param params.operatorId - The ID of the operator to deregister
- * @returns A submittable operator deregistration transaction
- * @throws Error if transaction creation fails
- *
- * @example
- * ```typescript
- * import { deregisterOperator } from '@autonomys/auto-consensus'
- * import { activate, signAndSendTx } from '@autonomys/auto-utils'
- *
- * const api = await activate({ networkId: 'mainnet' })
- *
- * const deregisterTx = deregisterOperator({
- *   api,
- *   operatorId: '1'
- * })
- *
- * await signAndSendTx(operatorOwner, deregisterTx)
- * ```
- */
-export declare const deregisterOperator: (params: StakingParams) => import("@autonomys/auto-utils").SubmittableExtrinsic<"promise", import("@autonomys/auto-utils").ISubmittableResult>;
-/**
- * Creates a transaction to unlock funds from an operator.
- *
- * This function creates a transaction to unlock funds that have completed
- * their withdrawal period. These are funds that were previously withdrawn
- * and have now passed the required waiting period.
- *
- * @param params - StakingParams containing the operator information
- * @param params.api - The connected API promise instance
- * @param params.operatorId - The ID of the operator to unlock funds from
- * @returns A submittable unlock funds transaction
- * @throws Error if transaction creation fails
- *
- * @example
- * ```typescript
- * import { unlockFunds } from '@autonomys/auto-consensus'
- * import { activate, signAndSendTx } from '@autonomys/auto-utils'
- *
- * const api = await activate({ networkId: 'mainnet' })
- *
- * const unlockTx = unlockFunds({
- *   api,
- *   operatorId: '1'
- * })
- *
- * await signAndSendTx(account, unlockTx)
- * ```
- */
-export declare const unlockFunds: (params: StakingParams) => import("@autonomys/auto-utils").SubmittableExtrinsic<"promise", import("@autonomys/auto-utils").ISubmittableResult>;
-/**
- * Creates a transaction to unlock a nominator from an operator.
- *
- * This function creates a transaction to unlock a nominator's position,
- * allowing them to withdraw their stake after the withdrawal period.
- * This is typically used when a nominator wants to completely exit their
- * position with an operator.
- *
- * @param params - StakingParams containing the operator information
- * @param params.api - The connected API promise instance
- * @param params.operatorId - The ID of the operator to unlock nominator from
- * @returns A submittable unlock nominator transaction
- * @throws Error if transaction creation fails
- *
- * @example
- * ```typescript
- * import { unlockNominator } from '@autonomys/auto-consensus'
- * import { activate, signAndSendTx } from '@autonomys/auto-utils'
- *
- * const api = await activate({ networkId: 'mainnet' })
- *
- * const unlockNominatorTx = unlockNominator({
- *   api,
- *   operatorId: '1'
- * })
- *
- * await signAndSendTx(nominator, unlockNominatorTx)
- * ```
- */
-export declare const unlockNominator: (params: StakingParams) => import("@autonomys/auto-utils").SubmittableExtrinsic<"promise", import("@autonomys/auto-utils").ISubmittableResult>;
-//# sourceMappingURL=staking.d.ts.map

package/dist/staking.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"staking.d.ts","sourceRoot":"","sources":["../src/staking.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,GAAG,EAA8B,MAAM,uBAAuB,CAAA;AACvE,OAAO,KAAK,EACV,sBAAsB,EACtB,sBAAsB,EACtB,aAAa,EACb,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,iBAAiB,CAAA;AASxB;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,SAAS,GAAU,KAAK,GAAG,kDAQvC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,QAAQ,GAAU,KAAK,GAAG,EAAE,YAAY,oBAAoB,uDAQxE,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,QAAQ,GACnB,KAAK,GAAG,EACR,YAAY,oBAAoB,EAChC,UAAS,MAAM,GAAG,SAAqB,iDAgBxC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,WAAW,GACtB,KAAK,GAAG,EACR,YAAY,oBAAoB,EAChC,UAAS,MAAM,GAAG,SAAqB,oDAkBxC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,gBAAgB,GAAI,QAAQ,sBAAsB,wHAmB9D,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,gBAAgB,GAAI,QAAQ,sBAAsB,wHAS9D,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,aAAa,GAAI,QAAQ,mBAAmB,wHAWxD,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,kBAAkB,GAAI,QAAQ,aAAa,wHASvD,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,WAAW,GAAI,QAAQ,aAAa,wHAShD,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,eAAe,GAAI,QAAQ,aAAa,wHASpD,CAAA"}

package/dist/staking.js

@@ -1,458 +0,0 @@
-"use strict";
-// file: src/staking.ts
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unlockNominator = exports.unlockFunds = exports.deregisterOperator = exports.withdrawStake = exports.nominateOperator = exports.registerOperator = exports.withdrawals = exports.deposits = exports.operator = exports.operators = void 0;
-const auto_utils_1 = require("@autonomys/auto-utils");
-const parse_1 = require("./utils/parse");
-/**
- * Retrieves all registered operators on the network.
- *
- * This function queries the blockchain to get information about all operators
- * that have been registered across all domains. Operators are entities that
- * process transactions and maintain domain chains.
- *
- * @param api - The connected API instance
- * @returns Promise that resolves to an array of Operator objects
- * @throws Error if the operators query fails
- *
- * @example
- * ```typescript
- * import { operators } from '@autonomys/auto-consensus'
- * import { activate } from '@autonomys/auto-utils'
- *
- * const api = await activate({ networkId: 'mainnet' })
- * const allOperators = await operators(api)
- *
- * allOperators.forEach(op => {
- *   console.log(`Operator ${op.operatorId}: Domain ${op.operatorDetails.currentDomainId}`)
- *   console.log(`Total Stake: ${op.operatorDetails.currentTotalStake}`)
- * })
- * ```
- */
-const operators = (api) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        const _operators = yield api.query.domains.operators.entries();
-        return _operators.map((o) => (0, parse_1.parseOperator)(o));
-    }
-    catch (error) {
-        console.error('error', error);
-        throw new Error('Error querying operators list.' + error);
-    }
-});
-exports.operators = operators;
-/**
- * Retrieves detailed information about a specific operator.
- *
- * This function queries information about a single operator including their
- * signing key, domain assignment, stake amounts, and operational status.
- *
- * @param api - The connected API instance
- * @param operatorId - The ID of the operator to query
- * @returns Promise that resolves to OperatorDetails object
- * @throws Error if the operator query fails or operator doesn't exist
- *
- * @example
- * ```typescript
- * import { operator } from '@autonomys/auto-consensus'
- * import { activate } from '@autonomys/auto-utils'
- *
- * const api = await activate({ networkId: 'mainnet' })
- * const operatorInfo = await operator(api, '1')
- *
- * console.log(`Domain: ${operatorInfo.currentDomainId}`)
- * console.log(`Total Stake: ${operatorInfo.currentTotalStake}`)
- * console.log(`Minimum Nominator Stake: ${operatorInfo.minimumNominatorStake}`)
- * console.log(`Nomination Tax: ${operatorInfo.nominationTax}%`)
- * ```
- */
-const operator = (api, operatorId) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        const _operator = yield api.query.domains.operators((0, parse_1.parseString)(operatorId));
-        return (0, parse_1.parseOperatorDetails)(_operator);
-    }
-    catch (error) {
-        console.error('error', error);
-        throw new Error(`Error querying operatorId: ${operatorId} with error: ${error}`);
-    }
-});
-exports.operator = operator;
-/**
- * Retrieves deposit information for an operator.
- *
- * This function queries all deposits (stakes) made to a specific operator.
- * It can optionally filter deposits by a specific account address.
- *
- * @param api - The connected API instance
- * @param operatorId - The ID of the operator to query deposits for
- * @param account - Optional account address to filter deposits by
- * @returns Promise that resolves to an array of Deposit objects
- * @throws Error if the deposits query fails
- *
- * @example
- * ```typescript
- * import { deposits } from '@autonomys/auto-consensus'
- * import { activate } from '@autonomys/auto-utils'
- *
- * const api = await activate({ networkId: 'mainnet' })
- *
- * // Get all deposits for operator
- * const allDeposits = await deposits(api, '1')
- *
- * // Get deposits for specific account
- * const accountDeposits = await deposits(api, '1', 'account_address')
- *
- * allDeposits.forEach(deposit => {
- *   console.log(`Account: ${deposit.account}, Shares: ${deposit.shares}`)
- * })
- * ```
- */
-const deposits = (api_1, operatorId_1, ...args_1) => __awaiter(void 0, [api_1, operatorId_1, ...args_1], void 0, function* (api, operatorId, account = undefined) {
-    try {
-        if (account) {
-            // For specific account, query all deposits for operator and filter
-            const _deposits = yield api.query.domains.deposits.entries((0, parse_1.parseString)(operatorId));
-            return _deposits.map((o) => (0, parse_1.parseDeposit)(o)).filter((deposit) => deposit.account === account);
-        }
-        else {
-            // Query all deposits for operator
-            const _deposits = yield api.query.domains.deposits.entries((0, parse_1.parseString)(operatorId));
-            return _deposits.map((o) => (0, parse_1.parseDeposit)(o));
-        }
-    }
-    catch (error) {
-        console.error('error', error);
-        throw new Error('Error querying deposits list.' + error);
-    }
-});
-exports.deposits = deposits;
-/**
- * Retrieves withdrawal information for an operator.
- *
- * This function queries all pending withdrawals for a specific operator.
- * Withdrawals are stakes that have been requested to be unstaked but are
- * still in the withdrawal period. Can optionally filter by account.
- *
- * @param api - The connected API instance
- * @param operatorId - The ID of the operator to query withdrawals for
- * @param account - Optional account address to filter withdrawals by
- * @returns Promise that resolves to an array of Withdrawal objects
- * @throws Error if the withdrawals query fails
- *
- * @example
- * ```typescript
- * import { withdrawals } from '@autonomys/auto-consensus'
- * import { activate } from '@autonomys/auto-utils'
- *
- * const api = await activate({ networkId: 'mainnet' })
- *
- * // Get all withdrawals for operator
- * const allWithdrawals = await withdrawals(api, '1')
- *
- * // Get withdrawals for specific account
- * const accountWithdrawals = await withdrawals(api, '1', 'account_address')
- *
- * allWithdrawals.forEach(withdrawal => {
- *   console.log(`Account: ${withdrawal.account}`)
- *   console.log(`Total Withdrawal: ${withdrawal.totalWithdrawalAmount}`)
- * })
- * ```
- */
-const withdrawals = (api_1, operatorId_1, ...args_1) => __awaiter(void 0, [api_1, operatorId_1, ...args_1], void 0, function* (api, operatorId, account = undefined) {
-    try {
-        if (account) {
-            // For specific account, query all withdrawals for operator and filter
-            const _withdrawals = yield api.query.domains.withdrawals.entries((0, parse_1.parseString)(operatorId));
-            return _withdrawals
-                .map((o) => (0, parse_1.parseWithdrawal)(o))
-                .filter((withdrawal) => withdrawal.account === account);
-        }
-        else {
-            // Query all withdrawals for operator
-            const _withdrawals = yield api.query.domains.withdrawals.entries((0, parse_1.parseString)(operatorId));
-            return _withdrawals.map((o) => (0, parse_1.parseWithdrawal)(o));
-        }
-    }
-    catch (error) {
-        console.error('error', error);
-        throw new Error('Error querying withdrawals list.' + error);
-    }
-});
-exports.withdrawals = withdrawals;
-/**
- * Creates a transaction to register a new operator.
- *
- * This function creates a transaction to register a new operator on a specific domain.
- * The operator will be able to process transactions and earn rewards. Requires
- * initial stake, minimum nominator stake, and nomination tax settings.
- *
- * @param params - RegisterOperatorParams containing all registration parameters
- * @param params.api - The connected API promise instance
- * @param params.domainId - The domain ID where the operator will be registered
- * @param params.amountToStake - Initial amount to stake (in smallest token units)
- * @param params.minimumNominatorStake - Minimum stake required from nominators
- * @param params.nominationTax - Percentage fee charged to nominators
- * @param params.signingKey - Optional signing key (derived from publicKey if not provided)
- * @param params.publicKey - Optional public key (used to derive signingKey if needed)
- * @returns A submittable operator registration transaction
- * @throws Error if signing key/public key not provided or transaction creation fails
- *
- * @example
- * ```typescript
- * import { registerOperator } from '@autonomys/auto-consensus'
- * import { activate, activateWallet, signAndSendTx } from '@autonomys/auto-utils'
- *
- * const api = await activate({ networkId: 'mainnet' })
- * const { accounts } = await activateWallet({ networkId: 'mainnet', mnemonic })
- *
- * const registerTx = registerOperator({
- *   api,
- *   domainId: '0',
- *   amountToStake: '100000000000000000000', // 100 AI3
- *   minimumNominatorStake: '1000000000000000000', // 1 AI3
- *   nominationTax: '10', // 10%
- *   publicKey: accounts[0].publicKey
- * })
- *
- * await signAndSendTx(accounts[0], registerTx)
- * ```
- */
-const registerOperator = (params) => {
-    try {
-        const { api, domainId, amountToStake, minimumNominatorStake, nominationTax, publicKey } = params;
-        let signingKey = params.signingKey;
-        if (!signingKey && !publicKey)
-            throw new Error('Signing key or public key not provided');
-        else if (!signingKey && publicKey)
-            signingKey = (0, auto_utils_1.signingKey)(publicKey);
-        if (!signingKey)
-            throw new Error('Signing key not provided');
-        return api.tx.domains.registerOperator((0, parse_1.parseString)(domainId), (0, parse_1.parseString)(amountToStake), {
-            signingKey,
-            minimumNominatorStake: (0, parse_1.parseString)(minimumNominatorStake),
-            nominationTax: (0, parse_1.parseString)(nominationTax),
-        });
-    }
-    catch (error) {
-        console.error('error', error);
-        throw new Error('Error creating register operator tx.' + error);
-    }
-};
-exports.registerOperator = registerOperator;
-/**
- * Creates a transaction to nominate (stake to) an existing operator.
- *
- * This function creates a transaction to stake tokens to an existing operator.
- * Nominators earn rewards proportional to their stake, minus the operator's
- * nomination tax. The stake helps secure the network and the specific domain.
- *
- * @param params - NominateOperatorParams containing nomination parameters
- * @param params.api - The connected API promise instance
- * @param params.operatorId - The ID of the operator to nominate
- * @param params.amountToStake - Amount to stake (in smallest token units)
- * @returns A submittable operator nomination transaction
- * @throws Error if transaction creation fails
- *
- * @example
- * ```typescript
- * import { nominateOperator } from '@autonomys/auto-consensus'
- * import { activate, signAndSendTx } from '@autonomys/auto-utils'
- *
- * const api = await activate({ networkId: 'mainnet' })
- *
- * const nominateTx = nominateOperator({
- *   api,
- *   operatorId: '1',
- *   amountToStake: '50000000000000000000' // 50 AI3
- * })
- *
- * await signAndSendTx(nominator, nominateTx)
- * ```
- */
-const nominateOperator = (params) => {
-    try {
-        const { api, operatorId, amountToStake } = params;
-        return api.tx.domains.nominateOperator((0, parse_1.parseString)(operatorId), (0, parse_1.parseString)(amountToStake));
-    }
-    catch (error) {
-        console.error('error', error);
-        throw new Error('Error creating nominate operator tx.' + error);
-    }
-};
-exports.nominateOperator = nominateOperator;
-/**
- * Creates a transaction to withdraw stake from an operator.
- *
- * This function creates a transaction to withdraw staked tokens from an operator.
- * As per the latest protocol, withdrawals are specified strictly in shares.
- * Withdrawn stake enters a withdrawal period before being available.
- *
- * @param params - WithdrawStakeParams containing withdrawal parameters
- * @param params.api - The connected API promise instance
- * @param params.operatorId - The ID of the operator to withdraw stake from
- * @param params.shares - Number of shares to withdraw (string/number/bigint)
- * @returns A submittable stake withdrawal transaction
- * @throws Error if no withdrawal method specified or transaction creation fails
- *
- * @example
- * ```typescript
- * import { withdrawStake } from '@autonomys/auto-consensus'
- * import { activate, signAndSendTx } from '@autonomys/auto-utils'
- *
- * const api = await activate({ networkId: 'mainnet' })
- *
- * // Withdraw all stake
- * const withdrawAllTx = withdrawStake({ api, operatorId: '1', all: true })
- *
- * // Withdraw 50% of stake
- * const withdrawPercentTx = withdrawStake({ api, operatorId: '1', percent: '50' })
- *
- * // Withdraw specific amount
- * const withdrawAmountTx = withdrawStake({
- *   api,
- *   operatorId: '1',
- *   stake: '25000000000000000000'
- * })
- *
- * await signAndSendTx(staker, withdrawAllTx)
- * ```
- */
-const withdrawStake = (params) => {
-    try {
-        const { api, operatorId, shares } = params;
-        if (shares === undefined || shares === null)
-            throw new Error('Provide shares(string/number/bigint) to withdraw stake');
-        return api.tx.domains.withdrawStake((0, parse_1.parseString)(operatorId), (0, parse_1.parseString)(shares));
-    }
-    catch (error) {
-        console.error('error', error);
-        throw new Error('Error creating withdraw stake tx.' + error);
-    }
-};
-exports.withdrawStake = withdrawStake;
-/**
- * Creates a transaction to deregister an operator.
- *
- * This function creates a transaction to deregister an operator, removing them
- * from active service. The operator will no longer process transactions or earn
- * rewards. All stakes will enter the withdrawal period.
- *
- * @param params - StakingParams containing the operator information
- * @param params.api - The connected API promise instance
- * @param params.operatorId - The ID of the operator to deregister
- * @returns A submittable operator deregistration transaction
- * @throws Error if transaction creation fails
- *
- * @example
- * ```typescript
- * import { deregisterOperator } from '@autonomys/auto-consensus'
- * import { activate, signAndSendTx } from '@autonomys/auto-utils'
- *
- * const api = await activate({ networkId: 'mainnet' })
- *
- * const deregisterTx = deregisterOperator({
- *   api,
- *   operatorId: '1'
- * })
- *
- * await signAndSendTx(operatorOwner, deregisterTx)
- * ```
- */
-const deregisterOperator = (params) => {
-    try {
-        const { api, operatorId } = params;
-        return api.tx.domains.deregisterOperator((0, parse_1.parseString)(operatorId));
-    }
-    catch (error) {
-        console.error('error', error);
-        throw new Error('Error creating de-register operator tx.' + error);
-    }
-};
-exports.deregisterOperator = deregisterOperator;
-/**
- * Creates a transaction to unlock funds from an operator.
- *
- * This function creates a transaction to unlock funds that have completed
- * their withdrawal period. These are funds that were previously withdrawn
- * and have now passed the required waiting period.
- *
- * @param params - StakingParams containing the operator information
- * @param params.api - The connected API promise instance
- * @param params.operatorId - The ID of the operator to unlock funds from
- * @returns A submittable unlock funds transaction
- * @throws Error if transaction creation fails
- *
- * @example
- * ```typescript
- * import { unlockFunds } from '@autonomys/auto-consensus'
- * import { activate, signAndSendTx } from '@autonomys/auto-utils'
- *
- * const api = await activate({ networkId: 'mainnet' })
- *
- * const unlockTx = unlockFunds({
- *   api,
- *   operatorId: '1'
- * })
- *
- * await signAndSendTx(account, unlockTx)
- * ```
- */
-const unlockFunds = (params) => {
-    try {
-        const { api, operatorId } = params;
-        return api.tx.domains.unlockFunds((0, parse_1.parseString)(operatorId));
-    }
-    catch (error) {
-        console.error('error', error);
-        throw new Error('Error creating unlock funds tx.' + error);
-    }
-};
-exports.unlockFunds = unlockFunds;
-/**
- * Creates a transaction to unlock a nominator from an operator.
- *
- * This function creates a transaction to unlock a nominator's position,
- * allowing them to withdraw their stake after the withdrawal period.
- * This is typically used when a nominator wants to completely exit their
- * position with an operator.
- *
- * @param params - StakingParams containing the operator information
- * @param params.api - The connected API promise instance
- * @param params.operatorId - The ID of the operator to unlock nominator from
- * @returns A submittable unlock nominator transaction
- * @throws Error if transaction creation fails
- *
- * @example
- * ```typescript
- * import { unlockNominator } from '@autonomys/auto-consensus'
- * import { activate, signAndSendTx } from '@autonomys/auto-utils'
- *
- * const api = await activate({ networkId: 'mainnet' })
- *
- * const unlockNominatorTx = unlockNominator({
- *   api,
- *   operatorId: '1'
- * })
- *
- * await signAndSendTx(nominator, unlockNominatorTx)
- * ```
- */
-const unlockNominator = (params) => {
-    try {
-        const { api, operatorId } = params;
-        return api.tx.domains.unlockNominator((0, parse_1.parseString)(operatorId));
-    }
-    catch (error) {
-        console.error('error', error);
-        throw new Error('Error creating unlock nominator tx.' + error);
-    }
-};
-exports.unlockNominator = unlockNominator;