robonomics-interface-vue 0.1.4 → 0.2.1

package/README.md

@@ -1,6 +1,6 @@
 # Robonomics-interface-vue for javascript
 
-Javascript library for Robonomics network
+Vue composables for Robonomics network
 
 ## Installation
 

package/dist/account/index.d.ts

@@ -0,0 +1,4 @@
+import { useAccount } from "./useAccount.js";
+import { useBalance } from "./useBalance.js";
+import { useSend } from "./useSend.js";
+export { useAccount, useBalance, useSend };

package/dist/account/index.js

@@ -1,3 +1,4 @@
-export { useAccount } from './useAccount.js';
-export { useBalance } from './useBalance.js';
-export { useSend } from './useSend.js';
+import { useAccount } from "./useAccount.js";
+import { useBalance } from "./useBalance.js";
+import { useSend } from "./useSend.js";
+export { useAccount, useBalance, useSend };

package/dist/account/useAccount.d.ts

@@ -0,0 +1,413 @@
+import { KeyringPair } from "@polkadot/keyring/types";
+import { AccountOptions } from "robonomics-interface";
+/**
+ * Vue сomposable for account management
+ * @description Provides functionality for setting transaction sender and subscription
+ * @returns Object with methods and properties for working with account
+ * @example
+ * const { account, pair, setSender, setSubscription } = useAccount()
+ *
+ * setSender(keypair, { subscription: 'subscription_id', signer: {
+ *    signPayload?: (payload: SignerPayloadJSON) => Promise<SignerResult>;
+ *    signRaw?: (raw: SignerPayloadRaw) => Promise<SignerResult>;
+ *    update?: (id: number, status: ISubmittableResult | H256) => void;
+ *  }
+ * })
+ * setSubscription('subscription_id')
+ */
+export declare const useAccount: () => {
+    account: import("vue").Ref<string | null, string | null>;
+    pair: import("vue").Ref<{
+        readonly address: string;
+        readonly addressRaw: {
+            [x: number]: number;
+            readonly BYTES_PER_ELEMENT: number;
+            readonly buffer: {
+                readonly byteLength: number;
+                slice: (begin?: number, end?: number) => ArrayBuffer;
+                readonly maxByteLength: number;
+                readonly resizable: boolean;
+                resize: (newByteLength?: number) => void;
+                readonly detached: boolean;
+                transfer: (newByteLength?: number) => ArrayBuffer;
+                transferToFixedLength: (newByteLength?: number) => ArrayBuffer;
+                readonly [Symbol.toStringTag]: "ArrayBuffer";
+            } | {
+                readonly byteLength: number;
+                slice: (begin?: number, end?: number) => SharedArrayBuffer;
+                readonly growable: boolean;
+                readonly maxByteLength: number;
+                grow: (newByteLength?: number) => void;
+                readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+            };
+            readonly byteLength: number;
+            readonly byteOffset: number;
+            copyWithin: (target: number, start: number, end?: number) => Uint8Array<ArrayBufferLike>;
+            every: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
+            fill: (value: number, start?: number, end?: number) => Uint8Array<ArrayBufferLike>;
+            filter: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => any, thisArg?: any) => Uint8Array<ArrayBuffer>;
+            find: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number | undefined;
+            findIndex: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number;
+            forEach: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => void, thisArg?: any) => void;
+            indexOf: (searchElement: number, fromIndex?: number) => number;
+            join: (separator?: string) => string;
+            lastIndexOf: (searchElement: number, fromIndex?: number) => number;
+            readonly length: number;
+            map: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => number, thisArg?: any) => Uint8Array<ArrayBuffer>;
+            reduce: {
+                (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
+                (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
+                <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
+            };
+            reduceRight: {
+                (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
+                (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
+                <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
+            };
+            reverse: () => Uint8Array<ArrayBufferLike>;
+            set: (array: ArrayLike<number>, offset?: number) => void;
+            slice: (start?: number, end?: number) => Uint8Array<ArrayBuffer>;
+            some: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
+            sort: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBufferLike>;
+            subarray: (begin?: number, end?: number) => Uint8Array<ArrayBufferLike>;
+            toLocaleString: {
+                (): string;
+                (locales: string | string[], options?: Intl.NumberFormatOptions): string;
+            };
+            toString: () => string;
+            valueOf: () => Uint8Array<ArrayBufferLike>;
+            entries: () => ArrayIterator<[number, number]>;
+            keys: () => ArrayIterator<number>;
+            values: () => ArrayIterator<number>;
+            includes: (searchElement: number, fromIndex?: number) => boolean;
+            at: (index: number) => number | undefined;
+            findLast: {
+                <S extends number>(predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => value is S, thisArg?: any): S | undefined;
+                (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any): number | undefined;
+            };
+            findLastIndex: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => number;
+            toReversed: () => Uint8Array<ArrayBuffer>;
+            toSorted: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBuffer>;
+            with: (index: number, value: number) => Uint8Array<ArrayBuffer>;
+            [Symbol.iterator]: () => ArrayIterator<number>;
+            readonly [Symbol.toStringTag]: "Uint8Array";
+        };
+        readonly meta: {
+            [x: string]: unknown;
+            address?: string | undefined;
+            contract?: {
+                abi: string;
+                genesisHash?: (import("@polkadot/util/types").HexString | null) | undefined;
+            } | undefined;
+            genesisHash?: (import("@polkadot/util/types").HexString | null) | undefined;
+            name?: string | undefined;
+            suri?: string | undefined;
+            tags?: string[] | undefined;
+            type?: import("@polkadot/util-crypto/types").KeypairType | undefined;
+            whenCreated?: number | undefined;
+            whenEdited?: number | undefined;
+            whenUsed?: number | undefined;
+            source?: string | undefined;
+            isDefaultAuthSelected?: boolean | undefined;
+            isExternal?: boolean | undefined;
+            isHardware?: boolean | undefined;
+            isHidden?: boolean | undefined;
+            isInjected?: boolean | undefined;
+            isMultisig?: boolean | undefined;
+            isProxied?: boolean | undefined;
+            isRecent?: boolean | undefined;
+            isTesting?: boolean | undefined;
+            accountIndex?: number | undefined;
+            accountOffset?: number | undefined;
+            addressOffset?: number | undefined;
+            hardwareType?: "ledger" | undefined;
+            threshold?: number | undefined;
+            who?: string[] | undefined;
+            parentAddress?: string | undefined;
+            parentName?: string | undefined;
+        };
+        readonly isLocked: boolean;
+        readonly publicKey: {
+            [x: number]: number;
+            readonly BYTES_PER_ELEMENT: number;
+            readonly buffer: {
+                readonly byteLength: number;
+                slice: (begin?: number, end?: number) => ArrayBuffer;
+                readonly maxByteLength: number;
+                readonly resizable: boolean;
+                resize: (newByteLength?: number) => void;
+                readonly detached: boolean;
+                transfer: (newByteLength?: number) => ArrayBuffer;
+                transferToFixedLength: (newByteLength?: number) => ArrayBuffer;
+                readonly [Symbol.toStringTag]: "ArrayBuffer";
+            } | {
+                readonly byteLength: number;
+                slice: (begin?: number, end?: number) => SharedArrayBuffer;
+                readonly growable: boolean;
+                readonly maxByteLength: number;
+                grow: (newByteLength?: number) => void;
+                readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+            };
+            readonly byteLength: number;
+            readonly byteOffset: number;
+            copyWithin: (target: number, start: number, end?: number) => Uint8Array<ArrayBufferLike>;
+            every: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
+            fill: (value: number, start?: number, end?: number) => Uint8Array<ArrayBufferLike>;
+            filter: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => any, thisArg?: any) => Uint8Array<ArrayBuffer>;
+            find: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number | undefined;
+            findIndex: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number;
+            forEach: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => void, thisArg?: any) => void;
+            indexOf: (searchElement: number, fromIndex?: number) => number;
+            join: (separator?: string) => string;
+            lastIndexOf: (searchElement: number, fromIndex?: number) => number;
+            readonly length: number;
+            map: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => number, thisArg?: any) => Uint8Array<ArrayBuffer>;
+            reduce: {
+                (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
+                (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
+                <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
+            };
+            reduceRight: {
+                (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
+                (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
+                <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
+            };
+            reverse: () => Uint8Array<ArrayBufferLike>;
+            set: (array: ArrayLike<number>, offset?: number) => void;
+            slice: (start?: number, end?: number) => Uint8Array<ArrayBuffer>;
+            some: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
+            sort: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBufferLike>;
+            subarray: (begin?: number, end?: number) => Uint8Array<ArrayBufferLike>;
+            toLocaleString: {
+                (): string;
+                (locales: string | string[], options?: Intl.NumberFormatOptions): string;
+            };
+            toString: () => string;
+            valueOf: () => Uint8Array<ArrayBufferLike>;
+            entries: () => ArrayIterator<[number, number]>;
+            keys: () => ArrayIterator<number>;
+            values: () => ArrayIterator<number>;
+            includes: (searchElement: number, fromIndex?: number) => boolean;
+            at: (index: number) => number | undefined;
+            findLast: {
+                <S extends number>(predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => value is S, thisArg?: any): S | undefined;
+                (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any): number | undefined;
+            };
+            findLastIndex: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => number;
+            toReversed: () => Uint8Array<ArrayBuffer>;
+            toSorted: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBuffer>;
+            with: (index: number, value: number) => Uint8Array<ArrayBuffer>;
+            [Symbol.iterator]: () => ArrayIterator<number>;
+            readonly [Symbol.toStringTag]: "Uint8Array";
+        };
+        readonly type: import("@polkadot/util-crypto/types").KeypairType;
+        decodePkcs8: (passphrase?: string, encoded?: Uint8Array) => void;
+        derive: (suri: string, meta?: import("@polkadot/keyring/types").KeyringPair$Meta) => KeyringPair;
+        encodePkcs8: (passphrase?: string) => Uint8Array;
+        lock: () => void;
+        setMeta: (meta: import("@polkadot/keyring/types").KeyringPair$Meta) => void;
+        sign: (message: string | Uint8Array, options?: import("@polkadot/keyring/types").SignOptions) => Uint8Array;
+        toJson: (passphrase?: string) => import("@polkadot/keyring/types").KeyringPair$Json;
+        unlock: (passphrase?: string) => void;
+        verify: (message: string | Uint8Array, signature: Uint8Array, signerPublic: string | Uint8Array) => boolean;
+        vrfSign: (message: string | Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array) => Uint8Array;
+        vrfVerify: (message: string | Uint8Array, vrfResult: Uint8Array, signerPublic: string | Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array) => boolean;
+    } | null, KeyringPair | {
+        readonly address: string;
+        readonly addressRaw: {
+            [x: number]: number;
+            readonly BYTES_PER_ELEMENT: number;
+            readonly buffer: {
+                readonly byteLength: number;
+                slice: (begin?: number, end?: number) => ArrayBuffer;
+                readonly maxByteLength: number;
+                readonly resizable: boolean;
+                resize: (newByteLength?: number) => void;
+                readonly detached: boolean;
+                transfer: (newByteLength?: number) => ArrayBuffer;
+                transferToFixedLength: (newByteLength?: number) => ArrayBuffer;
+                readonly [Symbol.toStringTag]: "ArrayBuffer";
+            } | {
+                readonly byteLength: number;
+                slice: (begin?: number, end?: number) => SharedArrayBuffer;
+                readonly growable: boolean;
+                readonly maxByteLength: number;
+                grow: (newByteLength?: number) => void;
+                readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+            };
+            readonly byteLength: number;
+            readonly byteOffset: number;
+            copyWithin: (target: number, start: number, end?: number) => Uint8Array<ArrayBufferLike>;
+            every: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
+            fill: (value: number, start?: number, end?: number) => Uint8Array<ArrayBufferLike>;
+            filter: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => any, thisArg?: any) => Uint8Array<ArrayBuffer>;
+            find: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number | undefined;
+            findIndex: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number;
+            forEach: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => void, thisArg?: any) => void;
+            indexOf: (searchElement: number, fromIndex?: number) => number;
+            join: (separator?: string) => string;
+            lastIndexOf: (searchElement: number, fromIndex?: number) => number;
+            readonly length: number;
+            map: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => number, thisArg?: any) => Uint8Array<ArrayBuffer>;
+            reduce: {
+                (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
+                (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
+                <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
+            };
+            reduceRight: {
+                (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
+                (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
+                <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
+            };
+            reverse: () => Uint8Array<ArrayBufferLike>;
+            set: (array: ArrayLike<number>, offset?: number) => void;
+            slice: (start?: number, end?: number) => Uint8Array<ArrayBuffer>;
+            some: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
+            sort: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBufferLike>;
+            subarray: (begin?: number, end?: number) => Uint8Array<ArrayBufferLike>;
+            toLocaleString: {
+                (): string;
+                (locales: string | string[], options?: Intl.NumberFormatOptions): string;
+            };
+            toString: () => string;
+            valueOf: () => Uint8Array<ArrayBufferLike>;
+            entries: () => ArrayIterator<[number, number]>;
+            keys: () => ArrayIterator<number>;
+            values: () => ArrayIterator<number>;
+            includes: (searchElement: number, fromIndex?: number) => boolean;
+            at: (index: number) => number | undefined;
+            findLast: {
+                <S extends number>(predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => value is S, thisArg?: any): S | undefined;
+                (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any): number | undefined;
+            };
+            findLastIndex: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => number;
+            toReversed: () => Uint8Array<ArrayBuffer>;
+            toSorted: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBuffer>;
+            with: (index: number, value: number) => Uint8Array<ArrayBuffer>;
+            [Symbol.iterator]: () => ArrayIterator<number>;
+            readonly [Symbol.toStringTag]: "Uint8Array";
+        };
+        readonly meta: {
+            [x: string]: unknown;
+            address?: string | undefined;
+            contract?: {
+                abi: string;
+                genesisHash?: (import("@polkadot/util/types").HexString | null) | undefined;
+            } | undefined;
+            genesisHash?: (import("@polkadot/util/types").HexString | null) | undefined;
+            name?: string | undefined;
+            suri?: string | undefined;
+            tags?: string[] | undefined;
+            type?: import("@polkadot/util-crypto/types").KeypairType | undefined;
+            whenCreated?: number | undefined;
+            whenEdited?: number | undefined;
+            whenUsed?: number | undefined;
+            source?: string | undefined;
+            isDefaultAuthSelected?: boolean | undefined;
+            isExternal?: boolean | undefined;
+            isHardware?: boolean | undefined;
+            isHidden?: boolean | undefined;
+            isInjected?: boolean | undefined;
+            isMultisig?: boolean | undefined;
+            isProxied?: boolean | undefined;
+            isRecent?: boolean | undefined;
+            isTesting?: boolean | undefined;
+            accountIndex?: number | undefined;
+            accountOffset?: number | undefined;
+            addressOffset?: number | undefined;
+            hardwareType?: "ledger" | undefined;
+            threshold?: number | undefined;
+            who?: string[] | undefined;
+            parentAddress?: string | undefined;
+            parentName?: string | undefined;
+        };
+        readonly isLocked: boolean;
+        readonly publicKey: {
+            [x: number]: number;
+            readonly BYTES_PER_ELEMENT: number;
+            readonly buffer: {
+                readonly byteLength: number;
+                slice: (begin?: number, end?: number) => ArrayBuffer;
+                readonly maxByteLength: number;
+                readonly resizable: boolean;
+                resize: (newByteLength?: number) => void;
+                readonly detached: boolean;
+                transfer: (newByteLength?: number) => ArrayBuffer;
+                transferToFixedLength: (newByteLength?: number) => ArrayBuffer;
+                readonly [Symbol.toStringTag]: "ArrayBuffer";
+            } | {
+                readonly byteLength: number;
+                slice: (begin?: number, end?: number) => SharedArrayBuffer;
+                readonly growable: boolean;
+                readonly maxByteLength: number;
+                grow: (newByteLength?: number) => void;
+                readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+            };
+            readonly byteLength: number;
+            readonly byteOffset: number;
+            copyWithin: (target: number, start: number, end?: number) => Uint8Array<ArrayBufferLike>;
+            every: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
+            fill: (value: number, start?: number, end?: number) => Uint8Array<ArrayBufferLike>;
+            filter: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => any, thisArg?: any) => Uint8Array<ArrayBuffer>;
+            find: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number | undefined;
+            findIndex: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number;
+            forEach: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => void, thisArg?: any) => void;
+            indexOf: (searchElement: number, fromIndex?: number) => number;
+            join: (separator?: string) => string;
+            lastIndexOf: (searchElement: number, fromIndex?: number) => number;
+            readonly length: number;
+            map: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => number, thisArg?: any) => Uint8Array<ArrayBuffer>;
+            reduce: {
+                (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
+                (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
+                <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
+            };
+            reduceRight: {
+                (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
+                (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
+                <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
+            };
+            reverse: () => Uint8Array<ArrayBufferLike>;
+            set: (array: ArrayLike<number>, offset?: number) => void;
+            slice: (start?: number, end?: number) => Uint8Array<ArrayBuffer>;
+            some: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
+            sort: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBufferLike>;
+            subarray: (begin?: number, end?: number) => Uint8Array<ArrayBufferLike>;
+            toLocaleString: {
+                (): string;
+                (locales: string | string[], options?: Intl.NumberFormatOptions): string;
+            };
+            toString: () => string;
+            valueOf: () => Uint8Array<ArrayBufferLike>;
+            entries: () => ArrayIterator<[number, number]>;
+            keys: () => ArrayIterator<number>;
+            values: () => ArrayIterator<number>;
+            includes: (searchElement: number, fromIndex?: number) => boolean;
+            at: (index: number) => number | undefined;
+            findLast: {
+                <S extends number>(predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => value is S, thisArg?: any): S | undefined;
+                (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any): number | undefined;
+            };
+            findLastIndex: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => number;
+            toReversed: () => Uint8Array<ArrayBuffer>;
+            toSorted: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBuffer>;
+            with: (index: number, value: number) => Uint8Array<ArrayBuffer>;
+            [Symbol.iterator]: () => ArrayIterator<number>;
+            readonly [Symbol.toStringTag]: "Uint8Array";
+        };
+        readonly type: import("@polkadot/util-crypto/types").KeypairType;
+        decodePkcs8: (passphrase?: string, encoded?: Uint8Array) => void;
+        derive: (suri: string, meta?: import("@polkadot/keyring/types").KeyringPair$Meta) => KeyringPair;
+        encodePkcs8: (passphrase?: string) => Uint8Array;
+        lock: () => void;
+        setMeta: (meta: import("@polkadot/keyring/types").KeyringPair$Meta) => void;
+        sign: (message: string | Uint8Array, options?: import("@polkadot/keyring/types").SignOptions) => Uint8Array;
+        toJson: (passphrase?: string) => import("@polkadot/keyring/types").KeyringPair$Json;
+        unlock: (passphrase?: string) => void;
+        verify: (message: string | Uint8Array, signature: Uint8Array, signerPublic: string | Uint8Array) => boolean;
+        vrfSign: (message: string | Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array) => Uint8Array;
+        vrfVerify: (message: string | Uint8Array, vrfResult: Uint8Array, signerPublic: string | Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array) => boolean;
+    } | null>;
+    setSender: (senderPair: KeyringPair, { signer, subscription }?: AccountOptions) => void;
+    setSubscription: (subscription?: string) => void;
+};

package/dist/account/useAccount.js

@@ -1,70 +1,61 @@
-import { ref } from 'vue';
-import { usePolkadotApi } from '../usePolkadotApi.js';
-
-/** @type {import('vue').Ref<string|null>} Current account address */
+import { ref } from "vue";
+import { usePolkadotApi } from "../usePolkadotApi.js";
+/** @description Current account address */
 const account = ref(null);
-/** @type {import('vue').Ref|null} Current account key pair */
-let pair = ref(null);
-
-/**
- * @typedef {Object} AccountComposable
- * @property {import('vue').Ref<string|null>} account - Current account address
- * @property {import('vue').Ref|null} pair - Current account key pair
- * @property {Function} setSender - Function for setting sender
- * @property {Function} setSubscription - Function for setting subscription
- */
+/** @description Current account key pair */
+const pair = ref(null);
 /**
  * Vue сomposable for account management
  * @description Provides functionality for setting transaction sender and subscription
- * @returns {AccountComposable} Object with methods and properties for working with account
+ * @returns Object with methods and properties for working with account
  * @example
  * const { account, pair, setSender, setSubscription } = useAccount()
  *
- * setSender(keypair, { subscription: 'sub', signer: 'sr25519' })
+ * setSender(keypair, { subscription: 'subscription_id', signer: {
+ *    signPayload?: (payload: SignerPayloadJSON) => Promise<SignerResult>;
+ *    signRaw?: (raw: SignerPayloadRaw) => Promise<SignerResult>;
+ *    update?: (id: number, status: ISubmittableResult | H256) => void;
+ *  }
+ * })
  * setSubscription('subscription_id')
  */
-const useAccount = () => {
-  const { isConnected, instance } = usePolkadotApi();
-
-  /**
-   * Sets transaction sender
-   * @description Sets key pair and subscription for sending transactions
-   * @param {Object} senderPair - Sender key pair
-   * @param {Object} options - Options for setting
-   * @param {string} options.subscription - Subscription ID
-   * @param {string} options.signer - Signing type (e.g., 'sr25519')
-   * @throws {Error} Throws error if not connected to network
-   * @example
-   * setSender(keypair, { subscription: 'sub_id', signer: 'sr25519' })
-   */
-  const setSender = (senderPair, { subscription, signer }) => {
-    if (!isConnected.value) {
-      throw new Error("Not connected");
-    }
-    instance.account.setSender(senderPair, {
-      signer,
-      subscription
-    });
-    account.value = senderPair.address;
-    pair.value = senderPair;
-  };
-
-  /**
-   * Sets subscription for account
-   * @description Sets subscription for working with account
-   * @param {string} subscription - Subscription ID
-   * @throws {Error} Throws error if not connected to network
-   * @example
-   * setSubscription('subscription_id')
-   */
-  const setSubscription = (subscription) => {
-    if (!isConnected.value) {
-      throw new Error("Not connected");
-    }
-    instance.account.useSubscription(subscription);
-  };
-
-  return { account, pair, setSender, setSubscription };
+export const useAccount = () => {
+    const { isConnected, instance } = usePolkadotApi();
+    /**
+     * Sets transaction sender
+     * @description Sets key pair and subscription for sending transactions
+     * @param senderPair - Sender key pair
+     * @param options - Options for setting
+     * @param [options.subscription] - Subscription ID
+     * @param [options.signer] - Signer object, undefined to use default
+     * @throws {Error} Throws error if not connected to network
+     * @example
+     * setSender(keypair, { subscription: 'subscription_id', signer: keypair })
+     */
+    const setSender = (senderPair, { signer, subscription } = {}) => {
+        if (!isConnected.value || !instance || !instance.account) {
+            throw new Error("Not connected");
+        }
+        instance.account.setSender(senderPair, {
+            signer,
+            subscription
+        });
+        account.value = senderPair.address;
+        pair.value = senderPair;
+    };
+    /**
+     * Sets subscription for account
+     * @description Sets subscription for working with account
+     * @param subscription - Subscription ID
+     * @throws {Error} Throws error if not connected to network
+     * @example
+     * setSubscription('subscription_id')
+     */
+    const setSubscription = (subscription) => {
+        if (!isConnected.value || !instance || !instance.account) {
+            throw new Error("Not connected");
+        }
+        instance.account.useSubscription(subscription);
+    };
+    return { account, pair, setSender, setSubscription };
 };
-
-export { useAccount };