From 92dae869cf6d2483ffbe849f431d111d71c2f3ea Mon Sep 17 00:00:00 2001
From: Denis Davidyuk <denis_davidyuk@hotmail.com>
Date: Thu, 14 Dec 2023 18:22:08 +0530
Subject: [PATCH] feat(contract): support all names delegation to contract

---
 docs/guides/aens.md                           |  9 +++---
 .../browser/aepp/src/DelegationSignature.vue  | 10 +++++-
 examples/browser/wallet-iframe/src/App.vue    | 11 +++++++
 .../wallet-web-extension/src/background.js    | 11 +++++++
 src/AeSdkBase.ts                              | 11 +++++++
 src/AeSdkWallet.ts                            |  4 ++-
 src/account/Base.ts                           | 21 ++++++++++++
 src/account/Generalized.ts                    |  5 +++
 src/account/Ledger.ts                         |  5 +++
 src/account/Memory.ts                         | 15 +++++++++
 src/account/Rpc.ts                            | 11 +++++++
 src/aepp-wallet-communication/rpc/types.ts    |  1 +
 test/integration/contract.ts                  | 32 ++++++++++++++++++-
 13 files changed, 139 insertions(+), 7 deletions(-)

diff --git a/docs/guides/aens.md b/docs/guides/aens.md
index 761a1240f1..eebf9cbd89 100644
--- a/docs/guides/aens.md
+++ b/docs/guides/aens.md
@@ -371,13 +371,14 @@ const aeSdk = new AeSdk({ ... }) // init the SDK instance with AeSdk class
 const contractAddress = 'ct_asd2ks...'
 // AENS name
 const name = 'example.chain'
-// Sign with a specific account
-const onAccount = aeSdk.address
 
 // this signature will allow the contract to perform a pre-claim on your behalf
-const preClaimSig = await aeSdk.createDelegationSignature(contractAddress, [])
+const preClaimSig = await aeSdk.signDelegationToContract(contractAddress)
 
 // this signature will allow the contract to perform
 // any name related transaction for a specific name that you own
