Merge pull request #2062 from aeternity/unsafe-sign

davidyuk · web-flow · commit e49753f2cd69 · 2025-04-14T09:36:20.000+02:00
fix(account): add `unsafeSign`, deprecate `sign`
diff --git a/.eslintrc.cjs b/.eslintrc.cjs
@@ -20,6 +20,7 @@ module.exports = {
     'es',
     'src/apis',
     'docs/api',
+    'test/assets',
     'test/environment/ledger/browser',
     'docs/examples',
     'site',
diff --git a/examples/browser/aepp/src/components/DataSign.vue b/examples/browser/aepp/src/components/DataSign.vue
@@ -72,7 +72,7 @@ export default {
       this.data = encode(Buffer.from(data, type), Encoding.Bytearray);
     },
     dataSign() {
-      return this.aeSdk.sign(decode(this.data || emptyData));
+      return this.aeSdk.unsafeSign(decode(this.data || emptyData));
     },
   },
 };
diff --git a/examples/browser/wallet-iframe/src/App.vue b/examples/browser/wallet-iframe/src/App.vue
@@ -175,11 +175,11 @@ export default {
         return super.signTypedData(data, aci, options);
       }
 
-      async sign(data, { aeppRpcClientId: id, aeppOrigin, ...options } = {}) {
+      async unsafeSign(data, { aeppRpcClientId: id, aeppOrigin, ...options } = {}) {
         if (id != null) {
           genConfirmCallback(`sign raw data ${data}`)(id, options, aeppOrigin);
         }
-        return super.sign(data, options);
+        return super.unsafeSign(data, options);
       }
 
       async signDelegation(delegation, { aeppRpcClientId: id, aeppOrigin, ...options }) {
diff --git a/examples/browser/wallet-web-extension/src/background.js b/examples/browser/wallet-web-extension/src/background.js
@@ -86,11 +86,11 @@ class AccountMemoryProtected extends MemoryAccount {
     return super.signTypedData(data, aci, options);
   }
 
-  async sign(data, { aeppRpcClientId: id, aeppOrigin, ...options } = {}) {
+  async unsafeSign(data, { aeppRpcClientId: id, aeppOrigin, ...options } = {}) {
     if (id != null) {
       await genConfirmCallback(`sign raw data ${data}`)(id, options, aeppOrigin);
     }
-    return super.sign(data, options);
+    return super.unsafeSign(data, options);
   }
 
   async signDelegation(delegation, { aeppRpcClientId: id, aeppOrigin, ...options }) {
diff --git a/src/AeSdkBase.ts b/src/AeSdkBase.ts
@@ -164,12 +164,25 @@ export default class AeSdkBase extends AeSdkMethods {
    * Sign data blob
    * @param data - Data to sign
    * @param options - Options
+   * @deprecated Use `unsafeSign` method instead
    */
   async sign(
+    data: string | Uint8Array,
+    options: { onAccount?: OnAccount } = {},
+  ): Promise<Uint8Array> {
+    return this.unsafeSign(data, options);
+  }
+
+  /**
+   * Sign data blob
+   * @param data - Data to sign
+   * @param options - Options
+   */
+  async unsafeSign(
     data: string | Uint8Array,
     { onAccount, ...options }: { onAccount?: OnAccount } = {},
   ): Promise<Uint8Array> {
-    return this._resolveAccount(onAccount).sign(data, options);
+    return this._resolveAccount(onAccount).unsafeSign(data, options);
   }
 
   /**
diff --git a/src/AeSdkWallet.ts b/src/AeSdkWallet.ts
@@ -331,7 +331,10 @@ export default class AeSdkWallet extends AeSdk {
             if (!this._isRpcClientConnected(id)) throw new RpcNotAuthorizeError();
             if (!this.addresses().includes(onAccount)) throw new RpcPermissionDenyError(onAccount);
             const parameters = { onAccount, aeppOrigin: origin, aeppRpcClientId: id };
-            const signature = encode(await this.sign(decode(data), parameters), Encoding.Signature);
+            const signature = encode(
+              await this.unsafeSign(decode(data), parameters),
+              Encoding.Signature,
+            );
             return { signature };
           },
           [METHODS.signDelegation]: async ({ delegation, onAccount = this.address }, origin) => {
diff --git a/src/account/Base.ts b/src/account/Base.ts
@@ -74,6 +74,7 @@ export default abstract class AccountBase {
    * @param data - Data blob to sign
    * @param options - Options
    * @returns Signature
+   * @deprecated Use `unsafeSign` method instead
    */
   abstract sign(
     data: string | Uint8Array,
@@ -83,6 +84,20 @@ export default abstract class AccountBase {
     },
   ): Promise<Uint8Array>;
 
+  /**
+   * Sign data blob
+   * @param data - Data blob to sign
+   * @param options - Options
+   * @returns Signature
+   */
+  abstract unsafeSign(
+    data: string | Uint8Array,
+    options?: {
+      aeppOrigin?: string;
+      aeppRpcClientId?: string;
+    },
+  ): Promise<Uint8Array>;
+
   /**
    * Account address
    */
diff --git a/src/account/Generalized.ts b/src/account/Generalized.ts
@@ -28,8 +28,16 @@ export default class AccountGeneralized extends AccountBase {
     this.address = address;
   }
 
+  /**
+   * @deprecated Use `unsafeSign` method instead
+   */
   // eslint-disable-next-line class-methods-use-this
   override async sign(): Promise<Uint8Array> {
+    return this.unsafeSign();
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  override async unsafeSign(): Promise<Uint8Array> {
     throw new NotImplementedError("Can't sign using generalized account");
   }
 
diff --git a/src/account/Ledger.ts b/src/account/Ledger.ts
@@ -29,8 +29,16 @@ export default class AccountLedger extends AccountBase {
     transport.decorateAppAPIMethods(this, ['signTransaction', 'signMessage'], 'w0w');
   }
 
+  /**
+   * @deprecated Use `unsafeSign` method instead
+   */
   // eslint-disable-next-line class-methods-use-this
   override async sign(): Promise<Uint8Array> {
+    return this.unsafeSign();
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  override async unsafeSign(): Promise<Uint8Array> {
     throw new NotImplementedError('RAW signing using Ledger HW');
   }
 
diff --git a/src/account/Memory.ts b/src/account/Memory.ts
@@ -45,8 +45,16 @@ export default class AccountMemory extends AccountBase {
     return new AccountMemory(secretKey);
   }
 
+  /**
+   * @deprecated Use `unsafeSign` method instead
+   */
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   override async sign(data: string | Uint8Array, options?: any): Promise<Uint8Array> {
+    return this.unsafeSign(data, options);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  override async unsafeSign(data: string | Uint8Array, options?: any): Promise<Uint8Array> {
     return nacl.sign.detached(Buffer.from(data), this.#secretKeyDecoded);
   }
 
@@ -60,12 +68,12 @@ export default class AccountMemory extends AccountBase {
     const rlpBinaryTx = decode(transaction);
     const txWithNetworkId = getBufferToSign(transaction, networkId, innerTx === true);
 
-    const signatures = [await this.sign(txWithNetworkId, options)];
+    const signatures = [await this.unsafeSign(txWithNetworkId, options)];
     return buildTx({ tag: Tag.SignedTx, encodedTx: rlpBinaryTx, signatures });
   }
 
   override async signMessage(message: string, options?: any): Promise<Uint8Array> {
-    return this.sign(messageToHash(message), options);
+    return this.unsafeSign(messageToHash(message), options);
   }
 
   override async signTypedData(
@@ -85,7 +93,7 @@ export default class AccountMemory extends AccountBase {
       networkId,
       contractAddress,
     });
-    const signature = await this.sign(dHash, options);
+    const signature = await this.unsafeSign(dHash, options);
     return encode(signature, Encoding.Signature);
   }
 
@@ -100,7 +108,7 @@ export default class AccountMemory extends AccountBase {
       Buffer.from(networkId),
       decode(delegation),
     ]);
-    const signature = await this.sign(payload);
+    const signature = await this.unsafeSign(payload);
     return encode(signature, Encoding.Signature);
   }
 }
diff --git a/src/account/Metamask.ts b/src/account/Metamask.ts
@@ -46,8 +46,16 @@ export default class AccountMetamask extends AccountBase {
     this.address = address;
   }
 
+  /**
+   * @deprecated Use `unsafeSign` method instead
+   */
   // eslint-disable-next-line class-methods-use-this
   override async sign(): Promise<Uint8Array> {
+    return this.unsafeSign();
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  override async unsafeSign(): Promise<Uint8Array> {
     throw new NotImplementedError('RAW signing using MetaMask');
   }
 
diff --git a/src/account/Rpc.ts b/src/account/Rpc.ts
@@ -23,7 +23,14 @@ export default class AccountRpc extends AccountBase {
     this.address = address;
   }
 
+  /**
+   * @deprecated Use `unsafeSign` method instead
+   */
   async sign(dataRaw: string | Uint8Array): Promise<Uint8Array> {
+    return this.unsafeSign(dataRaw);
+  }
+
+  async unsafeSign(dataRaw: string | Uint8Array): Promise<Uint8Array> {
     const data = encode(Buffer.from(dataRaw), Encoding.Bytearray);
     const { signature } = await this._rpcClient.request(METHODS.unsafeSign, {
       onAccount: this.address,
diff --git a/src/utils/jwt.ts b/src/utils/jwt.ts
@@ -39,7 +39,7 @@ export async function signJwt(originalPayload: any, account: AccountBase): Promi
   }
   if (payload.sub_jwk === undefined) delete payload.sub_jwk;
   const body = `${header}.${objectToBase64Url(payload)}` as const;
-  const signature = await account.sign(body);
+  const signature = await account.unsafeSign(body);
   return `${body}.${toBase64Url(signature)}`;
 }
 
diff --git a/test/integration/accounts.ts b/test/integration/accounts.ts
@@ -206,7 +206,7 @@ describe('Accounts', () => {
 
     it('Invalid on account options', async () => {
       await expect(
-        aeSdk.sign('tx_Aasdasd', { onAccount: 123 as unknown as Encoded.AccountAddress }),
+        aeSdk.unsafeSign('tx_Aasdasd', { onAccount: 123 as unknown as Encoded.AccountAddress }),
       ).to.be.rejectedWith(
         TypeError,
         'Account should be an address (ak-prefixed string), or instance of AccountBase, got 123 instead',
@@ -216,8 +216,8 @@ describe('Accounts', () => {
     it('Make operation on account using MemoryAccount', async () => {
       const account = MemoryAccount.generate();
       const data = 'Hello';
-      const signature = await account.sign(data);
-      const sigUsingMemoryAccount = await aeSdk.sign(data, { onAccount: account });
+      const signature = await account.unsafeSign(data);
+      const sigUsingMemoryAccount = await aeSdk.unsafeSign(data, { onAccount: account });
       expect(signature).to.eql(sigUsingMemoryAccount);
     });
   });
diff --git a/test/integration/contract-aci.ts b/test/integration/contract-aci.ts
@@ -1329,7 +1329,7 @@ describe('Contract instance', () => {
       });
 
       it('Valid', async () => {
-        const fakeSignature = Buffer.from(await aeSdk.sign(decode(aeSdk.address)));
+        const fakeSignature = Buffer.from(await aeSdk.unsafeSign(decode(aeSdk.address)));
         const hashAsBuffer = await testContract.signatureFn(fakeSignature);
         const hashAsHex = await testContract.signatureFn(fakeSignature.toString('hex'));
         hashAsBuffer.decodedResult.should.be.eql(fakeSignature);
diff --git a/test/integration/contract.ts b/test/integration/contract.ts
@@ -70,7 +70,7 @@ describe('Contract', () => {
     });
     await signContract.$deploy([]);
     const data = Buffer.from(new Array(32).fill(0).map((_, idx) => idx ** 2));
-    const signature = await aeSdk.sign(data);
+    const signature = await aeSdk.unsafeSign(data);
     expect((await signContract.verify(data, aeSdk.address, signature)).decodedResult).to.equal(
       true,
     );
diff --git a/test/integration/rpc.ts b/test/integration/rpc.ts
@@ -503,28 +503,30 @@ describe('Aepp<->Wallet', () => {
 
       it('rejected by wallet', async () => {
         let origin;
-        const s = stub(wallet._resolveAccount(), 'sign').callsFake((data, { aeppOrigin } = {}) => {
-          origin = aeppOrigin;
-          throw new RpcRejectedByUserError();
-        });
-        await expect(aepp.sign(rawData))
+        const s = stub(wallet._resolveAccount(), 'unsafeSign').callsFake(
+          (data, { aeppOrigin } = {}) => {
+            origin = aeppOrigin;
+            throw new RpcRejectedByUserError();
+          },
+        );
+        await expect(aepp.unsafeSign(rawData))
           .to.be.eventually.rejectedWith('Operation rejected by user')
           .with.property('code', 4);
         expect(origin).to.equal('http://origin.test');
         s.restore();
       });
 
       it('works', async () => {
-        const signature = await aepp.sign(rawData);
+        const signature = await aepp.unsafeSign(rawData);
         expect(signature).to.be.an.instanceOf(Buffer);
         expect(verify(rawData, signature, aepp.address)).to.equal(true);
       });
 
       it('fails with unknown error', async () => {
-        const s = stub(wallet._resolveAccount(), 'sign').callsFake(() => {
+        const s = stub(wallet._resolveAccount(), 'unsafeSign').callsFake(() => {
           throw new Error('test');
         });
-        await expect(aepp.sign(rawData))
+        await expect(aepp.unsafeSign(rawData))
           .to.be.eventually.rejectedWith(
             'The peer failed to execute your request due to unknown error',
           )
@@ -534,7 +536,7 @@ describe('Aepp<->Wallet', () => {
 
       it('signs using specific account', async () => {
         const onAccount = wallet.addresses()[1];
-        const signature = await aepp.sign(rawData, { onAccount });
+        const signature = await aepp.unsafeSign(rawData, { onAccount });
         expect(verify(rawData, signature, onAccount)).to.equal(true);
       });
     });
diff --git a/test/unit/ledger.ts b/test/unit/ledger.ts
@@ -181,7 +181,7 @@ describe('Ledger HW', function () {
     it('fails on calling raw signing', async () => {
       const transport = await initTransport('\n');
       const account = new AccountLedger(transport, 0, address);
-      await expect(account.sign()).to.be.rejectedWith('RAW signing using Ledger HW');
+      await expect(account.unsafeSign()).to.be.rejectedWith('RAW signing using Ledger HW');
     });
 
     const transaction = buildTx({
diff --git a/test/unit/memory-account.ts b/test/unit/memory-account.ts
@@ -27,7 +27,7 @@ describe('MemoryAccount', () => {
   it('Sign raw data', async () => {
     const data = Buffer.from(new Array(10).fill(0).map((_, idx) => idx));
     const account = new MemoryAccount(secretKey);
-    const signature = await account.sign(data);
+    const signature = await account.unsafeSign(data);
     expect(signature).to.eql(
       Uint8Array.from([
         113, 154, 121, 195, 164, 141, 153, 234, 196, 82, 120, 31, 198, 179, 208, 138, 88, 63, 98,
diff --git a/test/unit/metamask.ts b/test/unit/metamask.ts
@@ -239,7 +239,7 @@ describe('Aeternity Snap for MetaMask', function () {
     it('fails on calling raw signing', async () => {
       const provider = await initProvider([]);
       const account = new AccountMetamask(provider, 0, address);
-      await expect(account.sign()).to.be.rejectedWith('RAW signing using MetaMask');
+      await expect(account.unsafeSign()).to.be.rejectedWith('RAW signing using MetaMask');
     });
 
     const transaction = buildTx({

Original file line number	Diff line number	Diff line change
`@@ -175,11 +175,11 @@ export default {`
`175`	`175`	`return super.signTypedData(data, aci, options);`
`176`	`176`	`}`
`177`	`177`
`178`		`- async sign(data, { aeppRpcClientId: id, aeppOrigin, ...options } = {}) {`
	`178`	`+ async unsafeSign(data, { aeppRpcClientId: id, aeppOrigin, ...options } = {}) {`
`179`	`179`	`if (id != null) {`
`180`	`180`	genConfirmCallback(`sign raw data ${data}`)(id, options, aeppOrigin);
`181`	`181`	`}`
`182`		`- return super.sign(data, options);`
	`182`	`+ return super.unsafeSign(data, options);`
`183`	`183`	`}`
`184`	`184`
`185`	`185`	`async signDelegation(delegation, { aeppRpcClientId: id, aeppOrigin, ...options }) {`
Original file line number	Diff line number	Diff line change
`@@ -86,11 +86,11 @@ class AccountMemoryProtected extends MemoryAccount {`
`86`	`86`	`return super.signTypedData(data, aci, options);`
`87`	`87`	`}`
`88`	`88`
`89`		`- async sign(data, { aeppRpcClientId: id, aeppOrigin, ...options } = {}) {`
	`89`	`+ async unsafeSign(data, { aeppRpcClientId: id, aeppOrigin, ...options } = {}) {`
`90`	`90`	`if (id != null) {`
`91`	`91`	await genConfirmCallback(`sign raw data ${data}`)(id, options, aeppOrigin);
`92`	`92`	`}`
`93`		`- return super.sign(data, options);`
	`93`	`+ return super.unsafeSign(data, options);`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`async signDelegation(delegation, { aeppRpcClientId: id, aeppOrigin, ...options }) {`