@onekeyfe/hd-core 1.0.20 → 1.0.21

package/src/api/cardano/helper/auxiliaryData.ts

@@ -8,41 +8,65 @@ import { validateParams } from '../../helpers/paramsValidator';
 import { validatePath } from '../../helpers/pathUtils';
 import type {
   CardanoAuxiliaryData,
-  CardanoGovernanceRegistrationDelegation,
-  CardanoGovernanceRegistrationParameters,
+  CardanoCVoteRegistrationParameters,
+  CardanoCVoteRegistrationDelegation,
 } from '../../../types/api/cardano';
 import { PROTO } from '../../../constants';
 
 const MAX_DELEGATION_COUNT = 32;
 
 const transformDelegation = (
-  delegation: CardanoGovernanceRegistrationDelegation
-): PROTO.CardanoGovernanceRegistrationDelegation => {
+  delegation: CardanoCVoteRegistrationDelegation
+): PROTO.CardanoCVoteRegistrationDelegation => {
+  // @ts-expect-error votingPublicKey is a legacy param kept for backward compatibility (for now)
+  if (delegation.votingPublicKey) {
+    console.warn('Please use votePublicKey instead of votingPublicKey.');
+    // @ts-expect-error
+    delegation.votePublicKey = delegation.votingPublicKey;
+  }
+
   validateParams(delegation, [
     { name: 'votingPublicKey', type: 'string', required: true },
     { name: 'weight', type: 'uint', required: true },
   ]);
 
   return {
-    voting_public_key: delegation.votingPublicKey,
+    vote_public_key: delegation.votePublicKey,
     weight: delegation.weight,
   };
 };
 
