@dfns/lib-aptos 0.6.1

package/index.d.ts

@@ -0,0 +1,19 @@
+import { DfnsApiClient } from '@dfns/sdk';
+import { AnyRawTransaction, RawTransaction, SignedTransaction } from '@aptos-labs/ts-sdk';
+export declare const hexToBuffer: (hex: string) => Buffer;
+export type DfnsWalletOptions = {
+    walletId: string;
+    dfnsClient: DfnsApiClient;
+};
+export declare class DfnsWallet {
+    private metadata;
+    private readonly dfnsClient;
+    private constructor();
+    static init(options: DfnsWalletOptions): Promise<DfnsWallet>;
+    get address(): string;
+    get publicKey(): string;
+    signTransaction(transaction: RawTransaction | SignedTransaction | AnyRawTransaction): Promise<SignedTransaction>;
+    private prepareTransaction;
+    private prepareSimpleTransaction;
+    private prepareMultiAgentTransaction;
+}

package/index.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DfnsWallet = exports.hexToBuffer = void 0;
+const sdk_1 = require("@dfns/sdk");
+const ts_sdk_1 = require("@aptos-labs/ts-sdk");
+const hexToBuffer = (hex) => {
+    return Buffer.from(stripHexPrefix(hex), 'hex');
+};
+exports.hexToBuffer = hexToBuffer;
+const stripHexPrefix = (hex) => {
+    return hex.replace(/^0x/, '');
+};
+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(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.status !== 'Active') {
+            throw new sdk_1.DfnsError(-1, 'wallet not active', { walletId, status: res.status });
+        }
+        if (res.network !== 'Aptos' && res.network !== 'AptosTestnet') {
+            throw new sdk_1.DfnsError(-1, 'wallet is not bound to Aptos or AptosTestnet', { walletId, network: res.network });
+        }
+        return new DfnsWallet(res, options);
+    }
+    get address() {
+        return this.metadata.address;
+    }
+    get publicKey() {
+        return this.metadata.signingKey.publicKey;
+    }
+    // DFNS can sign:
+    //   - RawTransaction directly for simple transaction
+    //   - AnyRawTransaction
+    //   - SignedTransaction for transactions containing additional signers or fee payer (need to provide the
+    //     right transaction authenticator)
+    async signTransaction(transaction) {
+        transaction = this.prepareTransaction(transaction);
+        const res = await this.dfnsClient.wallets.generateSignature({
+            walletId: this.metadata.id,
+            body: {
+                kind: 'Transaction',
+                transaction: transaction.bcsToHex().toString(),
+            },
+        });
+        assertSigned(res);
+        if (!res.signedData) {
+            throw new sdk_1.DfnsError(-1, 'encoded signature missing', res);
+        }
+        const deserializer = new ts_sdk_1.Deserializer((0, exports.hexToBuffer)(res.signedData));
+        return ts_sdk_1.SignedTransaction.deserialize(deserializer);
+    }
+    prepareTransaction(transaction) {
+        if (isSimpleTransaction(transaction)) {
+            return this.prepareSimpleTransaction(transaction);
+        }
+        if (isMultiAgentTransaction(transaction)) {
+            return this.prepareMultiAgentTransaction(transaction);
+        }
+        // If already a SignedTransaction or RawTransaction, return as is
+        return transaction;
+    }
+    prepareSimpleTransaction(transaction) {
+        if (transaction.feePayerAddress) {
+            return new ts_sdk_1.SignedTransaction(transaction.rawTransaction, new ts_sdk_1.TransactionAuthenticatorFeePayer(new ts_sdk_1.AccountAuthenticatorNoAccountAuthenticator(), [], [], {
+                address: transaction.feePayerAddress,
+                authenticator: new ts_sdk_1.AccountAuthenticatorNoAccountAuthenticator(),
+            }));
+        }
+        return transaction.rawTransaction; // If no fee payer, use the raw transaction directly
+    }
+    prepareMultiAgentTransaction(transaction) {
+        if (transaction.feePayerAddress) {
+            return new ts_sdk_1.SignedTransaction(transaction.rawTransaction, new ts_sdk_1.TransactionAuthenticatorFeePayer(new ts_sdk_1.AccountAuthenticatorNoAccountAuthenticator(), transaction.secondarySignerAddresses, [], {
+                address: transaction.feePayerAddress,
+                authenticator: new ts_sdk_1.AccountAuthenticatorNoAccountAuthenticator(),
+            }));
+        }
+        return new ts_sdk_1.SignedTransaction(transaction.rawTransaction, new ts_sdk_1.TransactionAuthenticatorMultiAgent(new ts_sdk_1.AccountAuthenticatorNoAccountAuthenticator(), transaction.secondarySignerAddresses, []));
+    }
+}
+exports.DfnsWallet = DfnsWallet;
+const isSimpleTransaction = (transaction) => {
+    return transaction instanceof ts_sdk_1.SimpleTransaction;
+};
+const isMultiAgentTransaction = (transaction) => {
+    return transaction instanceof ts_sdk_1.MultiAgentTransaction;
+};

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@dfns/lib-aptos",
+  "version": "0.6.1",
+  "peerDependencies": {
+    "@aptos-labs/ts-sdk": "1.33.0",
+    "@dfns/sdk": "0.6.1"
+  },
+  "dependencies": {
+    "buffer": "6.0.3",
+    "cross-fetch": "3.1.6",
+    "uuid": "9.0.0"
+  },
+  "main": "./index.js",
+  "type": "commonjs"
+}