@dfns/lib-vechain 0.1.2 → 0.1.3-rc.2

package/index.d.ts

@@ -1,18 +1,22 @@
-/// <reference types="node" />
 import { DfnsApiClient } from '@dfns/sdk';
+import { GetWalletResponse } from '@dfns/sdk/types/wallets';
 import { Wallet } from '@vechain/connex-driver';
 export type DfnsWalletOptions = {
     walletId: string;
     dfnsClient: DfnsApiClient;
+    /** @deprecated transaction signing is now synchronous. polling is deprecated. */
     maxRetries?: number;
+    /** @deprecated transaction signing is now synchronous. polling is deprecated. */
     retryInterval?: number;
 };
+type WalletMetadata = GetWalletResponse;
 export declare class DfnsWallet implements Wallet {
+    private metadata;
     readonly address: string;
-    private options;
-    private constructor();
+    private readonly dfnsClient;
+    constructor(metadata: WalletMetadata, options: DfnsWalletOptions);
     static init(options: DfnsWalletOptions): Promise<DfnsWallet>;
-    waitForSignature(signatureId: string): Promise<Buffer>;
     private sign;
     get list(): Wallet.Key[];
 }
+export {};

package/index.js

@@ -1,59 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DfnsWallet = void 0;
-const Wallets_1 = require("@dfns/sdk/codegen/datamodel/Wallets");
+const sdk_1 = require("@dfns/sdk");
 const elliptic_1 = require("elliptic");
 const thor_devkit_1 = require("thor-devkit");
-const sleep = (interval = 0) => new Promise((resolve) => setTimeout(resolve, interval));
+const assertSigned = (res) => {
+    if (res.status === 'Failed') {
+        throw new sdk_1.DfnsError(-1, 'signing failed', res);
+    }
+    else if (res.status !== 'Signed') {
+        throw new sdk_1.DfnsError(-1, 'cannot complete signing synchronously because this wallet action requires policy approval', res);
+    }
+};
 class DfnsWallet {
-    constructor(address, options) {
-        this.address = address;
-        this.options = {
-            ...options,
-            maxRetries: options.maxRetries ?? 3,
-            retryInterval: options.retryInterval ?? 1000,
-        };
+    constructor(metadata, options) {
+        this.metadata = metadata;
+        this.dfnsClient = options.dfnsClient;
+        const publicKey = new elliptic_1.ec('secp256k1').keyFromPublic(metadata.signingKey.publicKey, 'hex');
+        this.address = thor_devkit_1.address.fromPublicKey(Buffer.from(publicKey.getPublic(false, 'array')));
     }
     static async init(options) {
         const { walletId, dfnsClient } = options;
         const res = await dfnsClient.wallets.getWallet({ walletId });
-        if (res.network !== Wallets_1.BlockchainNetwork.KeyECDSA || !res.signingKey) {
-            throw new Error(`wallet ${walletId} is incompatible`);
+        if (res.status !== 'Active') {
+            throw new sdk_1.DfnsError(-1, 'wallet not active', { walletId, status: res.status });
         }
-        const publicKey = new elliptic_1.ec('secp256k1').keyFromPublic(res.signingKey.publicKey, 'hex');
-        const addr = thor_devkit_1.address.fromPublicKey(Buffer.from(publicKey.getPublic(false, 'array')));
-        return new DfnsWallet(addr, options);
-    }
-    async waitForSignature(signatureId) {
-        const { walletId, dfnsClient, retryInterval } = this.options;
-        let maxRetries = this.options.maxRetries;
-        while (maxRetries > 0) {
-            await sleep(retryInterval);
-            const res = await dfnsClient.wallets.getSignature({ walletId, signatureId });
-            if (res.status === Wallets_1.SignatureStatus.Signed) {
-                if (!res.signature)
-                    break;
-                return Buffer.concat([
-                    Buffer.from(res.signature.r.substring(2), 'hex'),
-                    Buffer.from(res.signature.s.substring(2), 'hex'),
-                    Buffer.from([res.signature.recid]),
-                ]);
-            }
-            else if (res.status === Wallets_1.SignatureStatus.Failed) {
-                break;
-            }
-            maxRetries -= 1;
+        const { scheme, curve } = res.signingKey;
+        if (scheme !== 'ECDSA') {
+            throw new sdk_1.DfnsError(-1, 'key scheme is not ECDSA', { walletId, scheme });
         }
-        const waitedSeconds = Math.floor((this.options.maxRetries * retryInterval) / 1000);
-        throw new Error(`Signature request ${signatureId} took more than ${waitedSeconds}s to complete, stopping polling. Please update options "maxRetries" or "retryIntervals" to wait longer.`);
+        if (curve !== 'secp256k1') {
+            throw new sdk_1.DfnsError(-1, 'key curve is not secp256k1', { walletId, curve });
+        }
+        return new DfnsWallet(res, options);
     }
     async sign(msgHash) {
-        const { walletId, dfnsClient } = this.options;
-        const res = await dfnsClient.wallets.generateSignature({
-            walletId,
-            body: { kind: Wallets_1.SignatureKind.Hash, hash: msgHash.toString('hex') },
+        const res = await this.dfnsClient.wallets.generateSignature({
+            walletId: this.metadata.id,
+            body: { kind: 'Hash', hash: msgHash.toString('hex') },
         });
-        return this.waitForSignature(res.id);
+        assertSigned(res);
+        if (!res.signature) {
+            throw new sdk_1.DfnsError(-1, 'signature missing', res);
+        }
+        return Buffer.concat([
+            Buffer.from(res.signature.r.replace(/^0x/, ''), 'hex'),
+            Buffer.from(res.signature.s.replace(/^0x/, ''), 'hex'),
+            Buffer.from([res.signature.recid]),
+        ]);
     }
     get list() {
         return [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dfns/lib-vechain",
-  "version": "0.1.2",
+  "version": "0.1.3-rc.2",
   "dependencies": {
     "@vechain/connex-driver": "2.0.12",
     "buffer": "6.0.3",
@@ -10,7 +10,7 @@
     "uuid": "9.0.0"
   },
   "peerDependencies": {
-    "@dfns/sdk": "0.1.2"
+    "@dfns/sdk": "0.1.3-rc.2"
   },
   "main": "./index.js",
   "type": "commonjs"