@argonprotocol/mainchain 1.3.11 → 1.3.13

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';
 
@@ -10865,10 +10865,12 @@ declare module '@polkadot/types/lookup' {
         readonly frameId: Compact<u64>;
         readonly bitcoinLockFeeRevenue: Compact<u128>;
         readonly bitcoinLocksCreated: Compact<u32>;
-        readonly bitcoinLocksMarketValue: Compact<u128>;
-        readonly bitcoinLocksTotalSatoshis: Compact<u64>;
-        readonly satoshisReleased: Compact<u64>;
+        readonly bitcoinLocksNewLiquidityPromised: Compact<u128>;
+        readonly bitcoinLocksReleasedLiquidity: Compact<u128>;
+        readonly bitcoinLocksAddedSatoshis: Compact<u64>;
+        readonly bitcoinLocksReleasedSatoshis: Compact<u64>;
         readonly securitizationActivated: Compact<u128>;
+        readonly securitizationRelockable: Compact<u128>;
         readonly securitization: Compact<u128>;
         readonly treasuryVaultEarnings: Compact<u128>;
         readonly treasuryTotalEarnings: Compact<u128>;
@@ -11416,41 +11418,54 @@ 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>;
+declare const MICROGONS_PER_ARGON = 1000000;
+declare function formatArgons(microgons: bigint | number): string;
+declare function gettersToObject<T>(obj: T): Promise<T>;
+declare function dispatchErrorToString(client: ArgonClient, error: DispatchError$1): string;
+declare class ExtrinsicError extends Error {
+    readonly errorCode: string;
+    readonly details?: string | undefined;
+    readonly batchInterruptedIndex?: number | undefined;
+    readonly txFee: bigint;
+    constructor(errorCode: string, details?: string | undefined, batchInterruptedIndex?: number | undefined, txFee?: bigint);
+    toString(): string;
 }
+declare function dispatchErrorToExtrinsicError(client: ArgonClient, error: DispatchError$1, batchInterruptedIndex?: number, txFee?: bigint): ExtrinsicError;
+/**
+ * Check for an extrinsic success event in the given events. Helpful to validate the result of an extrinsic inclusion in a block (it will be included even if it fails)
+ * @param events The events to check
+ * @param client The client to use
+ * @returns A promise that resolves if the extrinsic was successful, and rejects if it failed
+ */
+declare function checkForExtrinsicSuccess(events: EventRecord[], client: ArgonClient): Promise<void>;
+
 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[];
+    #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;
-    includedInBlock?: Uint8Array;
+    blockHash?: Uint8Array;
+    blockNumber?: number;
     /**
      * The final fee paid for the transaction, including the fee tip.
      */
@@ -11459,35 +11474,56 @@ declare class TxResult {
      * 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;
+    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;
 }
 
-declare const MICROGONS_PER_ARGON = 1000000;
-declare function formatArgons(microgons: bigint | number): string;
-declare function gettersToObject<T>(obj: T): Promise<T>;
-declare function dispatchErrorToString(client: ArgonClient, error: DispatchError$1): string;
-declare class ExtrinsicError extends Error {
-    readonly errorCode: string;
-    readonly details?: string | undefined;
-    readonly batchInterruptedIndex?: number | undefined;
-    constructor(errorCode: string, details?: string | undefined, batchInterruptedIndex?: number | undefined);
-    toString(): string;
+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 dispatchErrorToExtrinsicError(client: ArgonClient, error: DispatchError$1, batchInterruptedIndex?: number): ExtrinsicError;
-/**
- * Check for an extrinsic success event in the given events. Helpful to validate the result of an extrinsic inclusion in a block (it will be included even if it fails)
- * @param events The events to check
- * @param client The client to use
- * @returns A promise that resolves if the extrinsic was successful, and rejects if it failed
- */
-declare function checkForExtrinsicSuccess(events: EventRecord[], client: ArgonClient): Promise<void>;
 
 declare function keyringFromSuri(suri: string, cryptoType?: 'sr25519' | 'ed25519'): KeyringPair;
 declare function createKeyringPair(opts: {
@@ -11533,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;
     }>;
 }
@@ -11601,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
@@ -11628,6 +11661,9 @@ declare class BitcoinLocks {
         tx: _polkadot_api_types.SubmittableExtrinsic<"promise", _polkadot_types_types_extrinsic.ISubmittableResult>;
         securityFee: bigint;
         txFee: bigint;
+        canAfford: boolean;
+        availableBalance: bigint;
+        txFeePlusTip: bigint;
     }>;
     getBitcoinLockFromTxResult(txResult: TxResult): Promise<{
         lock: IBitcoinLock;
@@ -11640,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;
     }>;
@@ -11654,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;
@@ -11673,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 {
@@ -11740,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 };