diff --git a/.gitignore b/.gitignore
index bf245d2b08..d8daa5f5bb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -29,6 +29,7 @@ coverage.*
 site
 /src/apis/
 /src/tx/builder/schema.generated.ts
+/src/tx/builder/delegation/schema.generated.ts
 /tooling/autorest/compiler-swagger.yaml
 /tooling/autorest/middleware-openapi.yaml
 /test/environment/ledger/browser
diff --git a/docker-compose.yml b/docker-compose.yml
index 5875e996e6..a684119fb7 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -1,7 +1,7 @@
 version: '3'
 services:
   node:
-    image: aeternity/aeternity:v6.12.0
+    image: aeternity/aeternity:master@sha256:dac4a3b032ee05f2e0d4b4ce5b0da5c639f95e849fe0332e393f87ca01da0df2
     hostname: node
     ports: ["3013:3013", "3113:3113", "3014:3014", "3114:3114"]
     volumes:
diff --git a/docs/guides/aens.md b/docs/guides/aens.md
index eebf9cbd89..0c6069ba46 100644
--- a/docs/guides/aens.md
+++ b/docs/guides/aens.md
@@ -373,7 +373,7 @@ const contractAddress = 'ct_asd2ks...'
 const name = 'example.chain'
 
 // this signature will allow the contract to perform a pre-claim on your behalf
-const preClaimSig = await aeSdk.signDelegationToContract(contractAddress)
+const preClaimSig = await aeSdk.signDelegationToContract(contractAddress, { isOracle: false })
 
 // this signature will allow the contract to perform
 // any name related transaction for a specific name that you own
diff --git a/examples/browser/aepp/src/DelegationSignature.vue b/examples/browser/aepp/src/DelegationSignature.vue
index 8e0a668c65..dcc6c1b2f0 100644
--- a/examples/browser/aepp/src/DelegationSignature.vue
+++ b/examples/browser/aepp/src/DelegationSignature.vue
@@ -7,27 +7,33 @@
     </div>
     <div>
       <label>
-        <input v-model="type" type="radio" value="general">
-        AENS preclaim and oracle
+        <input v-model="type" type="radio" :value="DelegationTag.AensPreclaim">
+        AENS preclaim
       </label>
     </div>
     <div>
       <label>
-        <input v-model="type" type="radio" value="name">
+        <input v-model="type" type="radio" :value="DelegationTag.Oracle">
+        Oracle
+      </label>
+    </div>
+    <div>
+      <label>
+        <input v-model="type" type="radio" :value="DelegationTag.AensName">
         AENS name
       </label>
       <div><input v-model="name"></div>
     </div>
     <div>
       <label>
-        <input v-model="type" type="radio" value="all-names">
+        <input v-model="type" type="radio" :value="DelegationTag.AensWildcard">
         All AENS names
       </label>
     </div>
     <div>
       <label>
-        <input v-model="type" type="radio" value="oracle-query">
-        Oracle query
+        <input v-model="type" type="radio" :value="DelegationTag.OracleResponse">
+        Response to oracle query
       </label>
       <div><input v-model="oracleQueryId"></div>
     </div>
@@ -43,12 +49,14 @@
 
 <script>
 import { mapState } from 'vuex';