-const transformGovernanceRegistrationParameters = (
-  governanceRegistrationParameters: CardanoGovernanceRegistrationParameters
-): PROTO.CardanoGovernanceRegistrationParametersType => {
-  validateParams(governanceRegistrationParameters, [
-    { name: 'votingPublicKey', type: 'string' },
+const transformCvoteRegistrationParameters = (
+  cVoteRegistrationParameters: CardanoCVoteRegistrationParameters
+): PROTO.CardanoCVoteRegistrationParametersType => {
+  // votingPublicKey and rewardAddressParameters are legacy params kept for backward compatibility (for now)
+  // @ts-expect-error
+  if (cVoteRegistrationParameters.votingPublicKey) {
+    console.warn('Please use votePublicKey instead of votingPublicKey.');
+    // @ts-expect-error
+    cVoteRegistrationParameters.votePublicKey = cVoteRegistrationParameters.votingPublicKey;
+  }
+  // @ts-expect-error
+  if (cVoteRegistrationParameters.rewardAddressParameters) {
+    console.warn('Please use paymentAddressParameters instead of rewardAddressParameters.');
+    cVoteRegistrationParameters.paymentAddressParameters =
+      // @ts-expect-error
+      cVoteRegistrationParameters.rewardAddressParameters;
+  }
+
+  validateParams(cVoteRegistrationParameters, [
+    { name: 'votePublicKey', type: 'string' },
     { name: 'stakingPath', required: true },
     { name: 'nonce', type: 'uint', required: true },
     { name: 'format', type: 'number' },
     { name: 'delegations', type: 'array', allowEmpty: true },
     { name: 'votingPurpose', type: 'uint' },
+    { name: 'paymentAddress', type: 'string' },
   ]);
-  validateAddressParameters(governanceRegistrationParameters.rewardAddressParameters);
+  const { paymentAddressParameters } = cVoteRegistrationParameters;
+  validateAddressParameters(paymentAddressParameters);
 
-  const { delegations } = governanceRegistrationParameters;
+  const { delegations } = cVoteRegistrationParameters;
   if (delegations && delegations.length > MAX_DELEGATION_COUNT) {
     throw ERRORS.TypedError(
       HardwareErrorCode.CallMethodInvalidParameter,
@@ -51,15 +75,16 @@ const transformGovernanceRegistrationParameters = (
   }
 
   return {
-    voting_public_key: governanceRegistrationParameters.votingPublicKey,
-    staking_path: validatePath(governanceRegistrationParameters.stakingPath, 3),
-    reward_address_parameters: addressParametersToProto(
-      governanceRegistrationParameters.rewardAddressParameters
-    ),
-    nonce: governanceRegistrationParameters.nonce as unknown as number,
-    format: governanceRegistrationParameters.format,
-    delegations: delegations?.map(transformDelegation) as any,
-    voting_purpose: governanceRegistrationParameters.votingPurpose,
+    vote_public_key: cVoteRegistrationParameters.votePublicKey,
+    staking_path: validatePath(cVoteRegistrationParameters.stakingPath, 3),
+    payment_address_parameters: paymentAddressParameters
+      ? addressParametersToProto(paymentAddressParameters)
+      : undefined,
+    nonce: cVoteRegistrationParameters.nonce as unknown as number,
+    format: cVoteRegistrationParameters.format,
+    delegations: delegations?.map(transformDelegation) ?? [],
+    voting_purpose: cVoteRegistrationParameters.votingPurpose,
+    payment_address: cVoteRegistrationParameters.paymentAddress,
   };
 };
 
@@ -73,32 +98,32 @@ export const transformAuxiliaryData = (
     },
   ]);
 
-  let governanceRegistrationParameters;
-  if (auxiliaryData.governanceRegistrationParameters) {
-    governanceRegistrationParameters = transformGovernanceRegistrationParameters(
-      auxiliaryData.governanceRegistrationParameters
+  let cVoteRegistrationParameters;
+  if (auxiliaryData.cVoteRegistrationParameters) {
+    cVoteRegistrationParameters = transformCvoteRegistrationParameters(
+      auxiliaryData.cVoteRegistrationParameters
     );
   }
 
   return {
     hash: auxiliaryData.hash,
-    governance_registration_parameters: governanceRegistrationParameters,
+    cvote_registration_parameters: cVoteRegistrationParameters,
   };
 };
 
 export const modifyAuxiliaryDataForBackwardsCompatibility = (
   auxiliary_data: PROTO.CardanoTxAuxiliaryData
 ): PROTO.CardanoTxAuxiliaryData => {
-  const { governance_registration_parameters } = auxiliary_data;
-  if (governance_registration_parameters) {
-    governance_registration_parameters.reward_address_parameters =
+  const { cvote_registration_parameters } = auxiliary_data;
+  if (cvote_registration_parameters?.payment_address_parameters) {
+    cvote_registration_parameters.payment_address_parameters =
       modifyAddressParametersForBackwardsCompatibility(
-        governance_registration_parameters.reward_address_parameters
+        cvote_registration_parameters.payment_address_parameters
       );
 
     return {
       ...auxiliary_data,
-      governance_registration_parameters,
+      cvote_registration_parameters,
     };
   }
 

package/src/api/cardano/helper/certificate.ts

@@ -9,6 +9,7 @@ import type {
   CardanoPoolMetadata,
   CardanoPoolRelay,
   CardanoPoolOwner,
+  CardanoDRep,
 } from '../../../types/api/cardano';
 import { PROTO } from '../../../constants';
 
@@ -156,6 +157,37 @@ const transformPoolParameters = (
   };
 };
 
+const transformDRep = (dRep: CardanoDRep | undefined): PROTO.CardanoDRep | undefined => {
+  if (!dRep) {
+    return undefined;
+  }
+
+  validateParams(dRep, [
+    { name: 'type', type: 'number', required: true },
+    { name: 'keyHash', type: 'string' },
+    { name: 'scriptHash', type: 'string' },
+  ]);
+
+  if (dRep.type === PROTO.CardanoDRepType.KEY_HASH && !dRep.keyHash) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.CallMethodInvalidParameter,
+      'key_hash must be supplied for key_hash type'
+    );
+  }
+
+  if (dRep.type === PROTO.CardanoDRepType.SCRIPT_HASH && !dRep.scriptHash) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.CallMethodInvalidParameter,
+      'script_hash must be supplied for script_hash type'
+    );
+  }
+  return {
+    type: dRep.type,
+    key_hash: dRep.keyHash,
+    script_hash: dRep.scriptHash,
+  };
+};
+
 export const transformCertificate = (
   certificate: CardanoCertificate
 ): CertificateWithPoolOwnersAndRelays => {
@@ -176,12 +208,25 @@ export const transformCertificate = (
     paramsToValidate.push({ name: 'poolParameters', type: 'object', required: true });
   }
 
+  if (
+    certificate.type === PROTO.CardanoCertificateType.STAKE_REGISTRATION_CONWAY ||
+    certificate.type === PROTO.CardanoCertificateType.STAKE_DEREGISTRATION_CONWAY
+  ) {
+    paramsToValidate.push({ name: 'deposit', required: true });
+  }
+
+  if (certificate.type === PROTO.CardanoCertificateType.VOTE_DELEGATION) {
+    paramsToValidate.push({ name: 'dRep', type: 'object', required: true });
+  }
+
   validateParams(certificate, paramsToValidate);
 
   const { poolParameters, poolOwners, poolRelays } = transformPoolParameters(
     certificate.poolParameters
   );
 
+  const dRep = transformDRep(certificate.dRep);
+
   return {
     certificate: {
       type: certificate.type,
@@ -190,6 +235,8 @@ export const transformCertificate = (
       key_hash: certificate.keyHash,
       pool: certificate.pool,
       pool_parameters: poolParameters,
+      deposit: certificate.deposit,
+      drep: dRep,
     },
     poolOwners,
     poolRelays,

package/src/data/messages/messages.json

@@ -345,7 +345,6 @@
     "BenfenAddress": {
       "fields": {
         "address": {
-          "rule": "required",
           "type": "string",
           "id": 1
         }
@@ -2016,7 +2015,18 @@
         "STAKE_REGISTRATION": 0,
         "STAKE_DEREGISTRATION": 1,
         "STAKE_DELEGATION": 2,
-        "STAKE_POOL_REGISTRATION": 3
+        "STAKE_POOL_REGISTRATION": 3,
+        "STAKE_REGISTRATION_CONWAY": 7,
+        "STAKE_DEREGISTRATION_CONWAY": 8,
+        "VOTE_DELEGATION": 9
+      }
+    },
+    "CardanoDRepType": {
+      "values": {
+        "KEY_HASH": 0,
+        "SCRIPT_HASH": 1,
+        "ABSTAIN": 2,
+        "NO_CONFIDENCE": 3
       }
     },
     "CardanoPoolRelayType": {
@@ -2029,10 +2039,10 @@
     "CardanoTxAuxiliaryDataSupplementType": {
       "values": {
         "NONE": 0,
-        "GOVERNANCE_REGISTRATION_SIGNATURE": 1
+        "CVOTE_REGISTRATION_SIGNATURE": 1
       }
     },
-    "CardanoGovernanceRegistrationFormat": {
+    "CardanoCVoteRegistrationFormat": {
       "values": {
         "CIP15": 0,
         "CIP36": 1
@@ -2206,6 +2216,10 @@
           "rule": "required",
           "type": "CardanoDerivationType",
           "id": 6
+        },
+        "chunkify": {
+          "type": "bool",
+          "id": 7
         }
       }
     },
@@ -2361,6 +2375,17 @@
           "options": {
             "default": 0
           }
+        },
+        "chunkify": {
+          "type": "bool",
+          "id": 22
+        },
+        "tag_cbor_sets": {
+          "type": "bool",
+          "id": 23,
+          "options": {
+            "default": false
+          }
         }
       }
     },
@@ -2582,6 +2607,23 @@
         }
       }
     },