-const aensDelegationSig = await aeSdk.createDelegationSignature(contractAddress, [name], { onAccount })
+const nameDelegationSig = await aeSdk.signNameDelegationToContract(contractAddress, name)
+
+// alternatively, you can generate a delegation signature suitable for every name you own
+const allNamesDelegationSig = await aeSdk.signAllNamesDelegationToContract(contractAddress)
 ```
diff --git a/examples/browser/aepp/src/DelegationSignature.vue b/examples/browser/aepp/src/DelegationSignature.vue
index b46b81d997..8e0a668c65 100644
--- a/examples/browser/aepp/src/DelegationSignature.vue
+++ b/examples/browser/aepp/src/DelegationSignature.vue
@@ -8,7 +8,7 @@
     <div>
       <label>
         <input v-model="type" type="radio" value="general">
-        AENS and oracle
+        AENS preclaim and oracle
       </label>
     </div>
     <div>
@@ -18,6 +18,12 @@
       </label>
       <div><input v-model="name"></div>
     </div>
+    <div>
+      <label>
+        <input v-model="type" type="radio" value="all-names">
+        All AENS names
+      </label>
+    </div>
     <div>
       <label>
         <input v-model="type" type="radio" value="oracle-query">
@@ -56,6 +62,8 @@ export default {
           return this.aeSdk.signDelegationToContract(this.contractAddress);
         case 'name':
           return this.aeSdk.signNameDelegationToContract(this.contractAddress, this.name);
+        case 'all-names':
+          return this.aeSdk.signAllNamesDelegationToContract(this.contractAddress);
         case 'oracle-query':
           return this.aeSdk
             .signOracleQueryDelegationToContract(this.contractAddress, this.oracleQueryId);
diff --git a/examples/browser/wallet-iframe/src/App.vue b/examples/browser/wallet-iframe/src/App.vue
index eac4c67c03..23050ac59a 100644
--- a/examples/browser/wallet-iframe/src/App.vue
+++ b/examples/browser/wallet-iframe/src/App.vue
@@ -207,6 +207,17 @@ export default {
         return super.signNameDelegationToContract(contractAddress, name, options);
       }
 
+      async signAllNamesDelegationToContract(
+        contractAddress,
+        { aeppRpcClientId: id, aeppOrigin, ...options },
+      ) {
+        if (id != null) {
+          const opt = { ...options, contractAddress };
+          genConfirmCallback('sign delegation of all names to contract')(id, opt, aeppOrigin);
+        }
+        return super.signAllNamesDelegationToContract(contractAddress, options);
+      }
+
       async signOracleQueryDelegationToContract(
         contractAddress,
         oracleQueryId,
diff --git a/examples/browser/wallet-web-extension/src/background.js b/examples/browser/wallet-web-extension/src/background.js
index 59f5d41205..57e4d89413 100644
--- a/examples/browser/wallet-web-extension/src/background.js
+++ b/examples/browser/wallet-web-extension/src/background.js
@@ -101,6 +101,17 @@ class AccountMemoryProtected extends MemoryAccount {
     return super.signNameDelegationToContract(contractAddress, name, options);
   }
 
+  async signAllNamesDelegationToContract(
+    contractAddress,
+    { aeppRpcClientId: id, aeppOrigin, ...options },
+  ) {
+    if (id != null) {
+      const opt = { ...options, contractAddress };
+      genConfirmCallback('sign delegation of all names to contract')(id, opt, aeppOrigin);
+    }
+    return super.signAllNamesDelegationToContract(contractAddress, options);
+  }
+
   async signOracleQueryDelegationToContract(
     contractAddress,
     oracleQueryId,
diff --git a/src/AeSdkBase.ts b/src/AeSdkBase.ts
index 8da2ef730c..ee9882db27 100644
--- a/src/AeSdkBase.ts
+++ b/src/AeSdkBase.ts
@@ -200,6 +200,17 @@ export default class AeSdkBase extends AeSdkMethods {
       .signNameDelegationToContract(contractAddress, name, options);
   }
 
+  async signAllNamesDelegationToContract(
+    contractAddress: Encoded.ContractAddress,
+    { onAccount, ...options }: { onAccount?: OnAccount }
+    & Parameters<AccountBase['signAllNamesDelegationToContract']>[1] = {},
+  ): Promise<Encoded.Signature> {
+    options.networkId ??= this.selectedNodeName !== null
+      ? await this.api.getNetworkId() : undefined;
+    return this._resolveAccount(onAccount)
+      .signAllNamesDelegationToContract(contractAddress, options);
+  }
+
   async signOracleQueryDelegationToContract(
     contractAddress: Encoded.ContractAddress,
     oracleQueryId: Encoded.OracleQueryId,
diff --git a/src/AeSdkWallet.ts b/src/AeSdkWallet.ts
index 2c58804202..875d9bdfb8 100644
--- a/src/AeSdkWallet.ts
+++ b/src/AeSdkWallet.ts
@@ -302,7 +302,7 @@ export default class AeSdkWallet extends AeSdk {
             };
           },
           [METHODS.signDelegationToContract]: async ({
-            contractAddress, name, oracleQueryId, onAccount = this.address,
+            contractAddress, name, oracleQueryId, allNames, onAccount = this.address,
           }, origin) => {
             if (!this._isRpcClientConnected(id)) throw new RpcNotAuthorizeError();
             if (!this.addresses().includes(onAccount)) {
@@ -315,6 +315,8 @@ export default class AeSdkWallet extends AeSdk {
                 .signNameDelegationToContract(contractAddress, name, parameters))
               ?? (oracleQueryId == null ? null : this
                 .signOracleQueryDelegationToContract(contractAddress, oracleQueryId, parameters))
+              ?? (allNames !== true ? null : this
+                .signAllNamesDelegationToContract(contractAddress, parameters))
               ?? this.signDelegationToContract(contractAddress, parameters)
             );
             return { signature };
diff --git a/src/account/Base.ts b/src/account/Base.ts
index e8492eb0b3..4664fec19e 100644
--- a/src/account/Base.ts
+++ b/src/account/Base.ts
@@ -120,6 +120,27 @@ export default abstract class AccountBase {
     throw new NotImplementedError('signNameDelegationToContract method');
   }
 
+  /**
+   * Sign delegation of all AENS names to a contract (not available in Iris)
+   * @param contractAddress - Address of a contract to delegate permissions to
+   * @param options - Options
+   * @returns Signature
+   */
+  // TODO: make abstract in the next major release
+  // eslint-disable-next-line class-methods-use-this
+  async signAllNamesDelegationToContract(
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    contractAddress: Encoded.ContractAddress,
+    options?: {
+      networkId?: string;
+      aeppOrigin?: string;
+      aeppRpcClientId?: string;
+    },
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+  ): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signAllNamesDelegationToContract method');
+  }
+
   /**
    * Sign delegation of oracle query to a contract
    *
diff --git a/src/account/Generalized.ts b/src/account/Generalized.ts
index a0196acf6f..a8c7761fca 100644
--- a/src/account/Generalized.ts
+++ b/src/account/Generalized.ts
@@ -53,6 +53,11 @@ export default class AccountGeneralized extends AccountBase {
     throw new NotImplementedError('signing delegation to contract using generalized account');
   }
 
+  // eslint-disable-next-line class-methods-use-this
+  override async signAllNamesDelegationToContract(): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signing delegation to contract using generalized account');
+  }
+
   // eslint-disable-next-line class-methods-use-this
   override async signOracleQueryDelegationToContract(): Promise<Encoded.Signature> {
     throw new NotImplementedError('signing delegation to contract using generalized account');
diff --git a/src/account/Ledger.ts b/src/account/Ledger.ts
index 1f4e3e970b..99f8e126e0 100644
--- a/src/account/Ledger.ts
+++ b/src/account/Ledger.ts
@@ -55,6 +55,11 @@ export default class AccountLedger extends AccountBase {
     throw new NotImplementedError('signing delegation to contract using Ledger HW');
   }
 
+  // eslint-disable-next-line class-methods-use-this
+  override async signAllNamesDelegationToContract(): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signing delegation to contract using Ledger HW');
+  }
+
   // eslint-disable-next-line class-methods-use-this
   override async signOracleQueryDelegationToContract(): Promise<Encoded.Signature> {
     throw new NotImplementedError('signing delegation to contract using Ledger HW');
diff --git a/src/account/Memory.ts b/src/account/Memory.ts
index ec4edd8a0d..b9879b3d10 100644
--- a/src/account/Memory.ts
+++ b/src/account/Memory.ts
@@ -121,6 +121,21 @@ export default class AccountMemory extends AccountBase {
     return encode(signature, Encoding.Signature);
   }
 
+  override async signAllNamesDelegationToContract(
+    contractAddress: Encoded.ContractAddress,
+    { networkId }: { networkId?: string } = {},
+  ): Promise<Encoded.Signature> {
+    if (networkId == null) throw new ArgumentError('networkId', 'provided', networkId);
+    const payload = concatBuffers([
+      Buffer.from(networkId),
+      decode(this.address),
+      Buffer.from('AENS'),
+      decode(contractAddress),
+    ]);
+    const signature = await this.sign(payload);
+    return encode(signature, Encoding.Signature);
+  }
+
   override async signOracleQueryDelegationToContract(
     contractAddress: Encoded.ContractAddress,
     oracleQueryId: Encoded.OracleQueryId,
diff --git a/src/account/Rpc.ts b/src/account/Rpc.ts
index 7b0bc456d8..369c569fcb 100644
--- a/src/account/Rpc.ts
+++ b/src/account/Rpc.ts
@@ -93,6 +93,17 @@ export default class AccountRpc extends AccountBase {
     return signature;
   }
 
+  override async signAllNamesDelegationToContract(
+    contractAddress: Encoded.ContractAddress,
+  ): Promise<Encoded.Signature> {
+    const { signature } = await this._rpcClient.request(METHODS.signDelegationToContract, {
+      onAccount: this.address,
+      contractAddress,
+      allNames: true,
+    });
+    return signature;
+  }
+
   override async signOracleQueryDelegationToContract(
     contractAddress: Encoded.ContractAddress,
     oracleQueryId: Encoded.OracleQueryId,
diff --git a/src/aepp-wallet-communication/rpc/types.ts b/src/aepp-wallet-communication/rpc/types.ts
index 1aa257e703..3e40517ecd 100644
--- a/src/aepp-wallet-communication/rpc/types.ts
+++ b/src/aepp-wallet-communication/rpc/types.ts
@@ -89,6 +89,7 @@ export interface WalletApi {
       contractAddress: Encoded.ContractAddress;
       name?: AensName;
       oracleQueryId?: Encoded.OracleQueryId;
+      allNames?: boolean;
       onAccount: Encoded.AccountAddress;
     },
   ) => Promise<{ signature: Encoded.Signature }>;
diff --git a/test/integration/contract.ts b/test/integration/contract.ts
index afbec9d4c8..e5705339a7 100644
--- a/test/integration/contract.ts
+++ b/test/integration/contract.ts
@@ -325,9 +325,10 @@ describe('Contract', () => {
     }>;
     let contractAddress: Encoded.ContractAddress;
     let aens: string;
+    let isIris: boolean;
 
     before(async () => {
-      const isIris = (await aeSdk.api.getNodeInfo())
+      isIris = (await aeSdk.api.getNodeInfo())
         .consensusProtocolVersion === ConsensusProtocolVersion.Iris;
       aens = isIris ? 'AENS' : 'AENSv2';
       contract = await aeSdk.initializeContract({
@@ -419,6 +420,35 @@ contract DelegateTest =
       result.returnType.should.be.equal('ok');
       await expect(aeSdk.aensQuery(name)).to.be.rejectedWith(Error);
     });
+
+    it('works using wildcard delegation signature', async () => {
+      if (isIris) return;
+      const allNamesDelSig = decode(await aeSdk.signAllNamesDelegationToContract(contractAddress));
+      const n = randomName(15);
+
+      const commitmentId = decode(commitmentHash(n, salt));
+      await contract.signedPreclaim(owner, commitmentId, allNamesDelSig);
+      await aeSdk.awaitHeight(2 + await aeSdk.getHeight());
+
+      await contract.signedClaim(owner, n, salt, 20e18, allNamesDelSig);
+
+      const pointee = { 'AENSv2.OraclePt': [newOwner] as const };
+      await contract.signedUpdate(owner, n, 'oracle', pointee, allNamesDelSig);
+
+      const nameEntry = (await contract.getName(n)).decodedResult['AENSv2.Name'];
+      const ttl = nameEntry[1].FixedTTL[0];
+      expect(ttl).to.be.a('bigint');
+      expect(nameEntry).to.be.eql([
+        owner,
+        { FixedTTL: [ttl] },
+        new Map([['oracle', { 'AENSv2.OraclePt': [newOwner] }]]),
+      ]);
+
+      await contract.signedTransfer(owner, newOwner, n, allNamesDelSig);
+      await aeSdk.aensTransfer(n, owner, { onAccount: newOwner });
+
+      await contract.signedRevoke(owner, n, allNamesDelSig);
+    });
   });
 
   describe('Oracle operation delegation', () => {