@argonprotocol/mainchain 1.3.12 → 1.3.14

package/browser/index.d.ts

@@ -93,12 +93,12 @@ import { SignerOptions, ApiDecoration, ApiOptions } from '@polkadot/api/types';
 export { ApiDecoration } from '@polkadot/api/types';
 import { SubmittableExtrinsic as SubmittableExtrinsic$1 } from '@polkadot/api/promise/types';
 export { SubmittableExtrinsic } from '@polkadot/api/promise/types';
+import { DispatchError as DispatchError$1 } from '@polkadot/types/interfaces';
 import * as _polkadot_types_types_extrinsic from '@polkadot/types/types/extrinsic';
 import { ISubmittableResult } from '@polkadot/types/types/extrinsic';
 export { IExtrinsic, ISignerPayload, ISubmittableResult, Signer, SignerResult } from '@polkadot/types/types/extrinsic';
 import { GenericEvent } from '@polkadot/types/generic';
 export { GenericAddress, GenericBlock, GenericEvent } from '@polkadot/types/generic';
-import { DispatchError as DispatchError$1 } from '@polkadot/types/interfaces';
 import BigNumber from 'bignumber.js';
 export { hexToU8a, u8aEq, u8aToHex } from '@polkadot/util';
 
@@ -3814,7 +3814,7 @@ declare module '@polkadot/api-base/types/storage' {
         };
         miningSlot: {
             /**
-             * Lookup by account id to the corresponding index in MinersByCohort and MinerXorKeysByCohort
+             * Lookup by account id to the corresponding index in MinersByCohort and MinerNoncesByCohort
              **/
             accountIndexLookup: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<ITuple<[u64, u32]>>>, [
                 AccountId32
@@ -3852,17 +3852,17 @@ declare module '@polkadot/api-base/types/storage' {
              * Is the next slot still open for bids
              **/
             isNextSlotBiddingOpen: AugmentedQuery<ApiType, () => Observable<bool>, []>;
+            /**
+             * This is a lookup of each miner's nonce to use when picking a best authority to submit a block.
+             * It's a blake2 256 hash of the miner account id and the block hash at time of activation.
+             **/
+            minerNoncesByCohort: AugmentedQuery<ApiType, () => Observable<BTreeMap<u64, Vec<U256>>>, []>;
             /**
              * Miners that are active in the current block (post initialize) by their starting frame
              **/
             minersByCohort: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Vec<ArgonPrimitivesBlockSealMiningRegistration>>, [
                 u64
             ]>;
-            /**
-             * This is a lookup of each miner's XOR key to use. It's a blake2 256 hash of the miner account
-             * id and the block hash at time of activation.
-             **/
-            minerXorKeysByCohort: AugmentedQuery<ApiType, () => Observable<BTreeMap<u64, Vec<U256>>>, []>;
             /**
              * The mining slot configuration set in genesis
              **/
@@ -9796,7 +9796,7 @@ declare module '@polkadot/types/lookup' {
         readonly sealStrength: U256;
         readonly totalComputeDifficulty: U256;
         readonly voteCreatedBlocks: Compact<u128>;
-        readonly minerVoteXorDistance: Option<U256>;
+        readonly minerNonceScore: Option<U256>;
     }
     /** @name ArgonPrimitivesDigestsNotebookDigest (170) */
     interface ArgonPrimitivesDigestsNotebookDigest extends Struct {
@@ -10261,7 +10261,7 @@ declare module '@polkadot/types/lookup' {
             readonly sourceNotebookNumber: Compact<u32>;
             readonly sourceNotebookProof: ArgonPrimitivesBalanceChangeMerkleProof;
             readonly blockVote: ArgonPrimitivesBlockVoteBlockVoteT;
-            readonly xorDistance: Option<U256>;
+            readonly minerNonceScore: Option<U256>;
         } & Struct;
         readonly isCompute: boolean;
         readonly type: 'Vote' | 'Compute';
@@ -11418,59 +11418,6 @@ declare class WageProtector {
     static create(client: ArgonClient): Promise<WageProtector>;
 }
 
-declare class TxSubmitter {
-    readonly client: ArgonClient;
-    tx: SubmittableExtrinsic$1;
-    pair: KeyringPair;
-    constructor(client: ArgonClient, tx: SubmittableExtrinsic$1, pair: KeyringPair);
-    feeEstimate(tip?: bigint): Promise<bigint>;
-    canAfford(options?: {
-        tip?: bigint;
-        unavailableBalance?: bigint;
-        includeExistentialDeposit?: boolean;
-    }): Promise<{
-        canAfford: boolean;
-        availableBalance: bigint;
-        txFee: bigint;
-    }>;
-    submit(options?: Partial<SignerOptions> & {
-        logResults?: boolean;
-        waitForBlock?: boolean;
-        useLatestNonce?: boolean;
-        txProgressCallback?: ITxProgressCallback;
-    }): Promise<TxResult>;
-}
-type ITxProgressCallback = (progressToInBlock: number, result?: TxResult) => void;
-declare class TxResult {
-    private readonly client;
-    private shouldLog;
-    inBlockPromise: Promise<Uint8Array>;
-    finalizedPromise: Promise<Uint8Array>;
-    status?: ISubmittableResult['status'];
-    readonly events: GenericEvent[];
-    /**
-     * The index of the batch that was interrupted, if any.
-     */
-    batchInterruptedIndex?: number;
-    includedInBlock?: Uint8Array;
-    /**
-     * The final fee paid for the transaction, including the fee tip.
-     */
-    finalFee?: bigint;
-    /**
-     * The fee tip paid for the transaction.
-     */
-    finalFeeTip?: bigint;
-    txProgressCallback?: ITxProgressCallback;
-    private inBlockResolve;
-    private inBlockReject;
-    private finalizedResolve;
-    private finalizedReject;
-    constructor(client: ArgonClient, shouldLog?: boolean);
-    onResult(result: ISubmittableResult): void;
-    private reject;
-}
-
 declare const MICROGONS_PER_ARGON = 1000000;
 declare function formatArgons(microgons: bigint | number): string;
 declare function gettersToObject<T>(obj: T): Promise<T>;
@@ -11492,6 +11439,92 @@ declare function dispatchErrorToExtrinsicError(client: ArgonClient, error: Dispa
  */
 declare function checkForExtrinsicSuccess(events: EventRecord[], client: ArgonClient): Promise<void>;
 
+type ITxProgressCallback = (progressToInBlock: number, result?: TxResult) => void;
+declare class TxResult {
+    #private;
+    protected readonly client: ArgonClient;
+    extrinsic: {
+        signedHash: string;
+        method: any;
+        submittedTime: Date;
+        submittedAtBlockNumber: number;
+        accountAddress: string;
+    };
+    set isBroadcast(value: boolean);
+    get isBroadcast(): boolean;
+    set submissionError(value: Error);
+    get submissionError(): Error | undefined;
+    waitForFinalizedBlock: Promise<Uint8Array>;
+    waitForInFirstBlock: Promise<Uint8Array>;
+    events: GenericEvent[];
+    extrinsicError: ExtrinsicError | Error | undefined;
+    extrinsicIndex: number | undefined;
+    txProgressCallback?: ITxProgressCallback;
+    /**
+     * The index of the batch that was interrupted, if any.
+     */
+    batchInterruptedIndex?: number;
+    blockHash?: Uint8Array;
+    blockNumber?: number;
+    /**
+     * The final fee paid for the transaction, including the fee tip.
+     */
+    finalFee?: bigint;
+    /**
+     * The fee tip paid for the transaction.
+     */
+    finalFeeTip?: bigint;
+    txProgress: number;
+    isFinalized: boolean;
+    protected finalizedResolve: (block: Uint8Array) => void;
+    protected finalizedReject: (error: ExtrinsicError | Error) => void;
+    protected inBlockResolve: (block: Uint8Array) => void;
+    protected inBlockReject: (error: ExtrinsicError | Error) => void;
+    constructor(client: ArgonClient, extrinsic: {
+        signedHash: string;
+        method: any;
+        submittedTime: Date;
+        submittedAtBlockNumber: number;
+        accountAddress: string;
+    });
+    setSeenInBlock(block: {
+        blockHash: Uint8Array;
+        blockNumber?: number;
+        extrinsicIndex: number;
+        events: GenericEvent[];
+    }): Promise<void>;
+    setFinalized(): void;
+    onSubscriptionResult(result: ISubmittableResult): void;
+    private updateProgress;
+    private parseEvents;
+}
+
+type ISubmittableOptions = Partial<SignerOptions> & {
+    tip?: bigint;
+    logResults?: boolean;
+    useLatestNonce?: boolean;
+    txProgressCallback?: ITxProgressCallback;
+    disableAutomaticTxTracking?: boolean;
+};
+declare class TxSubmitter {
+    readonly client: ArgonClient;
+    tx: SubmittableExtrinsic$1;
+    pair: KeyringPair;
+    constructor(client: ArgonClient, tx: SubmittableExtrinsic$1, pair: KeyringPair);
+    feeEstimate(tip?: bigint): Promise<bigint>;
+    canAfford(options?: {
+        tip?: bigint;
+        unavailableBalance?: bigint;
+        includeExistentialDeposit?: boolean;
+    }): Promise<{
+        canAfford: boolean;
+        availableBalance: bigint;
+        txFee: bigint;
+    }>;
+    submit(options?: ISubmittableOptions): Promise<TxResult>;
+    private logRequest;
+}
+
 declare function keyringFromSuri(suri: string, cryptoType?: 'sr25519' | 'ed25519'): KeyringPair;
 declare function createKeyringPair(opts: {
     cryptoType?: 'sr25519' | 'ed25519';
@@ -11536,13 +11569,11 @@ declare class Vault {
         baseFee: bigint | number;
         bitcoinXpub: string;
         treasuryProfitSharing: number;
-        tip?: bigint;
         doNotExceedBalance?: bigint;
-        txProgressCallback?: ITxProgressCallback;
-    }, config?: {
+    } & ISubmittableOptions, config?: {
         tickDurationMillis?: number;
     }): Promise<{
-        vault: Vault;
+        getVault(): Promise<Vault>;
         txResult: TxResult;
     }>;
 }
@@ -11604,8 +11635,7 @@ declare class BitcoinLocks {
         utxoId: number;
         vaultSignature: Uint8Array;
         argonKeyring: KeyringPair;
-        txProgressCallback?: ITxProgressCallback;
-    }): Promise<TxResult>;
+    } & ISubmittableOptions): Promise<TxResult>;
     getBitcoinLock(utxoId: number): Promise<IBitcoinLock | undefined>;
     /**
      * Finds the cosign signature for a vault lock by UTXO ID. Optionally waits for the signature
@@ -11646,11 +11676,11 @@ declare class BitcoinLocks {
         ownerBitcoinPubkey: Uint8Array;
         argonKeyring: KeyringPair;
         satoshis: bigint;
-        tip?: bigint;
-        txProgressCallback?: ITxProgressCallback;
-    }): Promise<{
-        lock: IBitcoinLock;
-        createdAtHeight: number;
+    } & ISubmittableOptions): Promise<{
+        getLock(): Promise<{
+            lock: IBitcoinLock;
+            createdAtHeight: number;
+        }>;
         txResult: TxResult;
         securityFee: bigint;
     }>;
@@ -11660,12 +11690,7 @@ declare class BitcoinLocks {
         priceIndex: PriceIndex;
         releaseRequest: IReleaseRequest;
         argonKeyring: KeyringPair;
-        tip?: bigint;
-        txProgressCallback?: ITxProgressCallback;
-    }): Promise<{
-        blockHash: Uint8Array;
-        blockHeight: number;
-    }>;
+    } & ISubmittableOptions): Promise<TxResult>;
     releasePrice(priceIndex: PriceIndex, lock: {
         satoshis: bigint;
         peggedPrice: bigint;
@@ -11679,18 +11704,19 @@ declare class BitcoinLocks {
         lock: IBitcoinLock;
         priceIndex: PriceIndex;
         argonKeyring: KeyringPair;
-        tip?: bigint;
         vault: Vault;
-        txProgressCallback?: ITxProgressCallback;
-    }): Promise<{
-        securityFee: bigint;
-        txFee: bigint;
-        newPeggedPrice: bigint;
-        liquidityPromised: bigint;
-        pendingMint: bigint;
-        burned: bigint;
-        blockHeight: number;
-        bitcoinBlockHeight: number;
+    } & ISubmittableOptions): Promise<{
+        txResult: TxResult;
+        getRatchetResult: () => Promise<{
+            securityFee: bigint;
+            txFee: bigint;
+            newPeggedPrice: bigint;
+            liquidityPromised: bigint;
+            pendingMint: bigint;
+            burned: bigint;
+            blockHeight: number;
+            bitcoinBlockHeight: number;
+        }>;
     }>;
 }
 interface IBitcoinLockConfig {
@@ -11746,4 +11772,4 @@ declare function waitForLoad(): Promise<void>;
  */
 declare function getClient(host: string, options?: ApiOptions): Promise<ArgonClient>;
 
-export { type ArgonClient, BitcoinLocks, ExtrinsicError, FIXED_U128_DECIMALS, type IBitcoinLock, type IBitcoinLockConfig, type IReleaseRequest, type IReleaseRequestDetails, type ITerms, type ITxProgressCallback, MICROGONS_PER_ARGON, PERMILL_DECIMALS, PriceIndex, SATS_PER_BTC, TxResult, TxSubmitter, Vault, WageProtector, checkForExtrinsicSuccess, createKeyringPair, dispatchErrorToExtrinsicError, dispatchErrorToString, formatArgons, fromFixedNumber, getAuthorFromHeader, getClient, getTickFromHeader, gettersToObject, keyringFromSuri, toFixedNumber, waitForLoad };
+export { type ArgonClient, BitcoinLocks, ExtrinsicError, FIXED_U128_DECIMALS, type IBitcoinLock, type IBitcoinLockConfig, type IReleaseRequest, type IReleaseRequestDetails, type ISubmittableOptions, type ITerms, type ITxProgressCallback, MICROGONS_PER_ARGON, PERMILL_DECIMALS, PriceIndex, SATS_PER_BTC, TxResult, TxSubmitter, Vault, WageProtector, checkForExtrinsicSuccess, createKeyringPair, dispatchErrorToExtrinsicError, dispatchErrorToString, formatArgons, fromFixedNumber, getAuthorFromHeader, getClient, getTickFromHeader, gettersToObject, keyringFromSuri, toFixedNumber, waitForLoad };