+    "CardanoDRep": {
+      "fields": {
+        "type": {
+          "rule": "required",
+          "type": "CardanoDRepType",
+          "id": 1
+        },
+        "key_hash": {
+          "type": "bytes",
+          "id": 2
+        },
+        "script_hash": {
+          "type": "bytes",
+          "id": 3
+        }
+      }
+    },
     "CardanoTxCertificate": {
       "fields": {
         "type": {
@@ -2612,6 +2654,14 @@
         "key_hash": {
           "type": "bytes",
           "id": 6
+        },
+        "deposit": {
+          "type": "uint64",
+          "id": 7
+        },
+        "drep": {
+          "type": "CardanoDRep",
+          "id": 8
         }
       }
     },
@@ -2640,9 +2690,9 @@
         }
       }
     },
-    "CardanoGovernanceRegistrationDelegation": {
+    "CardanoCVoteRegistrationDelegation": {
       "fields": {
-        "voting_public_key": {
+        "vote_public_key": {
           "rule": "required",
           "type": "bytes",
           "id": 1
@@ -2654,9 +2704,9 @@
         }
       }
     },
-    "CardanoGovernanceRegistrationParametersType": {
+    "CardanoCVoteRegistrationParametersType": {
       "fields": {
-        "voting_public_key": {
+        "vote_public_key": {
           "type": "bytes",
           "id": 1
         },
@@ -2668,8 +2718,7 @@
             "packed": false
           }
         },
-        "reward_address_parameters": {
-          "rule": "required",
+        "payment_address_parameters": {
           "type": "CardanoAddressParametersType",
           "id": 3
         },
@@ -2679,7 +2728,7 @@
           "id": 4
         },
         "format": {
-          "type": "CardanoGovernanceRegistrationFormat",
+          "type": "CardanoCVoteRegistrationFormat",
           "id": 5,
           "options": {
             "default": "CIP15"
@@ -2687,19 +2736,23 @@
         },
         "delegations": {
           "rule": "repeated",
-          "type": "CardanoGovernanceRegistrationDelegation",
+          "type": "CardanoCVoteRegistrationDelegation",
           "id": 6
         },
         "voting_purpose": {
           "type": "uint64",
           "id": 7
+        },
+        "payment_address": {
+          "type": "string",
+          "id": 8
         }
       }
     },
     "CardanoTxAuxiliaryData": {
       "fields": {
-        "governance_registration_parameters": {
-          "type": "CardanoGovernanceRegistrationParametersType",
+        "cvote_registration_parameters": {
+          "type": "CardanoCVoteRegistrationParametersType",
           "id": 1
         },
         "hash": {
@@ -2775,7 +2828,7 @@
           "type": "bytes",
           "id": 2
         },
-        "governance_signature": {
+        "cvote_registration_signature": {
           "type": "bytes",
           "id": 3
         }

package/src/types/api/cardano.ts

@@ -1,3 +1,4 @@
+import type { UintType } from '@onekeyfe/hd-transport';
 import type { PROTO } from '../../constants';
 
 export interface CardanoAddressParameters {
@@ -32,6 +33,12 @@ export type AssetGroupWithTokens = {
   tokens: PROTO.CardanoToken[];
 };
 
+export interface CardanoDRep {
+  type: PROTO.CardanoDRepType;
+  keyHash?: string;
+  scriptHash?: string;
+}
+
 export interface CardanoCertificate {
   type: PROTO.CardanoCertificateType;
   path?: string | number[];
@@ -39,6 +46,8 @@ export interface CardanoCertificate {
   poolParameters?: CardanoPoolParameters;
   scriptHash?: string;
   keyHash?: string;
+  deposit?: UintType;
+  dRep?: CardanoDRep;
 }
 
 export type CertificateWithPoolOwnersAndRelays = {
@@ -129,8 +138,8 @@ export interface CardanoReferenceInput {
   prev_index: number;
 }
 
-export interface CardanoGovernanceRegistrationDelegation {
-  votingPublicKey: string;
+export interface CardanoCVoteRegistrationDelegation {
+  votePublicKey: string;
   weight: number;
 }
 
@@ -141,19 +150,20 @@ export interface CardanoCatalystRegistrationParameters {
   nonce: string;
 }
 
-export interface CardanoGovernanceRegistrationParameters {
-  votingPublicKey?: string;
+export interface CardanoCVoteRegistrationParameters {
+  votePublicKey?: string;
   stakingPath: string | number[];
-  rewardAddressParameters: CardanoAddressParameters;
+  paymentAddressParameters: CardanoAddressParameters;
   nonce: string;
-  format?: PROTO.CardanoGovernanceRegistrationFormat;
-  delegations?: CardanoGovernanceRegistrationDelegation[];
+  format?: PROTO.CardanoCVoteRegistrationFormat;
+  delegations?: CardanoCVoteRegistrationDelegation[];
   votingPurpose?: number;
+  paymentAddress?: string;
 }
 
 export interface CardanoAuxiliaryData {
   hash?: string;
-  governanceRegistrationParameters?: CardanoGovernanceRegistrationParameters;
+  cVoteRegistrationParameters?: CardanoCVoteRegistrationParameters;
 }
 
 export interface CardanoSignTransaction {
@@ -178,6 +188,8 @@ export interface CardanoSignTransaction {
   signingMode: PROTO.CardanoTxSigningMode;
   derivationType?: PROTO.CardanoDerivationType;
   includeNetworkId?: boolean;
+  chunkify?: boolean;
+  tagCborSets?: boolean;
 }
 
 export interface CardanoSignedTxWitness {
@@ -190,7 +202,7 @@ export interface CardanoSignedTxWitness {
 export interface CardanoAuxiliaryDataSupplement {
   type: PROTO.CardanoTxAuxiliaryDataSupplementType;
   auxiliaryDataHash: string;
-  catalystSignature?: string;
+  cVoteRegistrationSignature?: string;
 }
 
 export interface CardanoSignedTxData {