Added account permission delegation

xrpl4j-core/src/main/java/org/xrpl/xrpl4j/codec/binary/definitions/DefaultDefinitionsProvider.java

@@ -24,8 +24,11 @@
 import com.google.common.base.Supplier;
 import com.google.common.base.Suppliers;
 import com.google.common.io.Resources;
+import org.xrpl.xrpl4j.model.transactions.GranularPermission;
 
 import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.Objects;
 
 public class DefaultDefinitionsProvider implements DefinitionsProvider {
@@ -43,14 +46,52 @@ public DefaultDefinitionsProvider(final ObjectMapper objectMapper) {
 
     this.supplier = Suppliers.memoize(() -> {
       try {
-        return objectMapper.readerFor(Definitions.class)
+        Definitions baseDefinitions = objectMapper.readerFor(Definitions.class)
           .readValue(Resources.getResource(DefaultDefinitionsProvider.class, "/definitions.json"));
+
+        // Generate PERMISSION_VALUES dynamically from TRANSACTION_TYPES
+        Map<String, Integer> permissionValues = generatePermissionValues(baseDefinitions);
+
+        // Return a new Definitions object with the generated PERMISSION_VALUES
+        return ImmutableDefinitions.builder()
+          .from(baseDefinitions)
+          .permissionValues(permissionValues)
+          .build();
       } catch (IOException e) {
         throw new IllegalStateException("Cannot read definition.json file", e);
       }
     });
   }
 
+  /**
+   * Generate PERMISSION_VALUES mapping from TRANSACTION_TYPES.
+   * This follows the same logic as xrpl.js:
+   * - Granular permissions start at 65537
+   * - Transaction type permissions are transaction type code + 1
+   *
+   * @param definitions The base {@link Definitions} loaded from definitions.json
+   * @return A {@link Map} of permission names to their numeric values
+   */
+  private Map<String, Integer> generatePermissionValues(Definitions definitions) {
+    Map<String, Integer> permissionValues = new HashMap<>();
+
+    // Add granular permissions from GranularPermission enum
+    for (GranularPermission permission : GranularPermission.values()) {
+      permissionValues.put(permission.value(), permission.numericValue());
+    }
+
+    // Add transaction type permissions (transaction type code + 1)
+    // Exclude Invalid (-1) only
+    definitions.transactionTypes().forEach((txType, txCode) -> {
+      // Skip Invalid (-1)
+      if (txCode >= 0) {
+        permissionValues.put(txType, txCode + 1);
+      }
+    });
+
+    return permissionValues;
+  }
+
   @Override
   public Definitions get() {
     return supplier.get();

xrpl4j-core/src/main/java/org/xrpl/xrpl4j/codec/binary/definitions/Definitions.java

@@ -24,6 +24,8 @@
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import com.google.common.collect.ImmutableMap;
+import org.immutables.value.Value.Default;
 import org.immutables.value.Value.Immutable;
 
 import java.util.List;
@@ -77,4 +79,16 @@ public interface Definitions {
   @JsonProperty("TRANSACTION_RESULTS")
   Map<String, Integer> transactionResults();
 
+  /**
+   * Permission values mappings (permission value to ordinal value).
+   * This field is not present in the generated definitions.json file and is populated
+   * programmatically by {@link DefaultDefinitionsProvider}.
+   *
+   * @return {@link Map} keyed by {@link String} with {@link Integer} values for all permission values.
+   */
+  @JsonProperty("PERMISSION_VALUES")
+  @Default
+  default Map<String, Integer> permissionValues() {
+    return ImmutableMap.of();
+  }
 }

xrpl4j-core/src/main/java/org/xrpl/xrpl4j/codec/binary/definitions/DefinitionsService.java

@@ -54,6 +54,8 @@ public class DefinitionsService {
 
   private final Map<Integer, String> ledgerEntryTypeReverseLookupMap;
 
+  private final Map<Integer, String> permissionValueReverseLookupMap;
+
   /**
    * Required-args Constructor.
    *
@@ -84,6 +86,7 @@ public class DefinitionsService {
     this.transactionTypeReverseLookupMap = inverse(definitions.transactionTypes());
     this.transactionResultReverseLookupNap = inverse(definitions.transactionResults());
     this.ledgerEntryTypeReverseLookupMap = inverse(definitions.ledgerEntryTypes());
+    this.permissionValueReverseLookupMap = inverse(definitions.permissionValues());
   }
 
   /**
@@ -184,6 +187,8 @@ public Optional<Integer> mapFieldSpecialization(String fieldName, String value)
         return Optional.ofNullable(definitions.transactionResults().get(value));
       case "TransactionType":
         return Optional.ofNullable(definitions.transactionTypes().get(value));
+      case "PermissionValue":
+        return Optional.ofNullable(definitions.permissionValues().get(value));
       default:
         return Optional.empty();
     }
@@ -208,6 +213,8 @@ public Optional<String> mapFieldRawValueToSpecialization(String fieldName, Strin
         return Optional.ofNullable(transactionResultReverseLookupNap.get(Integer.valueOf(value)));
       case "TransactionType":
         return Optional.ofNullable(transactionTypeReverseLookupMap.get(Integer.valueOf(value)));
+      case "PermissionValue":
+        return Optional.ofNullable(permissionValueReverseLookupMap.get(Integer.valueOf(value)));
       default:
         return Optional.empty();
     }

xrpl4j-core/src/main/java/org/xrpl/xrpl4j/crypto/signing/SignatureUtils.java

@@ -48,6 +48,7 @@
 import org.xrpl.xrpl4j.model.transactions.CredentialAccept;
 import org.xrpl.xrpl4j.model.transactions.CredentialCreate;
 import org.xrpl.xrpl4j.model.transactions.CredentialDelete;
+import org.xrpl.xrpl4j.model.transactions.DelegateSet;
 import org.xrpl.xrpl4j.model.transactions.DepositPreAuth;
 import org.xrpl.xrpl4j.model.transactions.DidDelete;
 import org.xrpl.xrpl4j.model.transactions.DidSet;
@@ -481,6 +482,10 @@ public <T extends Transaction> SingleSignedTransaction<T> addSignatureToTransact
       transactionWithSignature = CredentialDelete.builder().from((CredentialDelete) transaction)
         .transactionSignature(signature)
         .build();
+    } else if (DelegateSet.class.isAssignableFrom(transaction.getClass())) {
+      transactionWithSignature = DelegateSet.builder().from((DelegateSet) transaction)
+        .transactionSignature(signature)
+        .build();
     } else if (PermissionedDomainSet.class.isAssignableFrom(transaction.getClass())) {
       transactionWithSignature = PermissionedDomainSet.builder().from((PermissionedDomainSet) transaction)
         .transactionSignature(signature)
@@ -736,6 +741,10 @@ public <T extends Transaction> T addMultiSignaturesToTransaction(T transaction,
       transactionWithSignatures = CredentialDelete.builder().from((CredentialDelete) transaction)
         .signers(signers)
         .build();
+    } else if (DelegateSet.class.isAssignableFrom(transaction.getClass())) {
+      transactionWithSignatures = DelegateSet.builder().from((DelegateSet) transaction)
+        .signers(signers)
+        .build();
     } else if (PermissionedDomainSet.class.isAssignableFrom(transaction.getClass())) {
       transactionWithSignatures = PermissionedDomainSet.builder().from((PermissionedDomainSet) transaction)
         .signers(signers)

xrpl4j-core/src/main/java/org/xrpl/xrpl4j/model/client/ledger/DelegateLedgerEntryParams.java

@@ -0,0 +1,45 @@
+package org.xrpl.xrpl4j.model.client.ledger;
+
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import com.google.common.annotations.Beta;
+import org.immutables.value.Value.Immutable;
+import org.xrpl.xrpl4j.model.transactions.Address;
+
+/**
+ * Parameters that uniquely identify a {@link org.xrpl.xrpl4j.model.ledger.DelegateObject} on ledger that can be
+ * used in a {@link LedgerEntryRequestParams} to request a {@link org.xrpl.xrpl4j.model.ledger.DelegateObject}.
+ *
+ * <p>This class will be marked {@link Beta} until the featurePermissionDelegation amendment is enabled on mainnet.
+ * Its API is subject to change.</p>
+ */
+@Immutable
+@JsonSerialize(as = ImmutableDelegateLedgerEntryParams.class)
+@JsonDeserialize(as = ImmutableDelegateLedgerEntryParams.class)
+@Beta
+public interface DelegateLedgerEntryParams {
+
+  /**
+   * Construct a {@code DelegateLedgerEntryParams} builder.
+   *
+   * @return An {@link ImmutableDelegateLedgerEntryParams.Builder}.
+   */
+  static ImmutableDelegateLedgerEntryParams.Builder builder() {
+    return ImmutableDelegateLedgerEntryParams.builder();
+  }
+
+  /**
+   * The account that wants to authorize another account (the delegating account).
+   *
+   * @return An {@link Address}.
+   */
+  Address account();
+
+  /**
+   * The authorized account (the delegate).
+   *
+   * @return An {@link Address}.
+   */
+  Address authorize();
+}
+

xrpl4j-core/src/main/java/org/xrpl/xrpl4j/model/client/ledger/LedgerEntryRequestParams.java

@@ -14,6 +14,7 @@
 import org.xrpl.xrpl4j.model.ledger.BridgeObject;
 import org.xrpl.xrpl4j.model.ledger.CheckObject;
 import org.xrpl.xrpl4j.model.ledger.CredentialObject;
+import org.xrpl.xrpl4j.model.ledger.DelegateObject;
 import org.xrpl.xrpl4j.model.ledger.DepositPreAuthObject;
 import org.xrpl.xrpl4j.model.ledger.DidObject;
 import org.xrpl.xrpl4j.model.ledger.EscrowObject;
@@ -445,6 +446,25 @@ static LedgerEntryRequestParams<PermissionedDomainObject> permissionedDomain(
       .build();
   }
 
+  /**
+   * Construct a {@link LedgerEntryRequestParams} that requests a {@link DelegateObject} ledger entry.
+   *
+   * @param params          The {@link DelegateLedgerEntryParams} that uniquely identify the
+   *                        {@link DelegateObject} on ledger.
+   * @param ledgerSpecifier A {@link LedgerSpecifier} indicating the ledger to query data from.
+   *
+   * @return A {@link LedgerEntryRequestParams} for {@link DelegateObject}.
+   */
+  static LedgerEntryRequestParams<DelegateObject> delegate(
+    DelegateLedgerEntryParams params,
+    LedgerSpecifier ledgerSpecifier
+  ) {
+    return ImmutableLedgerEntryRequestParams.<DelegateObject>builder()
+      .delegate(params)
+      .ledgerSpecifier(ledgerSpecifier)
+      .build();
+  }
+
   /**
    * Specifies the ledger version to request. A ledger version can be specified by ledger hash, numerical ledger index,
    * or a shortcut value.
@@ -610,6 +630,13 @@ default boolean binary() {
   @JsonProperty("permissioned_domain")
   Optional<PermissionedDomainLedgerEntryParams> permissionedDomain();
 
+  /**
+   * Look up a {@link org.xrpl.xrpl4j.model.ledger.DelegateObject} by {@link DelegateLedgerEntryParams}.
+   *
+   * @return An optionally-present {@link DelegateLedgerEntryParams}.
+   */
+  Optional<DelegateLedgerEntryParams> delegate();
+
   /**
    * The {@link Class} of {@link T}. This field is helpful when telling Jackson how to deserialize rippled's response to
    * a {@link T}.
@@ -687,6 +714,10 @@ default Class<T> ledgerObjectClass() {
       return (Class<T>) PermissionedDomainObject.class;
     }
 
+    if (delegate().isPresent()) {
+      return (Class<T>) DelegateObject.class;
+    }
+
     return (Class<T>) LedgerObject.class;
   }
 }