+import { DelegationTag } from '@aeternity/aepp-sdk';
 import Value from './components/Value.vue';
 
 export default {
   components: { Value },
   data: () => ({
-    type: 'general',
+    DelegationTag,
+    type: DelegationTag.AensPreclaim,
     contractAddress: 'ct_6y3N9KqQb74QsvR9NrESyhWeLNiA9aJgJ7ua8CvsTuGot6uzh',
     name: 'test.chain',
     oracleQueryId: 'oq_6y3N9KqQb74QsvR9NrESyhWeLNiA9aJgJ7ua8CvsTuGot6uzh',
@@ -58,17 +66,19 @@ export default {
   methods: {
     sign() {
       switch (this.type) {
-        case 'general':
-          return this.aeSdk.signDelegationToContract(this.contractAddress);
-        case 'name':
+        case DelegationTag.AensPreclaim:
+          return this.aeSdk.signDelegationToContract(this.contractAddress, { isOracle: false });
+        case DelegationTag.Oracle:
+          return this.aeSdk.signDelegationToContract(this.contractAddress, { isOracle: true });
+        case DelegationTag.AensName:
           return this.aeSdk.signNameDelegationToContract(this.contractAddress, this.name);
-        case 'all-names':
+        case DelegationTag.AensWildcard:
           return this.aeSdk.signAllNamesDelegationToContract(this.contractAddress);
-        case 'oracle-query':
+        case DelegationTag.OracleResponse:
           return this.aeSdk
             .signOracleQueryDelegationToContract(this.contractAddress, this.oracleQueryId);
         default:
-          throw new Error(`Unknown delegation signature type: ${this.type}`)
+          throw new Error(`Unknown delegation signature type: ${DelegationTag[this.type]}`);
       }
     },
   },
diff --git a/examples/browser/wallet-iframe/src/App.vue b/examples/browser/wallet-iframe/src/App.vue
index 23050ac59a..ca755a8bf6 100644
--- a/examples/browser/wallet-iframe/src/App.vue
+++ b/examples/browser/wallet-iframe/src/App.vue
@@ -64,7 +64,7 @@
 import {
   MemoryAccount, generateKeyPair, AeSdkWallet, Node, CompilerHttp,
   BrowserWindowMessageConnection, METHODS, WALLET_TYPE, RPC_STATUS,
-  RpcConnectionDenyError, RpcRejectedByUserError, unpackTx,
+  RpcConnectionDenyError, RpcRejectedByUserError, unpackTx, unpackDelegation,
 } from '@aeternity/aepp-sdk';
 import { TypeResolver, ContractByteArrayEncoder } from '@aeternity/aepp-calldata';
 import Value from './Value.vue';
@@ -230,6 +230,14 @@ export default {
         return super.signOracleQueryDelegationToContract(contractAddress, oracleQueryId, options);
       }
 
+      async signDelegation(delegation, { aeppRpcClientId: id, aeppOrigin, ...options }) {
+        if (id != null) {
+          const opt = { ...options, ...unpackDelegation(delegation) };
+          genConfirmCallback('sign delegation')(id, opt, aeppOrigin);
+        }
+        return super.signDelegation(delegation, options);
+      }
+
       static generate() {
         // TODO: can inherit parent method after implementing https://github.com/aeternity/aepp-sdk-js/issues/1672
         return new AccountMemoryProtected(generateKeyPair().secretKey);
diff --git a/examples/browser/wallet-web-extension/src/background.js b/examples/browser/wallet-web-extension/src/background.js
index 57e4d89413..f9c070b9fa 100644
--- a/examples/browser/wallet-web-extension/src/background.js
+++ b/examples/browser/wallet-web-extension/src/background.js
@@ -1,7 +1,7 @@
 import browser from 'webextension-polyfill';
 import {
   AeSdkWallet, CompilerHttp, Node, MemoryAccount, generateKeyPair, BrowserRuntimeConnection,
-  WALLET_TYPE, RpcConnectionDenyError, RpcRejectedByUserError, unpackTx,
+  WALLET_TYPE, RpcConnectionDenyError, RpcRejectedByUserError, unpackTx, unpackDelegation,
 } from '@aeternity/aepp-sdk';
 import { TypeResolver, ContractByteArrayEncoder } from '@aeternity/aepp-calldata';
 
@@ -124,6 +124,14 @@ class AccountMemoryProtected extends MemoryAccount {
     return super.signOracleQueryDelegationToContract(contractAddress, oracleQueryId, options);
   }
 
+  async signDelegation(delegation, { aeppRpcClientId: id, aeppOrigin, ...options }) {
+    if (id != null) {
+      const opt = { ...options, ...unpackDelegation(delegation) };
+      await genConfirmCallback('sign delegation')(id, opt, aeppOrigin);
+    }
+    return super.signDelegation(delegation, options);
+  }
+
   static generate() {
     // TODO: can inherit parent method after implementing https://github.com/aeternity/aepp-sdk-js/issues/1672
     return new AccountMemoryProtected(generateKeyPair().secretKey);
diff --git a/src/AeSdkBase.ts b/src/AeSdkBase.ts
index ee9882db27..c23a55d790 100644
--- a/src/AeSdkBase.ts
+++ b/src/AeSdkBase.ts
@@ -177,6 +177,9 @@ export default class AeSdkBase extends AeSdkMethods {
     return this._resolveAccount(onAccount).signTypedData(data, aci, options);
   }
 
+  /**
+   * @deprecated use AeSdkBase:signDelegation in Ceres
+   */
   async signDelegationToContract(
     contractAddress: Encoded.ContractAddress,
     { onAccount, ...options }: { onAccount?: OnAccount }
@@ -184,10 +187,15 @@ export default class AeSdkBase extends AeSdkMethods {
   ): Promise<Encoded.Signature> {
     options.networkId ??= this.selectedNodeName !== null
       ? await this.api.getNetworkId() : undefined;
+    options.consensusProtocolVersion ??= this.selectedNodeName !== null
+      ? (await this.api.getNodeInfo()).consensusProtocolVersion : undefined;
     return this._resolveAccount(onAccount)
       .signDelegationToContract(contractAddress, options);
   }
 
+  /**
+   * @deprecated use AeSdkBase:signDelegation in Ceres
+   */
   async signNameDelegationToContract(
     contractAddress: Encoded.ContractAddress,
     name: AensName,
@@ -196,10 +204,15 @@ export default class AeSdkBase extends AeSdkMethods {
   ): Promise<Encoded.Signature> {
     options.networkId ??= this.selectedNodeName !== null
       ? await this.api.getNetworkId() : undefined;
+    options.consensusProtocolVersion ??= this.selectedNodeName !== null
+      ? (await this.api.getNodeInfo()).consensusProtocolVersion : undefined;
     return this._resolveAccount(onAccount)
       .signNameDelegationToContract(contractAddress, name, options);
   }
 
+  /**
+   * @deprecated use AeSdkBase:signDelegation in Ceres
+   */
   async signAllNamesDelegationToContract(
     contractAddress: Encoded.ContractAddress,
     { onAccount, ...options }: { onAccount?: OnAccount }
@@ -207,10 +220,15 @@ export default class AeSdkBase extends AeSdkMethods {
   ): Promise<Encoded.Signature> {
     options.networkId ??= this.selectedNodeName !== null
       ? await this.api.getNetworkId() : undefined;
+    options.consensusProtocolVersion ??= this.selectedNodeName !== null
+      ? (await this.api.getNodeInfo()).consensusProtocolVersion : undefined;
     return this._resolveAccount(onAccount)
       .signAllNamesDelegationToContract(contractAddress, options);
   }
 
+  /**
+   * @deprecated use AeSdkBase:signDelegation in Ceres
+   */
   async signOracleQueryDelegationToContract(
     contractAddress: Encoded.ContractAddress,
     oracleQueryId: Encoded.OracleQueryId,
@@ -219,10 +237,22 @@ export default class AeSdkBase extends AeSdkMethods {
   ): Promise<Encoded.Signature> {
     options.networkId ??= this.selectedNodeName !== null
       ? await this.api.getNetworkId() : undefined;
+    options.consensusProtocolVersion ??= this.selectedNodeName !== null
+      ? (await this.api.getNodeInfo()).consensusProtocolVersion : undefined;
     return this._resolveAccount(onAccount)
       .signOracleQueryDelegationToContract(contractAddress, oracleQueryId, options);
   }
 
+  async signDelegation(
+    delegation: Encoded.Bytearray,
+    { onAccount, ...options }: { onAccount?: OnAccount }
+    & Parameters<AccountBase['signDelegation']>[1] = {},
+  ): Promise<Encoded.Signature> {
+    options.networkId ??= this.selectedNodeName !== null
+      ? await this.api.getNetworkId() : undefined;
+    return this._resolveAccount(onAccount).signDelegation(delegation, options);
+  }
+
   /**
    * The same as AeSdkMethods:getContext, but it would resolve ak_-prefixed address in
    * `mergeWith.onAccount` to AccountBase.
diff --git a/src/AeSdkWallet.ts b/src/AeSdkWallet.ts
index 875d9bdfb8..18b82fd37f 100644
--- a/src/AeSdkWallet.ts
+++ b/src/AeSdkWallet.ts
@@ -302,13 +302,14 @@ export default class AeSdkWallet extends AeSdk {
             };
           },
           [METHODS.signDelegationToContract]: async ({
-            contractAddress, name, oracleQueryId, allNames, onAccount = this.address,
+            contractAddress, name, oracleQueryId, allNames, onAccount = this.address, isOracle,
           }, origin) => {
             if (!this._isRpcClientConnected(id)) throw new RpcNotAuthorizeError();
             if (!this.addresses().includes(onAccount)) {
               throw new RpcPermissionDenyError(onAccount);
             }
 
+            isOracle ??= false;
             const parameters = { onAccount, aeppOrigin: origin, aeppRpcClientId: id };
             const signature = await (
               (name == null ? null : this
@@ -317,10 +318,17 @@ export default class AeSdkWallet extends AeSdk {
                 .signOracleQueryDelegationToContract(contractAddress, oracleQueryId, parameters))
               ?? (allNames !== true ? null : this
                 .signAllNamesDelegationToContract(contractAddress, parameters))
-              ?? this.signDelegationToContract(contractAddress, parameters)
+              ?? this.signDelegationToContract(contractAddress, { ...parameters, isOracle })
             );
             return { signature };
           },
+          [METHODS.signDelegation]: async ({ delegation, onAccount = this.address }, origin) => {
+            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 = await this.signDelegation(delegation, parameters);
+            return { signature };
+          },
         },
       ),
     };
diff --git a/src/account/Base.ts b/src/account/Base.ts
index 4664fec19e..d92b77432e 100644
--- a/src/account/Base.ts
+++ b/src/account/Base.ts
@@ -1,7 +1,7 @@
 import { Encoded } from '../utils/encoder';
 import Node from '../Node';
 import CompilerBase from '../contract/compiler/Base';
-import { AensName, Int } from '../tx/builder/constants';
+import { AensName, ConsensusProtocolVersion, Int } from '../tx/builder/constants';
 import { AciValue, Domain } from '../utils/typed-data';
 import { NotImplementedError } from '../utils/errors';
 
@@ -80,7 +80,10 @@ export default abstract class AccountBase {
    * Sign delegation of AENS, oracle operations to a contract
    * @param contractAddress - Address of a contract to delegate permissions to
    * @param options - Options
+   * @param options.isOracle - Use to generate an oracle delegation signature in Ceres, otherwise an
+   * AENS preclaim delegation signature would be generated
    * @returns Signature
+   * @deprecated use AccountBase:signDelegation in Ceres
    */
   // TODO: make abstract in the next major release
   // eslint-disable-next-line class-methods-use-this
@@ -89,6 +92,8 @@ export default abstract class AccountBase {
     contractAddress: Encoded.ContractAddress,
     options?: {
       networkId?: string;
+      consensusProtocolVersion?: ConsensusProtocolVersion;
+      isOracle?: boolean;
       aeppOrigin?: string;
       aeppRpcClientId?: string;
     },
@@ -103,6 +108,7 @@ export default abstract class AccountBase {
    * @param name - AENS name to manage by a contract
    * @param options - Options
    * @returns Signature
+   * @deprecated use AccountBase:signDelegation in Ceres
    */
   // TODO: make abstract in the next major release
   // eslint-disable-next-line class-methods-use-this
@@ -112,6 +118,7 @@ export default abstract class AccountBase {
     name: AensName,
     options?: {
       networkId?: string;
+      consensusProtocolVersion?: ConsensusProtocolVersion;
       aeppOrigin?: string;
       aeppRpcClientId?: string;
     },
@@ -125,6 +132,7 @@ export default abstract class AccountBase {
    * @param contractAddress - Address of a contract to delegate permissions to
    * @param options - Options
    * @returns Signature
+   * @deprecated use AccountBase:signDelegation in Ceres
    */
   // TODO: make abstract in the next major release
   // eslint-disable-next-line class-methods-use-this
@@ -133,6 +141,7 @@ export default abstract class AccountBase {
     contractAddress: Encoded.ContractAddress,
     options?: {
       networkId?: string;
+      consensusProtocolVersion?: ConsensusProtocolVersion;
       aeppOrigin?: string;
       aeppRpcClientId?: string;
     },
@@ -154,6 +163,7 @@ export default abstract class AccountBase {
    * @param oracleQueryId - Oracle query ID to reply by a contract
    * @param options - Options
    * @returns Signature
+   * @deprecated use AccountBase:signDelegation in Ceres
    */
   // TODO: make abstract in the next major release
   // eslint-disable-next-line class-methods-use-this
@@ -163,6 +173,7 @@ export default abstract class AccountBase {
     oracleQueryId: Encoded.OracleQueryId,
     options?: {
       networkId?: string;
+      consensusProtocolVersion?: ConsensusProtocolVersion;
       aeppOrigin?: string;
       aeppRpcClientId?: string;
     },
@@ -183,4 +194,25 @@ export default abstract class AccountBase {
    * Account address
    */
   readonly address!: Encoded.AccountAddress;
+
+  /**
+   * Sign delegation, works only in Ceres
+   * @param delegation - Delegation to sign
+   * @param options - Options
+   * @returns Signature
+   */
+  // TODO: make abstract in the next major release
+  // eslint-disable-next-line class-methods-use-this
+  async signDelegation(
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    delegation: Encoded.Bytearray,
+    options?: {
+      networkId?: string;
+      aeppOrigin?: string;
+      aeppRpcClientId?: string;
+    },
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+  ): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signDelegation method');
+  }
 }
diff --git a/src/account/Generalized.ts b/src/account/Generalized.ts
index a8c7761fca..ff068d8cf1 100644
--- a/src/account/Generalized.ts
+++ b/src/account/Generalized.ts
@@ -63,6 +63,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 signDelegation(): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signing delegation using generalized account');
+  }
+
   override async signTransaction(
     tx: Encoded.Transaction,
     { authData, onCompiler, onNode }: Parameters<AccountBase['signTransaction']>[1],
diff --git a/src/account/Ledger.ts b/src/account/Ledger.ts
index 99f8e126e0..4175b8dd9e 100644
--- a/src/account/Ledger.ts
+++ b/src/account/Ledger.ts
@@ -65,6 +65,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 signDelegation(): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signing delegation using Ledger HW');
+  }
+
   override async signTransaction(
     tx: Encoded.Transaction,
     { innerTx, networkId }: { innerTx?: boolean; networkId?: string } = {},
diff --git a/src/account/Memory.ts b/src/account/Memory.ts
index b9879b3d10..ab15c3e3d1 100644
--- a/src/account/Memory.ts
+++ b/src/account/Memory.ts
@@ -1,6 +1,6 @@
 import AccountBase from './Base';
 import {
-  generateKeyPairFromSecret, sign, generateKeyPair, hash, messageToHash,
+  generateKeyPairFromSecret, sign, generateKeyPair, hash, messageToHash, messagePrefixLength,
 } from '../utils/crypto';
 import { ArgumentError } from '../utils/errors';
 import {
@@ -9,8 +9,10 @@ import {
 import { concatBuffers } from '../utils/other';
 import { hashTypedData, AciValue } from '../utils/typed-data';
 import { buildTx } from '../tx/builder';
-import { Tag, AensName } from '../tx/builder/constants';
+import { Tag, AensName, ConsensusProtocolVersion } from '../tx/builder/constants';
 import { produceNameId } from '../tx/builder/helpers';
+import { DelegationTag } from '../tx/builder/delegation/schema';
+import { packDelegation } from '../tx/builder/delegation';
 
 const secretKeys = new WeakMap();
 
@@ -93,8 +95,24 @@ export default class AccountMemory extends AccountBase {
 
   override async signDelegationToContract(
     contractAddress: Encoded.ContractAddress,
-    { networkId }: { networkId?: string } = {},
+    { networkId, consensusProtocolVersion, isOracle }: {
+      networkId?: string;
+      consensusProtocolVersion?: ConsensusProtocolVersion;
+      isOracle?: boolean;
+    } = {},
   ): Promise<Encoded.Signature> {
+    if (isOracle == null) {
+      const protocol = (consensusProtocolVersion != null) ? ConsensusProtocolVersion[consensusProtocolVersion] : 'unknown';
+      console.warn(`AccountMemory:signDelegationToContract: isOracle is not set. By default, sdk would generate an AENS preclaim delegation signature, but it won't be the same as the oracle delegation signature in Ceres (current protocol is ${protocol}).`);
+    }
+    if (consensusProtocolVersion === ConsensusProtocolVersion.Ceres) {
+      const delegation = packDelegation({
+        tag: isOracle === true ? DelegationTag.Oracle : DelegationTag.AensPreclaim,
+        accountAddress: this.address,
+        contractAddress,
+      });
+      return this.signDelegation(delegation, { networkId });
+    }
     if (networkId == null) throw new ArgumentError('networkId', 'provided', networkId);
     const payload = concatBuffers([
       Buffer.from(networkId),
@@ -108,8 +126,17 @@ export default class AccountMemory extends AccountBase {
   override async signNameDelegationToContract(
     contractAddress: Encoded.ContractAddress,
     name: AensName,
-    { networkId }: { networkId?: string } = {},
+    { networkId, consensusProtocolVersion }: {
+      networkId?: string;
+      consensusProtocolVersion?: ConsensusProtocolVersion;
+    } = {},
   ): Promise<Encoded.Signature> {
+    if (consensusProtocolVersion === ConsensusProtocolVersion.Ceres) {
+      const delegation = packDelegation({
+        tag: DelegationTag.AensName, accountAddress: this.address, contractAddress, nameId: name,
+      });
+      return this.signDelegation(delegation, { networkId });
+    }
     if (networkId == null) throw new ArgumentError('networkId', 'provided', networkId);
     const payload = concatBuffers([
       Buffer.from(networkId),
@@ -123,8 +150,17 @@ export default class AccountMemory extends AccountBase {
 
   override async signAllNamesDelegationToContract(
     contractAddress: Encoded.ContractAddress,
-    { networkId }: { networkId?: string } = {},
+    { networkId, consensusProtocolVersion }: {
+      networkId?: string;
+      consensusProtocolVersion?: ConsensusProtocolVersion;
+    } = {},
   ): Promise<Encoded.Signature> {
+    if (consensusProtocolVersion === ConsensusProtocolVersion.Ceres) {
+      const delegation = packDelegation({
+        tag: DelegationTag.AensWildcard, accountAddress: this.address, contractAddress,
+      });
+      return this.signDelegation(delegation, { networkId });
+    }
     if (networkId == null) throw new ArgumentError('networkId', 'provided', networkId);
     const payload = concatBuffers([
       Buffer.from(networkId),
@@ -139,8 +175,17 @@ export default class AccountMemory extends AccountBase {
   override async signOracleQueryDelegationToContract(
     contractAddress: Encoded.ContractAddress,
     oracleQueryId: Encoded.OracleQueryId,
-    { networkId }: { networkId?: string } = {},
+    { networkId, consensusProtocolVersion }: {
+      networkId?: string;
+      consensusProtocolVersion?: ConsensusProtocolVersion;
+    } = {},
   ): Promise<Encoded.Signature> {
+    if (consensusProtocolVersion === ConsensusProtocolVersion.Ceres) {
+      const delegation = packDelegation({
+        tag: DelegationTag.OracleResponse, queryId: oracleQueryId, contractAddress,
+      });
+      return this.signDelegation(delegation, { networkId });
+    }
     const oracleQueryIdDecoded = decode(oracleQueryId);
     const addressDecoded = decode(this.address);
     // TODO: remove after fixing https://github.com/aeternity/aesophia/issues/475
@@ -156,4 +201,16 @@ export default class AccountMemory extends AccountBase {
     const signature = await this.sign(payload);
     return encode(signature, Encoding.Signature);
   }
+
+  override async signDelegation(
+    delegation: Encoded.Bytearray,
+    { networkId }: { networkId?: string } = {},
+  ): Promise<Encoded.Signature> {
+    if (networkId == null) throw new ArgumentError('networkId', 'provided', networkId);
+    const payload = concatBuffers([
+      messagePrefixLength, new Uint8Array([1]), Buffer.from(networkId), decode(delegation),
+    ]);
+    const signature = await this.sign(payload);
+    return encode(signature, Encoding.Signature);
+  }
 }
diff --git a/src/account/Rpc.ts b/src/account/Rpc.ts
index 369c569fcb..1003d32c62 100644
--- a/src/account/Rpc.ts
+++ b/src/account/Rpc.ts
@@ -4,7 +4,9 @@ import { ArgumentError, NotImplementedError, UnsupportedProtocolError } from '..
 import { Encoded } from '../utils/encoder';
 import RpcClient from '../aepp-wallet-communication/rpc/RpcClient';
 import { AeppApi, WalletApi } from '../aepp-wallet-communication/rpc/types';
-import { AensName } from '../tx/builder/constants';
+import { AensName, ConsensusProtocolVersion } from '../tx/builder/constants';
+import { packDelegation } from '../tx/builder/delegation';
+import { DelegationTag } from '../tx/builder/delegation/schema';
 
 /**
  * Account provided by wallet
@@ -73,10 +75,27 @@ export default class AccountRpc extends AccountBase {
 
   override async signDelegationToContract(
     contractAddress: Encoded.ContractAddress,
+    { consensusProtocolVersion, isOracle }: {
+      consensusProtocolVersion?: ConsensusProtocolVersion;
+      isOracle?: boolean;
+    } = {},
   ): Promise<Encoded.Signature> {
+    if (isOracle == null) {
+      const protocol = (consensusProtocolVersion != null) ? ConsensusProtocolVersion[consensusProtocolVersion] : 'unknown';
+      console.warn(`AccountRpc:signDelegationToContract: isOracle is not set. By default, sdk would generate an AENS preclaim delegation signature, but it won't be the same as the oracle delegation signature in Ceres (current protocol is ${protocol}).`);
+    }
+    if (consensusProtocolVersion === ConsensusProtocolVersion.Ceres) {
+      const delegation = packDelegation({
+        tag: isOracle === true ? DelegationTag.Oracle : DelegationTag.AensPreclaim,
+        accountAddress: this.address,
+        contractAddress,
+      });
+      return this.signDelegation(delegation);
+    }
     const { signature } = await this._rpcClient.request(METHODS.signDelegationToContract, {
       onAccount: this.address,
       contractAddress,
+      isOracle,
     });
     return signature;
   }
@@ -84,7 +103,14 @@ export default class AccountRpc extends AccountBase {
   override async signNameDelegationToContract(
     contractAddress: Encoded.ContractAddress,
     name: AensName,
+    { consensusProtocolVersion }: { consensusProtocolVersion?: ConsensusProtocolVersion } = {},
   ): Promise<Encoded.Signature> {
+    if (consensusProtocolVersion === ConsensusProtocolVersion.Ceres) {
+      const delegation = packDelegation({
+        tag: DelegationTag.AensName, accountAddress: this.address, contractAddress, nameId: name,
+      });
+      return this.signDelegation(delegation);
+    }
     const { signature } = await this._rpcClient.request(METHODS.signDelegationToContract, {
       onAccount: this.address,
       contractAddress,
@@ -95,7 +121,14 @@ export default class AccountRpc extends AccountBase {
 
   override async signAllNamesDelegationToContract(
     contractAddress: Encoded.ContractAddress,
+    { consensusProtocolVersion }: { consensusProtocolVersion?: ConsensusProtocolVersion } = {},
   ): Promise<Encoded.Signature> {
+    if (consensusProtocolVersion === ConsensusProtocolVersion.Ceres) {
+      const delegation = packDelegation({
+        tag: DelegationTag.AensWildcard, accountAddress: this.address, contractAddress,
+      });
+      return this.signDelegation(delegation);
+    }
     const { signature } = await this._rpcClient.request(METHODS.signDelegationToContract, {
       onAccount: this.address,
       contractAddress,
@@ -107,7 +140,14 @@ export default class AccountRpc extends AccountBase {
   override async signOracleQueryDelegationToContract(
     contractAddress: Encoded.ContractAddress,
     oracleQueryId: Encoded.OracleQueryId,
+    { consensusProtocolVersion }: { consensusProtocolVersion?: ConsensusProtocolVersion } = {},
   ): Promise<Encoded.Signature> {
+    if (consensusProtocolVersion === ConsensusProtocolVersion.Ceres) {
+      const delegation = packDelegation({
+        tag: DelegationTag.OracleResponse, queryId: oracleQueryId, contractAddress,
+      });
+      return this.signDelegation(delegation);
+    }
     const { signature } = await this._rpcClient.request(METHODS.signDelegationToContract, {
       onAccount: this.address,
       contractAddress,
@@ -115,4 +155,12 @@ export default class AccountRpc extends AccountBase {
     });
     return signature;
   }
+
+  override async signDelegation(delegation: Encoded.Bytearray): Promise<Encoded.Signature> {
+    const { signature } = await this._rpcClient.request(
+      METHODS.signDelegation,
+      { delegation, onAccount: this.address },
+    );
+    return signature;
+  }
 }
diff --git a/src/aepp-wallet-communication/rpc/types.ts b/src/aepp-wallet-communication/rpc/types.ts
index 3e40517ecd..fa6de15586 100644
--- a/src/aepp-wallet-communication/rpc/types.ts
+++ b/src/aepp-wallet-communication/rpc/types.ts
@@ -90,6 +90,14 @@ export interface WalletApi {
       name?: AensName;
       oracleQueryId?: Encoded.OracleQueryId;
       allNames?: boolean;
+      isOracle?: boolean;
+      onAccount: Encoded.AccountAddress;
+    },
+  ) => Promise<{ signature: Encoded.Signature }>;
+
+  [METHODS.signDelegation]: (
+    p: {
+      delegation: Encoded.Bytearray;
       onAccount: Encoded.AccountAddress;
     },
   ) => Promise<{ signature: Encoded.Signature }>;
diff --git a/src/aepp-wallet-communication/schema.ts b/src/aepp-wallet-communication/schema.ts
index 71fb3e8b66..ad9056a14a 100644
--- a/src/aepp-wallet-communication/schema.ts
+++ b/src/aepp-wallet-communication/schema.ts
@@ -38,6 +38,7 @@ export const enum METHODS {
   signMessage = 'message.sign',
   signTypedData = 'typedData.sign',
   signDelegationToContract = 'delegationToContract.sign',
+  signDelegation = 'delegation.sign',
   subscribeAddress = 'address.subscribe',
   updateNetwork = 'networkId.update',
   closeConnection = 'connection.close',
diff --git a/src/contract/delegation-signature.ts b/src/contract/delegation-signature.ts
index ad001a00a0..a05c36e819 100644
--- a/src/contract/delegation-signature.ts
+++ b/src/contract/delegation-signature.ts
@@ -47,19 +47,25 @@ function ensureOracleQuery(oq: string): asserts oq is Encoded.OracleQueryId {
 export default async function createDelegationSignature(
   contractAddress: Encoded.ContractAddress,
   ids: Array<Encoded.Any | AensName>,
-  { onAccount, omitAddress, ...options }: {
+  {
+    onAccount, omitAddress, isOracle, ...options
+  }: {
     omitAddress?: boolean;
     onAccount: AccountBase;
+    isOracle?: boolean;
     onNode: Node;
   },
 ): Promise<Uint8Array> {
   if (ids.length > 1) throw new ArgumentError('ids', 'shorter than 2', ids);
-  const networkId = await options.onNode.getNetworkId();
+  const { nodeNetworkId, consensusProtocolVersion } = await options.onNode.getNodeInfo();
+  const signOpts = { networkId: nodeNetworkId, consensusProtocolVersion };
   if (ids.length === 0) {
     if (omitAddress === true) {
       throw new ArgumentError('omitAddress', 'equal false', omitAddress);
     }
-    return decode(await onAccount.signDelegationToContract(contractAddress, { networkId }));
+    return decode(
+      await onAccount.signDelegationToContract(contractAddress, { ...signOpts, isOracle }),
+    );
   }
 
   const [payload] = ids;
@@ -68,7 +74,7 @@ export default async function createDelegationSignature(
       throw new ArgumentError('omitAddress', 'equal false', omitAddress);
     }
     return decode(
-      await onAccount.signNameDelegationToContract(contractAddress, payload, { networkId }),
+      await onAccount.signNameDelegationToContract(contractAddress, payload, signOpts),
     );
   }
 
@@ -77,6 +83,6 @@ export default async function createDelegationSignature(
     throw new ArgumentError('omitAddress', 'equal true', omitAddress);
   }
   return decode(
-    await onAccount.signOracleQueryDelegationToContract(contractAddress, payload, { networkId }),
+    await onAccount.signOracleQueryDelegationToContract(contractAddress, payload, signOpts),
   );
 }
diff --git a/src/index-browser.ts b/src/index-browser.ts
index 9794d54303..2c4cbc30cf 100644
--- a/src/index-browser.ts
+++ b/src/index-browser.ts
@@ -27,6 +27,8 @@ export {
 export type { Int, AensName } from './tx/builder/constants';
 // TODO: move to constants
 export { ORACLE_TTL_TYPES, DRY_RUN_ACCOUNT, CallReturnType } from './tx/builder/schema';
+export { DelegationTag } from './tx/builder/delegation/schema';
+export { packDelegation, unpackDelegation } from './tx/builder/delegation';
 export {
   getExecutionCost, getExecutionCostBySignedTx, getExecutionCostUsingNode,
 } from './tx/execution-cost';
diff --git a/src/tx/builder/common.ts b/src/tx/builder/common.ts
new file mode 100644
index 0000000000..162bb09e2c
--- /dev/null
+++ b/src/tx/builder/common.ts
@@ -0,0 +1,68 @@
+import { decode as rlpDecode, encode as rlpEncode } from 'rlp';
+import { Field, BinaryData } from './field-types';
+import { ArgumentError, DecodeError, SchemaNotFoundError } from '../../utils/errors';
+import {
+  Encoding, Encoded, encode, decode,
+} from '../../utils/encoder';
+import { readInt } from './helpers';
+
+type Schemas = ReadonlyArray<{
+  tag: { constValue: number } & Field;
+  version: { constValue: number } & Field;
+}>;
+
+export function getSchema(
+  schemas: Schemas,
+  Tag: { [key: number]: string },
+  tag: number,
+  version: number | undefined,
+): Array<[string, Field]> {
+  const subSchemas = schemas.filter((s) => s.tag.constValue === tag);
+  if (subSchemas.length === 0) throw new SchemaNotFoundError(`${Tag[tag]} (${tag})`, 0);
+  version ??= Math.max(...subSchemas.map((s) => s.version.constValue));
+  const schema = subSchemas.find((s) => s.version.constValue === version);
+  if (schema == null) throw new SchemaNotFoundError(`${Tag[tag]} (${tag})`, version);
+  return Object.entries(schema);
+}
+
+export function packRecord<E extends Encoding>(
+  schemas: Schemas,
+  Tag: { [key: number]: string },
+  params: {
+    tag: number;
+    version?: number;
+    [k: string]: unknown;
+  },
+  extraParams: { [k: string]: unknown },
+  encoding: E,
+): Encoded.Generic<E> {
+  const schema = getSchema(schemas, Tag, params.tag, params.version);
+  const binary = schema.map(([key, field]) => (
+    field.serialize(params[key], { ...params, ...extraParams }, params)
+  ));
+  return encode(rlpEncode(binary), encoding);
+}
+
+export function unpackRecord(
+  schemas: Schemas,
+  Tag: { [key: number]: string },
+  encodedRecord: Encoded.Any,
+  expectedTag: number | undefined,
+  extraParams: { [k: string]: unknown },
+): unknown {
+  const binary = rlpDecode(decode(encodedRecord));
+  const tag = +readInt(binary[0] as Buffer);
+  const version = +readInt(binary[1] as Buffer);
+  const schema = getSchema(schemas, Tag, tag, version);
+  if (expectedTag != null && expectedTag !== tag) {
+    throw new DecodeError(`Expected ${Tag[expectedTag]} tag, got ${Tag[tag]} instead`);
+  }
+  if (binary.length !== schema.length) {
+    throw new ArgumentError('RLP length', schema.length, binary.length);
+  }
+  return Object.fromEntries(
+    schema.map(([name, field], index) => [
+      name, field.deserialize(binary[index] as BinaryData, extraParams),
+    ]),
+  );
+}
diff --git a/src/tx/builder/delegation/index.ts b/src/tx/builder/delegation/index.ts
new file mode 100644
index 0000000000..bab7010342
--- /dev/null
+++ b/src/tx/builder/delegation/index.ts
@@ -0,0 +1,28 @@
+import { Encoded, Encoding } from '../../../utils/encoder';
+import { packRecord, unpackRecord } from '../common';
+import { DelegationTag, schemas } from './schema';
+import { DlgParams, DlgUnpacked } from './schema.generated';
+
+/**
+ * Pack delegation
+ * @category delegation signature
+ * @param params - Params of delegation
+ * @returns Encoded delegation
+ */
+export function packDelegation(params: DlgParams): Encoded.Bytearray {
+  return packRecord(schemas, DelegationTag, params, {}, Encoding.Bytearray);
+}
+
+/**
+ * Unpack delegation
+ * @category delegation signature
+ * @param encoded - Encoded delegation
+ * @param expectedTag - Expected delegation signature type
+ * @returns Params of delegation
+ */
+export function unpackDelegation<T extends DelegationTag>(
+  encoded: Encoded.Bytearray,
+  expectedTag?: T,
+): DlgUnpacked & { tag: T } {
+  return unpackRecord(schemas, DelegationTag, encoded, expectedTag, {}) as any;
+}
diff --git a/src/tx/builder/delegation/schema.ts b/src/tx/builder/delegation/schema.ts
new file mode 100644
index 0000000000..3171264cf4
--- /dev/null
+++ b/src/tx/builder/delegation/schema.ts
@@ -0,0 +1,61 @@
+import SchemaTypes from '../SchemaTypes';
+import { address, nameId, shortUIntConst } from '../field-types';
+import {
+  Encoded, Encoding, decode, encode,
+} from '../../../utils/encoder';
+
+/**
+ * @category delegation signature
+ */
+export enum DelegationTag {
+  AensWildcard = 1,
+  AensName = 2,
+  AensPreclaim = 3,
+  Oracle = 4,
+  OracleResponse = 5,
+}
+
+const oracleAddressField = address(Encoding.OracleAddress);
+const queryIdField = {
+  serialize(value: Encoded.OracleQueryId): Buffer {
+    return oracleAddressField.serialize(encode(decode(value), Encoding.OracleAddress));
+  },
+  deserialize(value: Buffer): Encoded.OracleQueryId {
+    return encode(decode(oracleAddressField.deserialize(value)), Encoding.OracleQueryId);
+  },
+} as const;
+
+/**
+ * @see {@link https://github.com/aeternity/protocol/blob/8a9d1d1206174627f6aaef86159dc9c643080653/contracts/fate.md#from-ceres-serialized-signature-data}
+ */
+export const schemas = [{
+  tag: shortUIntConst(DelegationTag.AensWildcard),
+  version: shortUIntConst(1, true),
+  accountAddress: address(Encoding.AccountAddress),
+  contractAddress: address(Encoding.ContractAddress),
+}, {
+  tag: shortUIntConst(DelegationTag.AensName),
+  version: shortUIntConst(1, true),
+  accountAddress: address(Encoding.AccountAddress),
+  nameId,
+  contractAddress: address(Encoding.ContractAddress),
+}, {
+  tag: shortUIntConst(DelegationTag.AensPreclaim),
+  version: shortUIntConst(1, true),
+  accountAddress: address(Encoding.AccountAddress),
+  contractAddress: address(Encoding.ContractAddress),
+}, {
+  tag: shortUIntConst(DelegationTag.Oracle),
+  version: shortUIntConst(1, true),
+  accountAddress: address(Encoding.AccountAddress),
+  contractAddress: address(Encoding.ContractAddress),
+}, {
+  tag: shortUIntConst(DelegationTag.OracleResponse),
+  version: shortUIntConst(1, true),
+  queryId: queryIdField,
+  contractAddress: address(Encoding.ContractAddress),
+}] as const;
+
+type Schemas = SchemaTypes<typeof schemas>;
+export type DlgParams = Schemas['TxParams'];
+export type DlgUnpacked = Schemas['TxUnpacked'];
diff --git a/src/tx/builder/index.ts b/src/tx/builder/index.ts
index 20754cd461..3a03322f4f 100644
--- a/src/tx/builder/index.ts
+++ b/src/tx/builder/index.ts
@@ -1,71 +1,61 @@
-import { decode as rlpDecode, encode as rlpEncode } from 'rlp';
 import {
   decode, encode, Encoded, Encoding,
 } from '../../utils/encoder';
 import { hash } from '../../utils/crypto';
-import { BinaryData, Field } from './field-types';
+import { Field } from './field-types';
 import { txSchema } from './schema';
 import { TxUnpacked, TxParams, TxParamsAsync } from './schema.generated';
 import { Tag } from './constants';
-import { buildContractId, readInt } from './helpers';
-import { ArgumentError, DecodeError, SchemaNotFoundError } from '../../utils/errors';
+import { buildContractId } from './helpers';
+import { getSchema as getSchemaCommon, packRecord, unpackRecord } from './common';
+import { ArgumentError } from '../../utils/errors';
 
 /**
  * JavaScript-based Transaction builder
  */
 
 export function getSchema(tag: Tag, version?: number): Array<[string, Field]> {
-  const schemas = txSchema.filter((s) => s.tag.constValue === tag);
-  if (schemas.length === 0) throw new SchemaNotFoundError(`${Tag[tag]} (${tag})`, 0);
-  version ??= Math.max(...schemas.map((schema) => schema.version.constValue));
-  const schema = schemas.find((s) => s.version.constValue === version);
-  if (schema == null) throw new SchemaNotFoundError(`${Tag[tag]} (${tag})`, version);
-  return Object.entries(schema);
+  return getSchemaCommon(txSchema, Tag, tag, version);
 }
 
 type TxEncoding = Encoding.Transaction | Encoding.Poi | Encoding.StateTrees
 | Encoding.CallStateTree;
 
 /**
- * Build transaction hash
+ * Build transaction
  * @category transaction builder
- * @param params - Object with tx params
+ * @param params - Transaction params
  * @param options - options
- * @param options.prefix - Prefix of transaction
- * @returns object Base64Check transaction hash with 'tx_' prefix
+ * @param options.prefix - Output encoding
+ * @returns Encoded transaction
  */
-export function buildTx<E extends TxEncoding = Encoding.Transaction>(
+export function buildTx(params: TxParams): Encoded.Transaction;
+export function buildTx<E extends TxEncoding>(
   params: TxParams,
-  { prefix }: { prefix?: E } = {},
-): Encoded.Generic<E> {
-  const schema = getSchema(params.tag, params.version);
-
-  const binary = schema.map(([key, field]) => (
-    field.serialize(
-      // @ts-expect-error the type of `params[key]` can't be determined accurately
-      params[key],
-      {
-        ...params,
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        unpackTx,
-        buildTx,
-        rebuildTx: (overrideParams: any) => buildTx(
-          { ...params, ...overrideParams },
-        ),
-      },
-      params,
-    )
-  ));
-
-  // @ts-expect-error looks like a TypeScript edge case
-  return encode(rlpEncode(binary), prefix ?? Encoding.Transaction);
+  { prefix }: { prefix: E },
+): Encoded.Generic<E>;
+export function buildTx(
+  params: TxParams,
+  { prefix }: { prefix?: TxEncoding } = {},
+): Encoded.Generic<TxEncoding> {
+  return packRecord(txSchema, Tag, params, {
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    unpackTx,
+    buildTx,
+    rebuildTx: (overrideParams: any) => buildTx(
+      { ...params, ...overrideParams },
+    ),
+  }, prefix ?? Encoding.Transaction);
 }
 
 export type BuildTxOptions <TxType extends Tag, OmitFields extends string> =
   Omit<TxParamsAsync & { tag: TxType }, 'tag' | OmitFields>;
 
 /**
+ * Build transaction async (may request node for additional data)
  * @category transaction builder
+ * @param params - Transaction params
+ * @returns tx_-encoded transaction
  */
 export async function buildTxAsync(params: TxParamsAsync): Promise<Encoded.Transaction> {
   await Promise.all(
@@ -84,30 +74,18 @@ export async function buildTxAsync(params: TxParamsAsync): Promise<Encoded.Trans
 /**
  * Unpack transaction encoded as string
  * @category transaction builder
- * @param encodedTx - Transaction to unpack
+ * @param encodedTx - Encoded transaction
  * @param txType - Expected transaction type
- * @returns Object with transaction param's
+ * @returns Transaction params
  */
 export function unpackTx<TxType extends Tag>(
   encodedTx: Encoded.Generic<TxEncoding>,
   txType?: TxType,
 ): TxUnpacked & { tag: TxType } {
-  const binary = rlpDecode(decode(encodedTx));
-  const tag = +readInt(binary[0] as Buffer);
-  const version = +readInt(binary[1] as Buffer);
-  const schema = getSchema(tag, version);
-  if (txType != null && txType !== tag) throw new DecodeError(`Expected transaction to have ${Tag[txType]} tag, got ${Tag[tag]} instead`);
-  if (binary.length !== schema.length) {
-    throw new ArgumentError('Transaction RLP length', schema.length, binary.length);
-  }
-  return schema.reduce<any>(
-    (acc, [name, field], index) => {
-      // eslint-disable-next-line @typescript-eslint/no-use-before-define
-      const deserialized = field.deserialize(binary[index] as BinaryData, { unpackTx });
-      return { ...acc, [name]: deserialized };
-    },
-    {},
-  ) as any;
+  return unpackRecord(txSchema, Tag, encodedTx, txType, {
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    unpackTx,
+  }) as any;
 }
 
 /**
diff --git a/test/integration/contract.ts b/test/integration/contract.ts
index e5705339a7..b66cb61bf8 100644
--- a/test/integration/contract.ts
+++ b/test/integration/contract.ts
@@ -286,11 +286,18 @@ describe('Contract', () => {
     });
   });
 
+  let isIris: boolean;
+  before(async () => {
+    isIris = (await aeSdk.api.getNodeInfo())
+      .consensusProtocolVersion === ConsensusProtocolVersion.Iris;
+  });
+
   describe('AENS operation delegation', () => {
     const name = randomName(15);
     const salt = genSalt();
     let owner: Encoded.AccountAddress;
     let newOwner: Encoded.AccountAddress;
+    // TODO: replace with Encoded.Signature after solving https://github.com/aeternity/aepp-calldata-js/issues/240
     let delegationSignature: Uint8Array;
     let contract: Contract<{
       getName: (name: string) => {
@@ -325,11 +332,8 @@ describe('Contract', () => {
     }>;
     let contractAddress: Encoded.ContractAddress;
     let aens: string;
-    let isIris: boolean;
 
     before(async () => {
-      isIris = (await aeSdk.api.getNodeInfo())
-        .consensusProtocolVersion === ConsensusProtocolVersion.Iris;
       aens = isIris ? 'AENS' : 'AENSv2';
       contract = await aeSdk.initializeContract({
         sourceCode: `
@@ -366,7 +370,8 @@ contract DelegateTest =
       const commitmentId = commitmentHash(name, salt);
       // TODO: provide more convenient way to create the decoded commitmentId ?
       const commitmentIdDecoded = decode(commitmentId);
-      const preclaimSig = await aeSdk.createDelegationSignature(contractAddress, []);
+      const preclaimSig = await aeSdk
+        .createDelegationSignature(contractAddress, [], { isOracle: false });
       const { result } = await contract.signedPreclaim(owner, commitmentIdDecoded, preclaimSig);
       assertNotNull(result);
       result.returnType.should.be.equal('ok');
@@ -449,6 +454,15 @@ contract DelegateTest =
 
       await contract.signedRevoke(owner, n, allNamesDelSig);
     });
+
+    it('claims without preclaim', async () => {
+      const n = randomName(15);
+      const nameFee = 20e18;
+      const dlgSig = await aeSdk.createDelegationSignature(contractAddress, [n]);
+      const { result } = await contract.signedClaim(aeSdk.address, n, 0, nameFee, dlgSig);
+      assertNotNull(result);
+      result.returnType.should.be.equal('ok');
+    });
   });
 
   describe('Oracle operation delegation', () => {
@@ -501,7 +515,8 @@ contract DelegateTest =
     });
 
     it('registers', async () => {
-      delegationSignature = await aeSdk.createDelegationSignature(contractAddress, []);
+      delegationSignature = await aeSdk
+        .createDelegationSignature(contractAddress, [], { isOracle: true });
       const { result } = await contract
         .signedRegisterOracle(aeSdk.address, delegationSignature, queryFee, ttl);
       assertNotNull(result);
@@ -546,6 +561,7 @@ contract DelegateTest =
     });
 
     it('fails trying to create general delegation as oracle query', async () => {
+      if (!isIris) return;
       const fakeQueryId = encode(decode(aeSdk.address), Encoding.OracleQueryId);
       await expect(
         aeSdk.createDelegationSignature(contractAddress, [fakeQueryId], { omitAddress: true }),
diff --git a/test/integration/rpc.ts b/test/integration/rpc.ts
index bd3be729e1..de09f92c87 100644
--- a/test/integration/rpc.ts
+++ b/test/integration/rpc.ts
@@ -441,33 +441,43 @@ describe('Aepp<->Wallet', function aeppWallet() {
 
       it('rejected by wallet', async () => {
         let origin;
+        wallet._resolveAccount().signDelegation = (delegation, { aeppOrigin } = {}) => {
+          origin = aeppOrigin;
+          throw new RpcRejectedByUserError();
+        };
         wallet._resolveAccount().signDelegationToContract = (contractAddr, { aeppOrigin } = {}) => {
           origin = aeppOrigin;
           throw new RpcRejectedByUserError();
         };
-        await expect(aepp.signDelegationToContract(contractAddress)).to.be.eventually
-          .rejectedWith('Operation rejected by user').with.property('code', 4);
+        await expect(aepp.signDelegationToContract(contractAddress, { isOracle: false }))
+          .to.be.eventually.rejectedWith('Operation rejected by user').with.property('code', 4);
         expect(origin).to.be.equal('http://origin.test');
       });
 
       it('works', async () => {
+        // @ts-expect-error removes object property to restore the original behavior
+        delete wallet._resolveAccount().signDelegation;
         // @ts-expect-error removes object property to restore the original behavior
         delete wallet._resolveAccount().signDelegationToContract;
-        const signature = await aepp.signDelegationToContract(contractAddress);
+        const signature = await aepp.signDelegationToContract(contractAddress, { isOracle: false });
         expect(signature).to.satisfy((s: string) => s.startsWith('sg_'));
       });
 
       it('fails with unknown error', async () => {
+        wallet._resolveAccount().signDelegation = () => {
+          throw new Error('test');
+        };
         wallet._resolveAccount().signDelegationToContract = () => {
           throw new Error('test');
         };
-        await expect(aepp.signDelegationToContract(contractAddress))
+        await expect(aepp.signDelegationToContract(contractAddress, { isOracle: false }))
           .to.be.rejectedWith('The peer failed to execute your request due to unknown error');
       });
 
       it('signs using specific account', async () => {
         const onAccount = wallet.addresses()[1];
-        const signature = await aepp.signDelegationToContract(contractAddress, { onAccount });
+        const signature = await aepp
+          .signDelegationToContract(contractAddress, { onAccount, isOracle: false });
         expect(signature).to.satisfy((s: string) => s.startsWith('sg_'));
       });
     });
diff --git a/test/unit/delegation.ts b/test/unit/delegation.ts
new file mode 100644
index 0000000000..16b726c5dc
--- /dev/null
+++ b/test/unit/delegation.ts
@@ -0,0 +1,71 @@
+import { describe, it } from 'mocha';
+import { expect } from 'chai';
+import {
+  Encoded, DelegationTag, packDelegation, unpackDelegation, MemoryAccount, DecodeError,
+} from '../../src';
+
+const accountAddress = 'ak_i9svRuk9SJfAponRnCYVnVWN9HVLdBEd8ZdGREJMaUiTn4S4D';
+const contractAddress = 'ct_i9svRuk9SJfAponRnCYVnVWN9HVLdBEd8ZdGREJMaUiTn4S4D';
+const queryId = 'oq_i9svRuk9SJfAponRnCYVnVWN9HVLdBEd8ZdGREJMaUiTn4S4D';
+
+describe('Delegation signatures', () => {
+  const delegation = 'ba_+EYDAaEBXXFtZp9YqbY4KdW8Nolf9Hjp0VZcNWnQOKjgCb8Br9mhBV1xbWafWKm2OCnVvDaJX/R46dFWXDVp0Dio4Am/Aa/Z2vgCEQ==';
+
+  it('packs and unpacks delegation', () => {
+    const params = { tag: DelegationTag.AensPreclaim, accountAddress, contractAddress } as const;
+    expect(packDelegation(params)).to.equal(delegation);
+    expect(unpackDelegation(delegation)).to.eql({ ...params, version: 1 });
+  });
+
+  it('signs delegation', async () => {
+    const account = new MemoryAccount('9ebd7beda0c79af72a42ece3821a56eff16359b6df376cf049aee995565f022f840c974b97164776454ba119d84edc4d6058a8dec92b6edc578ab2d30b4c4200');
+    expect(await account.signDelegation(delegation, { networkId: 'ae_test' }))
+      .to.be.equal('sg_UHnWENCvSvJPjcwR2rW82btPvDoDqPvDnn8TsXkoQSNoMHEeT1D8YkAwJQQNrALTBdqqFou4X4Q2MoqCXzwnQZTDZvH28');
+  });
+
+  it('packs and unpacks aens name delegation', () => {
+    const d = 'ba_+GgCAaEBXXFtZp9YqbY4KdW8Nolf9Hjp0VZcNWnQOKjgCb8Br9mhAlCYygTo5mrGvATbkThUR6EXecvfzfsug8dFPZFieKO3oQVdcW1mn1iptjgp1bw2iV/0eOnRVlw1adA4qOAJvwGv2bOkQT8=';
+    const params = { tag: DelegationTag.AensName, accountAddress, contractAddress } as const;
+    expect(packDelegation({ ...params, nameId: 'test.chain' })).to.equal(d);
+    expect(unpackDelegation(d)).to.eql({
+      ...params, nameId: 'nm_cVjoMBVH5UAthDx8hEijr5dF21yex6itrxbZZUMaftL941g9G', version: 1,
+    });
+  });
+
+  it('packs and unpacks oracle response delegation', () => {
+    const d = 'ba_+EYFAaEEXXFtZp9YqbY4KdW8Nolf9Hjp0VZcNWnQOKjgCb8Br9mhBV1xbWafWKm2OCnVvDaJX/R46dFWXDVp0Dio4Am/Aa/ZQ3BGAA==';
+    const params = { tag: DelegationTag.OracleResponse, queryId, contractAddress } as const;
+    expect(packDelegation(params)).to.equal(d);
+    expect(unpackDelegation(d)).to.eql({ ...params, version: 1 });
+  });
+
+  it('unpacks delegation with correct types', () => {
+    const params = unpackDelegation(delegation);
+    expect(params.tag);
+    expect(params.version);
+    if (params.tag === DelegationTag.AensWildcard) {
+      expect(params.accountAddress);
+      // @ts-expect-error AensWildcard don't have nameId
+      expect(params.nameId);
+      const addr: Encoded.AccountAddress = params.accountAddress;
+      expect(addr);
+    }
+    if (params.tag === DelegationTag.OracleResponse) {
+      expect(params.queryId);
+    }
+  });
+
+  it('fails if unexpected delegation tag', () => {
+    expect(() => unpackDelegation(delegation, DelegationTag.Oracle))
+      .to.throw(DecodeError, 'Expected Oracle tag, got AensPreclaim instead');
+  });
+
+  it('checks packing parameters', () => {
+    // @ts-expect-error AensPreclaim don't have nameId
+    expect(() => packDelegation({ tag: DelegationTag.AensPreclaim, nameId: 'test.chain' }))
+      .to.throw();
+    // @ts-expect-error requires contractAddress
+    expect(() => packDelegation({ tag: DelegationTag.AensPreclaim, accountAddress }))
+      .to.throw();
+  });
+});
diff --git a/test/unit/tx.ts b/test/unit/tx.ts
index a669bb71a9..5e5c88a36b 100644
--- a/test/unit/tx.ts
+++ b/test/unit/tx.ts
@@ -101,7 +101,7 @@ describe('Tx', () => {
 
     it('fails to unpack tx with more RLP items than in schema', () => {
       expect(() => unpackTx('tx_+GIMAaEB4TK48d23oE5jt/qWR5pUu8UlpTGn8bwM5JISGQMGf7ChAeEyuPHdt6BOY7f6lkeaVLvFJaUxp/G8DOSSEhkDBn+wiBvBbWdOyAAAhg92HvYQAAABhHRlc3SEdGVzdK2Ldck='))
-        .to.throw(ArgumentError, 'Transaction RLP length should be 9, got 10 instead');
+        .to.throw(ArgumentError, 'RLP length should be 9, got 10 instead');
     });
 
     it('unpacks unknown transaction', () => {
diff --git a/tooling/generate-schema.ts b/tooling/generate-schema.ts
index b4c0a47a9e..30c650b1a0 100755
--- a/tooling/generate-schema.ts
+++ b/tooling/generate-schema.ts
@@ -3,159 +3,170 @@ import { writeFileSync } from 'fs';
 import { basename } from 'path';
 import ts, { factory, IntersectionTypeNode, TypeNode } from 'typescript';
 import { txSchema } from '../src/tx/builder/schema';
-import { Tag } from '../src/tx/builder/constants';
+import { Tag as TxTag } from '../src/tx/builder/constants';
+import { DelegationTag, schemas as delegationSchema } from '../src/tx/builder/delegation/schema';
 
-const destPath = 'src/tx/builder/schema.generated.ts';
+function generate(isDelegation: boolean): void {
+  const prefix = isDelegation ? 'Dlg' : 'Tx';
+  const destPath = `src/tx/builder/${isDelegation ? 'delegation/' : ''}schema.generated.ts`;
+  const [Tag, schemas] = isDelegation ? [DelegationTag, delegationSchema] : [TxTag, txSchema];
+  const typesToGenerate = ['Params', ...isDelegation ? [] : ['ParamsAsync'], 'Unpacked'];
 
-const sourceFile = ts.createSourceFile(basename(destPath), '', ts.ScriptTarget.Latest);
+  const sourceFile = ts.createSourceFile(basename(destPath), '', ts.ScriptTarget.Latest);
 
-function addTsDocCategory<T extends ts.Node>(node: T): T {
-  return ts.addSyntheticLeadingComment(
-    node,
-    ts.SyntaxKind.MultiLineCommentTrivia,
-    '*\n * @category transaction builder\n ',
-    true,
-  );
-}
+  function addTsDocCategory<T extends ts.Node>(node: T): T {
+    return ts.addSyntheticLeadingComment(
+      node,
+      ts.SyntaxKind.MultiLineCommentTrivia,
+      `*\n * @category ${isDelegation ? 'delegation signature' : 'transaction builder'}\n `,
+      true,
+    );
+  }
 
-// workaround to fix "An interface can only extend an object type or intersection of object types
-// with statically known members." while building test/environment/typescript (uses ts decl files)
-// TODO: figure out why union is not converted to a single item it case of Tag.Account v2 and v1
-function reAddVersion(node: TypeNode, version: number): IntersectionTypeNode {
-  return factory.createIntersectionTypeNode([
-    factory.createTypeReferenceNode(
-      factory.createIdentifier('Omit'),
-      [
-        node,
-        factory.createLiteralTypeNode(factory.createStringLiteral('version')),
-      ],
-    ),
-    factory.createTypeLiteralNode([factory.createPropertySignature(
-      undefined,
-      factory.createIdentifier('version'),
-      factory.createToken(ts.SyntaxKind.QuestionToken),
-      factory.createLiteralTypeNode(factory.createNumericLiteral(version)),
-    )]),
-  ]);
-}
+  // workaround to fix "An interface can only extend an object type or intersection of object types
+  // with statically known members." while building test/environment/typescript (uses ts decl files)
+  // TODO: figure out why union is not converted to a single item it case of Tag.Account v2 and v1
+  function reAddVersion(node: TypeNode, version: number): IntersectionTypeNode {
+    return factory.createIntersectionTypeNode([
+      factory.createTypeReferenceNode(
+        factory.createIdentifier('Omit'),
+        [
+          node,
+          factory.createLiteralTypeNode(factory.createStringLiteral('version')),
+        ],
+      ),
+      factory.createTypeLiteralNode([factory.createPropertySignature(
+        undefined,
+        factory.createIdentifier('version'),
+        factory.createToken(ts.SyntaxKind.QuestionToken),
+        factory.createLiteralTypeNode(factory.createNumericLiteral(version)),
+      )]),
+    ]);
+  }
 
-const list = factory.createNodeArray([
-  factory.createImportDeclaration(
-    undefined,
-    factory.createImportClause(
-      false,
+  const list = factory.createNodeArray([
+    factory.createImportDeclaration(
+      undefined,
+      factory.createImportClause(
+        false,
+        undefined,
+        factory.createNamedImports([
+          factory.createImportSpecifier(
+            false,
+            factory.createIdentifier(`${prefix}Params`),
+            factory.createIdentifier(`${prefix}ParamsComplex`),
+          ),
+          ...isDelegation ? [] : [
+            factory.createImportSpecifier(
+              false,
+              factory.createIdentifier('TxParamsAsync'),
+              factory.createIdentifier('TxParamsAsyncComplex'),
+            ),
+          ],
+          factory.createImportSpecifier(
+            false,
+            factory.createIdentifier(`${prefix}Unpacked`),
+            factory.createIdentifier(`${prefix}UnpackedComplex`),
+          ),
+        ]),
+      ),
+      factory.createStringLiteral('./schema'),
       undefined,
-      factory.createNamedImports([
-        factory.createImportSpecifier(
-          false,
-          factory.createIdentifier('TxParams'),
-          factory.createIdentifier('TxParamsComplex'),
-        ),
-        factory.createImportSpecifier(
-          false,
-          factory.createIdentifier('TxParamsAsync'),
-          factory.createIdentifier('TxParamsAsyncComplex'),
-        ),
-        factory.createImportSpecifier(
-          false,
-          factory.createIdentifier('TxUnpacked'),
-          factory.createIdentifier('TxUnpackedComplex'),
-        ),
-      ]),
     ),
-    factory.createStringLiteral('./schema'),
-    undefined,
-  ),
-  factory.createImportDeclaration(
-    undefined,
-    factory.createImportClause(
-      false,
+    factory.createImportDeclaration(
       undefined,
-      factory.createNamedImports([factory.createImportSpecifier(
+      factory.createImportClause(
         false,
         undefined,
-        factory.createIdentifier('Tag'),
-      )]),
+        factory.createNamedImports([factory.createImportSpecifier(
+          false,
+          isDelegation ? factory.createIdentifier('DelegationTag') : undefined,
+          factory.createIdentifier('Tag'),
+        )]),
+      ),
+      factory.createStringLiteral(isDelegation ? './schema' : './constants'),
+      undefined,
     ),
-    factory.createStringLiteral('./constants'),
-    undefined,
-  ),
-  ...txSchema.map((schema) => {
-    const tag = Tag[schema.tag.constValue];
-    const version = schema.version.constValue;
-    const name = `${tag}${version}`;
-    return ['TxParams', 'TxParamsAsync', 'TxUnpacked'].map((kind) => {
-      const isVersionOptional = schema.version.constValueOptional && kind !== 'TxUnpacked';
-      const innerType = factory.createIntersectionTypeNode([
-        factory.createTypeReferenceNode(
-          factory.createIdentifier(`${kind}Complex`),
-          undefined,
-        ),
-        factory.createTypeLiteralNode([
-          factory.createPropertySignature(
-            undefined,
-            factory.createIdentifier('tag'),
+    ...schemas.map((schema) => {
+      const tag = Tag[schema.tag.constValue];
+      const version = schema.version.constValue;
+      const name = `${tag}${version}`;
+      return typesToGenerate.map((kind) => {
+        const isVersionOptional = schema.version.constValueOptional && kind !== 'Unpacked';
+        const innerType = factory.createIntersectionTypeNode([
+          factory.createTypeReferenceNode(
+            factory.createIdentifier(`${prefix}${kind}Complex`),
             undefined,
-            factory.createTypeReferenceNode(
-              factory.createQualifiedName(
-                factory.createIdentifier('Tag'),
-                factory.createIdentifier(tag),
+          ),
+          factory.createTypeLiteralNode([
+            factory.createPropertySignature(
+              undefined,
+              factory.createIdentifier('tag'),
+              undefined,
+              factory.createTypeReferenceNode(
+                factory.createQualifiedName(
+                  factory.createIdentifier('Tag'),
+                  factory.createIdentifier(tag),
+                ),
+                undefined,
               ),
+            ),
+            factory.createPropertySignature(
               undefined,
+              factory.createIdentifier('version'),
+              undefined,
+              factory.createLiteralTypeNode(factory.createNumericLiteral(version)),
             ),
-          ),
-          factory.createPropertySignature(
+          ]),
+        ]);
+        return [
+          factory.createTypeAliasDeclaration(
             undefined,
-            factory.createIdentifier('version'),
+            factory.createIdentifier(`${prefix}${kind}${name}Type`),
             undefined,
-            factory.createLiteralTypeNode(factory.createNumericLiteral(version)),
+            isVersionOptional ? reAddVersion(innerType, version) : innerType,
           ),
-        ]),
-      ]);
-      return [
-        factory.createTypeAliasDeclaration(
-          undefined,
-          factory.createIdentifier(`${kind}${name}Type`),
-          undefined,
-          isVersionOptional ? reAddVersion(innerType, version) : innerType,
-        ),
-        factory.createInterfaceDeclaration(
-          [factory.createToken(ts.SyntaxKind.ExportKeyword)],
-          factory.createIdentifier(`${kind}${name}`),
-          undefined,
-          [factory.createHeritageClause(
-            ts.SyntaxKind.ExtendsKeyword,
-            [factory.createExpressionWithTypeArguments(
-              factory.createIdentifier(`${kind}${name}Type`),
-              undefined,
+          factory.createInterfaceDeclaration(
+            [factory.createToken(ts.SyntaxKind.ExportKeyword)],
+            factory.createIdentifier(`${prefix}${kind}${name}`),
+            undefined,
+            [factory.createHeritageClause(
+              ts.SyntaxKind.ExtendsKeyword,
+              [factory.createExpressionWithTypeArguments(
+                factory.createIdentifier(`${prefix}${kind}${name}Type`),
+                undefined,
+              )],
             )],
-          )],
-          [],
-        ),
-      ];
-    })
-      .flat()
-      .map((node) => addTsDocCategory(node));
-  }).flat(),
-  ...['TxParams', 'TxParamsAsync', 'TxUnpacked'].map((kind) => (
-    factory.createTypeAliasDeclaration(
-      [factory.createToken(ts.SyntaxKind.ExportKeyword)],
-      factory.createIdentifier(kind),
-      undefined,
-      factory.createUnionTypeNode(txSchema.map((schema) => {
-        const tag = Tag[schema.tag.constValue];
-        const version = schema.version.constValue;
-        const name = `${tag}${version}`;
-        return factory.createTypeReferenceNode(factory.createIdentifier(`${kind}${name}`));
-      })),
-    )
-  ))
-    .map((node) => addTsDocCategory(node)),
-]);
+            [],
+          ),
+        ];
+      })
+        .flat()
+        .map((node) => addTsDocCategory(node));
+    }).flat(),
+    ...typesToGenerate.map((kind) => (
+      factory.createTypeAliasDeclaration(
+        [factory.createToken(ts.SyntaxKind.ExportKeyword)],
+        factory.createIdentifier(prefix + kind),
+        undefined,
+        factory.createUnionTypeNode(schemas.map((schema) => {
+          const tag = Tag[schema.tag.constValue];
+          const version = schema.version.constValue;
+          const name = `${tag}${version}`;
+          return factory.createTypeReferenceNode(factory.createIdentifier(`${prefix}${kind}${name}`));
+        })),
+      )
+    ))
+      .map((node) => addTsDocCategory(node)),
+  ]);
 
-const result = `/* eslint-disable */
+  const result = `/* eslint-disable */
 // This file generated by \`npm run build:generate\`, don't edit manually.
 
 ${ts.createPrinter().printList(ts.ListFormat.MultiLine, list, sourceFile)}`;
 
-writeFileSync(destPath, result);
+  writeFileSync(destPath, result);
+}
+
+generate(true);
+generate(false);