@dfns/lib-vechain 0.7.11 → 0.7.13

package/index.d.ts

@@ -1,19 +1,20 @@
 import { DfnsApiClient } from '@dfns/sdk';
-import { Wallet } from '@vechain/connex-driver';
+import { type AvailableVeChainProviders, type TransactionRequestInput, VeChainAbstractSigner } from '@vechain/sdk-network';
 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;
 };
-export declare class DfnsWallet implements Wallet {
-    private metadata;
+export declare class DfnsWallet extends VeChainAbstractSigner {
+    private ad;
     readonly address: string;
     private readonly dfnsClient;
+    readonly walletId: string;
     private constructor();
-    static init(options: DfnsWalletOptions): Promise<DfnsWallet>;
+    static init(options: DfnsWalletOptions, provider?: AvailableVeChainProviders): Promise<DfnsWallet>;
     private sign;
-    get list(): Wallet.Key[];
+    connect(provider: AvailableVeChainProviders): this;
+    getAddress(): Promise<string>;
+    signTransaction(transactionToSign: TransactionRequestInput): Promise<string>;
+    sendTransaction(transactionToSend: TransactionRequestInput): Promise<string>;
+    signPayload(payload: Uint8Array): Promise<string>;
 }

package/index.js

@@ -2,8 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DfnsWallet = void 0;
 const sdk_1 = require("@dfns/sdk");
+const sdk_network_1 = require("@vechain/sdk-network");
+const sdk_core_1 = require("@vechain/sdk-core");
 const elliptic_1 = require("elliptic");
-const thor_devkit_1 = require("thor-devkit");
 const assertSigned = (res) => {
     if (res.status === 'Failed') {
         throw new sdk_1.DfnsError(-1, 'signing failed', res);
@@ -12,14 +13,15 @@ const assertSigned = (res) => {
         throw new sdk_1.DfnsError(-1, 'cannot complete signing synchronously because this wallet action requires policy approval', res);
     }
 };
-class DfnsWallet {
-    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) {
+class DfnsWallet extends sdk_network_1.VeChainAbstractSigner {
+    constructor(ad, client, walletId, provider) {
+        super(provider);
+        this.ad = ad;
+        this.dfnsClient = client;
+        this.address = ad;
+        this.walletId = walletId;
+    }
+    static async init(options, provider) {
         const { walletId, dfnsClient } = options;
         const res = await dfnsClient.wallets.getWallet({ walletId });
         if (res.status !== 'Active') {
@@ -32,11 +34,13 @@ class DfnsWallet {
         if (curve !== 'secp256k1') {
             throw new sdk_1.DfnsError(-1, 'key curve is not secp256k1', { walletId, curve });
         }
-        return new DfnsWallet(res, options);
+        const publicKey = new elliptic_1.ec('secp256k1').keyFromPublic(res.signingKey.publicKey, 'hex');
+        const ad = sdk_core_1.Address.ofPublicKey(Buffer.from(publicKey.getPublic(false, 'array'))).toString();
+        return new DfnsWallet(ad, dfnsClient, walletId, provider);
     }
     async sign(msgHash) {
         const res = await this.dfnsClient.wallets.generateSignature({
-            walletId: this.metadata.id,
+            walletId: this.walletId,
             body: { kind: 'Hash', hash: msgHash.toString('hex') },
         });
         assertSigned(res);
@@ -49,13 +53,32 @@ class DfnsWallet {
             Buffer.from([res.signature.recid]),
         ]);
     }
-    get list() {
-        return [
-            {
-                address: this.address,
-                sign: (msgHash) => this.sign(msgHash),
-            },
-        ];
+    connect(provider) {
+        return new DfnsWallet(this.address, this.dfnsClient, this.walletId, provider);
+    }
+    async getAddress() {
+        return Promise.resolve(this.address);
+    }
+    async signTransaction(transactionToSign) {
+        const transactionBody = await this.populateTransaction(transactionToSign);
+        // Get the transaction object
+        const transaction = sdk_core_1.Transaction.of(transactionBody);
+        const transactionHash = transaction.getTransactionHash().bytes;
+        const signature = await this.sign(Buffer.from(transactionHash));
+        return sdk_core_1.Hex.of(signature).toString();
+    }
+    async sendTransaction(transactionToSend) {
+        const signedTransaction = await this.signTransaction(transactionToSend);
+        return this.provider?.request({
+            method: sdk_network_1.RPC_METHODS.eth_sendRawTransaction,
+            params: [sdk_core_1.Hex.of(signedTransaction).toString()],
+        });
+    }
+    async signPayload(payload) {
+        const signature = await this.sign(Buffer.from(payload));
+        // SCP256K1 encodes the recovery flag in the last byte. EIP-191 adds 27 to it.
+        signature[signature.length - 1] += 27;
+        return sdk_core_1.Hex.of(signature).toString();
     }
 }
 exports.DfnsWallet = DfnsWallet;

package/package.json

@@ -1,15 +1,12 @@
 {
   "name": "@dfns/lib-vechain",
-  "version": "0.7.11",
+  "version": "0.7.13",
   "peerDependencies": {
-    "@vechain/connex-driver": "2.0.12",
-    "thor-devkit": "2.0.8",
-    "@dfns/sdk": "0.7.11"
+    "@vechain/sdk-core": "^2.0.5",
+    "@vechain/sdk-network": "^2.0.5"
   },
   "dependencies": {
-    "buffer": "6.0.3",
-    "cross-fetch": "3.1.6",
-    "elliptic": "6.6.1"
+    "elliptic": "^6.6.1"
   },
   "main": "./index.js",
   "type": "commonjs"