* allow garbage collection.\r
*/\r
async destroy (): Promise<void> {\r
- await SafeWorker.assign({\r
+ await SafeWorker.request({\r
method: 'destroy',\r
store: 'Account',\r
[this.publicKey]: this.publicKey\r
async sign (block: ChangeBlock | ReceiveBlock | SendBlock, password: Key): Promise<string> {\r
if (typeof password === 'string') password = utf8.toBytes(password)\r
try {\r
- const { signature } = await NanoNaClWorker.
assign<ArrayBuffer>({
\r+ const { signature } = await NanoNaClWorker.
request<ArrayBuffer>({
\r method: 'detached',\r
privateKey: (await this.#export(password)).buffer,\r
msg: hex.toBytes(block.hash).buffer\r
throw new Error('Password must be string or bytes')\r
}\r
try {\r
- const response = await SafeWorker.
assign<ArrayBuffer>({
\r+ const response = await SafeWorker.
request<ArrayBuffer>({
\r method: 'fetch',\r
name: this.publicKey,\r
store: 'Account',\r
this.#validateKey(privateKey)\r
if (typeof privateKey === 'string') privateKey = hex.toBytes(privateKey)\r
try {\r
- const result = await NanoNaClWorker.
assign<ArrayBuffer>({
\r+ const result = await NanoNaClWorker.
request<ArrayBuffer>({
\r method: 'convert',\r
privateKey: new Uint8Array(privateKey).buffer\r
})\r
}\r
\r
try {\r
- const { result } = await SafeWorker.assign(privateAccounts)\r
+ const { result } = await SafeWorker.request(privateAccounts)\r
if (!result) {\r
throw null\r
}\r
throw new Error('Provide a key for block signature verification.')
}
try {
- const { isVerified } = await NanoNaClWorker.assign<boolean>({
+ const { isVerified } = await NanoNaClWorker.request<boolean>({
method: 'verify',
msg: hex.toBytes(this.hash).buffer,
signature: hex.toBytes(this.signature ?? '').buffer,
const existingAddresses = await this.getAddresses(name)
existingAddresses.push(account.address)
data[name] = utf8.toBytes(JSON.stringify(existingAddresses)).buffer
- const { result } = await SafeWorker.assign<boolean>(data)
+ const { result } = await SafeWorker.request<boolean>(data)
return result
} catch (err) {
throw new Error('failed to add address', { cause: err })
return false
}
const addresses = (await this.getAddresses(name)).filter(a => a !== address).sort()
- const { result: isUpdated } = await SafeWorker.assign<boolean>({
+ const { result: isUpdated } = await SafeWorker.request<boolean>({
method: 'store',
store: 'Rolodex',
password: utf8.toBytes('').buffer,
if (!isUpdated) {
throw new Error('failed to remove address from existing name')
}
- const { result } = await SafeWorker.assign<boolean>({
+ const { result } = await SafeWorker.request<boolean>({
method: 'destroy',
store: 'Rolodex',
[address]: address
for (const address of addresses) {
data[address] = address
}
- const { result } = await SafeWorker.assign<boolean>(data)
+ const { result } = await SafeWorker.request<boolean>(data)
return result
}
*/
static async getAddresses (name: string): Promise<string[]> {
try {
- const response = await SafeWorker.
assign<ArrayBuffer>({
+ const response = await SafeWorker.
request<ArrayBuffer>({
method: 'fetch',
name,
store: 'Rolodex',
*/
static async getAllNames (): Promise<string[]> {
try {
- const response = await SafeWorker.
assign<ArrayBuffer>({
+ const response = await SafeWorker.
request<ArrayBuffer>({
method: 'export',
name: '',
store: 'Rolodex',
*/
static async getName (address: string): Promise<string | null> {
try {
- const response = await SafeWorker.
assign<ArrayBuffer>({
+ const response = await SafeWorker.
request<ArrayBuffer>({
method: 'fetch',
name: address,
store: 'Rolodex',
export async function sign (key: Key, ...input: string[]): Promise<string> {
if (typeof key === 'string') key = hex.toBytes(key)
try {
- const { signature } = await NanoNaClWorker.
assign<ArrayBuffer>({
+ const { signature } = await NanoNaClWorker.
request<ArrayBuffer>({
method: 'detached',
privateKey: key.buffer,
msg: hash(input).buffer
export async function verify (key: Key, signature: string, ...input: string[]): Promise<boolean> {
if (typeof key === 'string') key = hex.toBytes(key)
try {
- const { isVerified } = await NanoNaClWorker.assign<boolean>({
+ const { isVerified } = await NanoNaClWorker.request<boolean>({
method: 'verify',
msg: hash(input).buffer,
signature: hex.toBytes(signature).buffer,
if (this.isLocked) {\r
throw new Error('wallet must be unlocked to derive accounts')\r
}\r
- const results = await Bip44CkdWorker.assign({\r
+ const results = await Bip44CkdWorker.request({\r
indexes,\r
seed: hex.toBytes(this.seed).buffer\r
})\r
return bytes.toHex(this.#s)\r
}\r
\r
+ static async export () {\r
+ try {\r
+ const response = await SafeWorker.request<ArrayBuffer>({\r
+ method: 'export',\r
+ name: '',\r
+ store: 'Rolodex',\r
+ password: utf8.toBytes('').buffer\r
+ })\r
+ return Object.keys(response).filter(v => v.slice(0, 5) !== 'nano_')\r
+ } catch (err) {\r
+ console.error(err)\r
+ return []\r
+ }\r
+ }\r
+\r
constructor (id: Entropy, seed?: Uint8Array<ArrayBuffer>, mnemonic?: Bip39Mnemonic) {\r
if (this.constructor === Wallet) {\r
throw new Error('Wallet is an abstract class and cannot be instantiated directly.')\r
bytes.erase(this.#s)\r
this.#m = undefined\r
this.#s = undefined\r
- await SafeWorker.assign<boolean>({\r
+ await SafeWorker.request<boolean>({\r
store: 'Wallet',\r
method: 'destroy',\r
[this.id]: this.id\r
seed: this.#s == null ? this.#s : bytes.toHex(this.#s)\r
})\r
const encoded = utf8.toBytes(serialized)\r
- const success = await SafeWorker.assign({\r
+ const success = await SafeWorker.request({\r
method: 'store',\r
store: 'Wallet',\r
[this.id]: encoded.buffer,\r
if (password == null || !(password instanceof Uint8Array)) {\r
throw new Error('password must be string or bytes')\r
}\r
- const response = await SafeWorker.
assign<ArrayBuffer>({
\r+ const response = await SafeWorker.
request<ArrayBuffer>({
\r method: 'fetch',\r
name: this.id,\r
store: 'Wallet',\r
WorkerQueue.#instances.push(this)
}
- async assign<T extends Data> (data: NamedData): Promise<NamedData<T>> {
- return this.#assign<T>(data, task => this.#queue.push(task))
- }
-
async prioritize<T extends Data> (data: NamedData): Promise<NamedData<T>> {
return this.#assign<T>(data, task => this.#queue.unshift(task))
}
+ async request<T extends Data> (data: NamedData): Promise<NamedData<T>> {
+ return this.#assign<T>(data, task => this.#queue.push(task))
+ }
+
terminate (): void {
this.#job = undefined
this.#worker.terminate()
projects / libnemo.git / commitdiff