@dfns/lib-tron 0.1.2-rc.5 → 0.1.3-rc.1

package/index.d.ts

@@ -3,16 +3,13 @@ import { SignedTransaction, Transaction } from '@tronweb3/tronwallet-abstract-ad
 export type DfnsWalletOptions = {
     walletId: string;
     dfnsClient: DfnsApiClient;
-    maxRetries?: number;
-    retryInterval?: number;
 };
 export declare class DfnsWallet {
-    private options;
-    private tronAddress;
+    private metadata;
+    private readonly dfnsClient;
     private constructor();
     static init(options: DfnsWalletOptions): Promise<DfnsWallet>;
     get address(): string;
-    waitForSignature(signatureId: string): Promise<string>;
     signTransaction(transaction: Transaction): Promise<SignedTransaction>;
     signMessage(message: string): Promise<string>;
 }

package/index.js

@@ -1,100 +1,72 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DfnsWallet = void 0;
-const Wallets_1 = require("@dfns/sdk/codegen/datamodel/Wallets");
-const elliptic = __importStar(require("elliptic"));
+const sdk_1 = require("@dfns/sdk");
 const TronWeb = require('tronweb');
-const sleep = (interval = 0) => new Promise((resolve) => setTimeout(resolve, interval));
+const bytes = TronWeb.utils.bytes;
+const ethersUtils = TronWeb.utils.ethersUtils;
+const txUtils = TronWeb.utils.transaction;
+const bufferToHex = (buffer) => {
+    return `0x${bytes.byteArray2hexStr(buffer).toLowerCase()}`;
+};
+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(options, tronAddress) {
-        this.options = {
-            ...options,
-            maxRetries: options.maxRetries ?? 3,
-            retryInterval: options.retryInterval ?? 1000,
-        };
-        this.tronAddress = tronAddress;
+    constructor(metadata, options) {
+        this.metadata = metadata;
+        this.dfnsClient = options.dfnsClient;
     }
     static async init(options) {
         const { walletId, dfnsClient } = options;
         const res = await dfnsClient.wallets.getWallet({ walletId });
-        if (!res.signingKey || res.signingKey.scheme !== Wallets_1.KeyScheme.ECDSA || res.signingKey.curve !== Wallets_1.KeyCurve.secp256k1) {
-            throw new Error(`wallet ${walletId} has incompatible scheme (${res.signingKey?.scheme}) or curve (${res.signingKey?.curve})`);
+        if (res.status !== 'Active') {
+            throw new sdk_1.DfnsError(-1, 'wallet not active', { walletId, status: res.status });
+        }
+        if (res.network !== 'Tron' && res.network !== 'TronNile') {
+            throw new sdk_1.DfnsError(-1, 'wallet is not bound to Tron or TronNile', { walletId, network: res.network });
         }
-        // Decompressed the key to derive the address
-        const ec = new elliptic.ec('secp256k1');
-        const keyAsArray = ec.keyFromPublic(res.signingKey.publicKey, 'hex').getPublic(false, 'array');
-        const tronAddress = TronWeb.utils.crypto.getBase58CheckAddress(TronWeb.utils.crypto.computeAddress(keyAsArray));
-        return new DfnsWallet(options, tronAddress);
+        return new DfnsWallet(res, options);
     }
     get address() {
-        return this.tronAddress;
-    }
-    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;
-                const r = res.signature.r.substring(2);
-                const s = res.signature.s.substring(2);
-                const v = (res.signature.recid ? 0x1c : 0x1b).toString(16);
-                return r + s + v;
-            }
-            else if (res.status === Wallets_1.SignatureStatus.Failed) {
-                console.log("signature failed: %s", res);
-                break;
-            }
-            maxRetries -= 1;
-        }
-        throw new Error(`signature ${signatureId} not available`);
+        // Tron-bound wallets will have a tron address
+        return this.metadata.address;
     }
     async signTransaction(transaction) {
-        const { walletId, dfnsClient } = this.options;
-        const res = await dfnsClient.wallets.generateSignature({
-            walletId,
-            body: { kind: Wallets_1.SignatureKind.Hash, hash: transaction.txID },
+        const res = await this.dfnsClient.wallets.generateSignature({
+            walletId: this.metadata.id,
+            body: {
+                kind: 'Transaction',
+                transaction: bufferToHex(txUtils.txJsonToPb(transaction).serializeBinary()),
+            },
         });
-        const signature = await this.waitForSignature(res.id);
-        const signedTransaction = {
+        assertSigned(res);
+        if (!res.signature?.encoded) {
+            throw new sdk_1.DfnsError(-1, 'encoded signature missing', res);
+        }
+        return {
             ...transaction,
-            signature: [signature],
+            signature: [res.signature.encoded.replace(/^0x/, '')],
         };
-        return signedTransaction;
     }
     async signMessage(message) {
-        const { walletId, dfnsClient } = this.options;
-        let messageHash = TronWeb.utils.message.hashMessage(message);
-        const res = await dfnsClient.wallets.generateSignature({
-            walletId,
-            body: { kind: Wallets_1.SignatureKind.Hash, hash: messageHash },
+        const res = await this.dfnsClient.wallets.generateSignature({
+            walletId: this.metadata.id,
+            body: {
+                kind: 'Message',
+                message: bufferToHex(ethersUtils.toUtf8Bytes(message)),
+            },
         });
-        return this.waitForSignature(res.id);
+        assertSigned(res);
+        if (!res.signature?.encoded) {
+            throw new sdk_1.DfnsError(-1, 'encoded signature missing', res);
+        }
+        return res.signature.encoded.replace(/^0x/, '');
     }
 }
 exports.DfnsWallet = DfnsWallet;

package/package.json

@@ -1,16 +1,15 @@
 {
   "name": "@dfns/lib-tron",
-  "version": "0.1.2-rc.5",
+  "version": "0.1.3-rc.1",
   "dependencies": {
-    "@tronweb3/tronwallet-abstract-adapter": "^1.1.5",
+    "@tronweb3/tronwallet-abstract-adapter": "1.1.6",
     "buffer": "6.0.3",
     "cross-fetch": "3.1.6",
-    "elliptic": "6.5.4",
-    "tronweb": "^5.3.0",
+    "tronweb": "5.3.1",
     "uuid": "9.0.0"
   },
   "peerDependencies": {
-    "@dfns/sdk": "0.1.2-rc.5"
+    "@dfns/sdk": "0.1.3-rc.1"
   },
   "main": "./index.js",
   "type": "commonjs"