feat(contract): support all names delegation to contract

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)
 ```

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);

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,

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,

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,

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 };

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
    *

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');

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');

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,

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,

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 }>;

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', () => {