@trezor/connect 9.7.0-beta.1 → 9.7.0-beta.2

package/lib/api/cardano/cardanoAddressParameters.js

@@ -1,83 +1,89 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.addressParametersFromProto = exports.addressParametersToProto = exports.modifyAddressParametersForBackwardsCompatibility = exports.validateAddressParameters = void 0;
 const schema_utils_1 = require("@trezor/schema-utils");
 const constants_1 = require("../../constants");
 const cardano_1 = require("../../types/api/cardano");
 const pathUtils_1 = require("../../utils/pathUtils");
-const validateAddressParameters = (addressParameters) => {
-    (0, schema_utils_1.Assert)(cardano_1.CardanoAddressParameters, addressParameters);
-    if (addressParameters.path) {
-        (0, pathUtils_1.validatePath)(addressParameters.path);
-    }
-    if (addressParameters.stakingPath) {
-        (0, pathUtils_1.validatePath)(addressParameters.stakingPath);
-    }
+const validateAddressParameters = addressParameters => {
+  (0, schema_utils_1.Assert)(cardano_1.CardanoAddressParameters, addressParameters);
+  if (addressParameters.path) {
+    (0, pathUtils_1.validatePath)(addressParameters.path);
+  }
+  if (addressParameters.stakingPath) {
+    (0, pathUtils_1.validatePath)(addressParameters.stakingPath);
+  }
 };
 exports.validateAddressParameters = validateAddressParameters;
-const modifyAddressParametersForBackwardsCompatibility = (address_parameters) => {
-    if (address_parameters.address_type === constants_1.PROTO.CardanoAddressType.REWARD) {
-        let { address_n, address_n_staking } = address_parameters;
-        if (address_n.length > 0 && address_n_staking.length > 0) {
-            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `Only stakingPath is allowed for CardanoAddressType.REWARD`);
-        }
-        if (address_n.length > 0) {
-            address_n_staking = address_n;
-            address_n = [];
-        }
-        return {
-            ...address_parameters,
-            address_n,
-            address_n_staking,
-        };
-    }
-    return address_parameters;
-};
-exports.modifyAddressParametersForBackwardsCompatibility = modifyAddressParametersForBackwardsCompatibility;
-const addressParametersToProto = (addressParameters) => {
-    let path = [];
-    if (addressParameters.path) {
-        path = (0, pathUtils_1.validatePath)(addressParameters.path, 3);
-    }
-    let stakingPath = [];
-    if (addressParameters.stakingPath) {
-        stakingPath = (0, pathUtils_1.validatePath)(addressParameters.stakingPath, 3);
+const modifyAddressParametersForBackwardsCompatibility = address_parameters => {
+  if (address_parameters.address_type === constants_1.PROTO.CardanoAddressType.REWARD) {
+    let {
+      address_n,
+      address_n_staking
+    } = address_parameters;
+    if (address_n.length > 0 && address_n_staking.length > 0) {
+      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `Only stakingPath is allowed for CardanoAddressType.REWARD`);
     }
-    let certificatePointer;
-    if (addressParameters.certificatePointer) {
-        certificatePointer = {
-            block_index: addressParameters.certificatePointer.blockIndex,
-            tx_index: addressParameters.certificatePointer.txIndex,
-            certificate_index: addressParameters.certificatePointer.certificateIndex,
-        };
+    if (address_n.length > 0) {
+      address_n_staking = address_n;
+      address_n = [];
     }
     return {
-        address_type: addressParameters.addressType,
-        address_n: path,
-        address_n_staking: stakingPath,
-        staking_key_hash: addressParameters.stakingKeyHash,
-        certificate_pointer: certificatePointer,
-        script_payment_hash: addressParameters.paymentScriptHash,
-        script_staking_hash: addressParameters.stakingScriptHash,
+      ...address_parameters,
+      address_n,
+      address_n_staking
     };
+  }
+  return address_parameters;
+};
+exports.modifyAddressParametersForBackwardsCompatibility = modifyAddressParametersForBackwardsCompatibility;
+const addressParametersToProto = addressParameters => {
+  let path = [];
+  if (addressParameters.path) {
+    path = (0, pathUtils_1.validatePath)(addressParameters.path, 3);
+  }
+  let stakingPath = [];
+  if (addressParameters.stakingPath) {
+    stakingPath = (0, pathUtils_1.validatePath)(addressParameters.stakingPath, 3);
+  }
+  let certificatePointer;
+  if (addressParameters.certificatePointer) {
+    certificatePointer = {
+      block_index: addressParameters.certificatePointer.blockIndex,
+      tx_index: addressParameters.certificatePointer.txIndex,
+      certificate_index: addressParameters.certificatePointer.certificateIndex
+    };
+  }
+  return {
+    address_type: addressParameters.addressType,
+    address_n: path,
+    address_n_staking: stakingPath,
+    staking_key_hash: addressParameters.stakingKeyHash,
+    certificate_pointer: certificatePointer,
+    script_payment_hash: addressParameters.paymentScriptHash,
+    script_staking_hash: addressParameters.stakingScriptHash
+  };
 };
 exports.addressParametersToProto = addressParametersToProto;
-const addressParametersFromProto = (addressParameters) => {
-    let certificatePointer;
-    if (addressParameters.certificate_pointer) {
-        certificatePointer = {
-            blockIndex: addressParameters.certificate_pointer.block_index,
-            txIndex: addressParameters.certificate_pointer.tx_index,
-            certificateIndex: addressParameters.certificate_pointer.certificate_index,
-        };
-    }
-    return {
-        addressType: addressParameters.address_type,
-        path: addressParameters.address_n,
-        stakingPath: addressParameters.address_n_staking,
-        stakingKeyHash: addressParameters.staking_key_hash,
-        certificatePointer,
+const addressParametersFromProto = addressParameters => {
+  let certificatePointer;
+  if (addressParameters.certificate_pointer) {
+    certificatePointer = {
+      blockIndex: addressParameters.certificate_pointer.block_index,
+      txIndex: addressParameters.certificate_pointer.tx_index,
+      certificateIndex: addressParameters.certificate_pointer.certificate_index
     };
+  }
+  return {
+    addressType: addressParameters.address_type,
+    path: addressParameters.address_n,
+    stakingPath: addressParameters.address_n_staking,
+    stakingKeyHash: addressParameters.staking_key_hash,
+    certificatePointer
+  };
 };
 exports.addressParametersFromProto = addressParametersFromProto;
 //# sourceMappingURL=cardanoAddressParameters.js.map

package/lib/api/cardano/cardanoAuxiliaryData.js

@@ -1,5 +1,8 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.modifyAuxiliaryDataForBackwardsCompatibility = exports.transformAuxiliaryData = void 0;
 const schema_utils_1 = require("@trezor/schema-utils");
 const cardanoAddressParameters_1 = require("./cardanoAddressParameters");
@@ -7,72 +10,74 @@ const constants_1 = require("../../constants");
 const cardano_1 = require("../../types/api/cardano");
 const pathUtils_1 = require("../../utils/pathUtils");
 const MAX_DELEGATION_COUNT = 32;
-const transformDelegation = (delegation) => {
-    if (delegation.votingPublicKey) {
-        console.warn('Please use votePublicKey instead of votingPublicKey.');
-        delegation.votePublicKey = delegation.votingPublicKey;
-    }
-    (0, schema_utils_1.Assert)(cardano_1.CardanoCVoteRegistrationDelegation, delegation);
-    return {
-        vote_public_key: delegation.votePublicKey,
-        weight: delegation.weight,
-    };
+const transformDelegation = delegation => {
+  if (delegation.votingPublicKey) {
+    console.warn('Please use votePublicKey instead of votingPublicKey.');
+    delegation.votePublicKey = delegation.votingPublicKey;
+  }
+  (0, schema_utils_1.Assert)(cardano_1.CardanoCVoteRegistrationDelegation, delegation);
+  return {
+    vote_public_key: delegation.votePublicKey,
+    weight: delegation.weight
+  };
 };
-const transformCvoteRegistrationParameters = (cVoteRegistrationParameters) => {
-    if (cVoteRegistrationParameters.votingPublicKey) {
-        console.warn('Please use votePublicKey instead of votingPublicKey.');
-        cVoteRegistrationParameters.votePublicKey = cVoteRegistrationParameters.votingPublicKey;
-    }
-    if (cVoteRegistrationParameters.rewardAddressParameters) {
-        console.warn('Please use paymentAddressParameters instead of rewardAddressParameters.');
-        cVoteRegistrationParameters.paymentAddressParameters =
-            cVoteRegistrationParameters.rewardAddressParameters;
-    }
-    (0, schema_utils_1.Assert)(cardano_1.CardanoCVoteRegistrationParameters, cVoteRegistrationParameters);
-    const { paymentAddressParameters } = cVoteRegistrationParameters;
-    if (paymentAddressParameters) {
-        (0, cardanoAddressParameters_1.validateAddressParameters)(paymentAddressParameters);
-    }
-    const { delegations } = cVoteRegistrationParameters;
-    if (delegations && delegations.length > MAX_DELEGATION_COUNT) {
-        throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `At most ${MAX_DELEGATION_COUNT} delegations are allowed in a CIP-36 registration`);
-    }
-    return {
-        vote_public_key: cVoteRegistrationParameters.votePublicKey,
-        staking_path: (0, pathUtils_1.validatePath)(cVoteRegistrationParameters.stakingPath, 3),
-        payment_address_parameters: paymentAddressParameters
-            ? (0, cardanoAddressParameters_1.addressParametersToProto)(paymentAddressParameters)
-            : undefined,
-        nonce: cVoteRegistrationParameters.nonce,
-        format: cVoteRegistrationParameters.format,
-        delegations: delegations?.map(transformDelegation),
-        voting_purpose: cVoteRegistrationParameters.votingPurpose,
-        payment_address: cVoteRegistrationParameters.paymentAddress,
-    };
+const transformCvoteRegistrationParameters = cVoteRegistrationParameters => {
+  if (cVoteRegistrationParameters.votingPublicKey) {
+    console.warn('Please use votePublicKey instead of votingPublicKey.');
+    cVoteRegistrationParameters.votePublicKey = cVoteRegistrationParameters.votingPublicKey;
+  }
+  if (cVoteRegistrationParameters.rewardAddressParameters) {
+    console.warn('Please use paymentAddressParameters instead of rewardAddressParameters.');
+    cVoteRegistrationParameters.paymentAddressParameters = cVoteRegistrationParameters.rewardAddressParameters;
+  }
+  (0, schema_utils_1.Assert)(cardano_1.CardanoCVoteRegistrationParameters, cVoteRegistrationParameters);
+  const {
+    paymentAddressParameters
+  } = cVoteRegistrationParameters;
+  if (paymentAddressParameters) {
+    (0, cardanoAddressParameters_1.validateAddressParameters)(paymentAddressParameters);
+  }
+  const {
+    delegations
+  } = cVoteRegistrationParameters;
+  if (delegations && delegations.length > MAX_DELEGATION_COUNT) {
+    throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `At most ${MAX_DELEGATION_COUNT} delegations are allowed in a CIP-36 registration`);
+  }
+  return {
+    vote_public_key: cVoteRegistrationParameters.votePublicKey,
+    staking_path: (0, pathUtils_1.validatePath)(cVoteRegistrationParameters.stakingPath, 3),
+    payment_address_parameters: paymentAddressParameters ? (0, cardanoAddressParameters_1.addressParametersToProto)(paymentAddressParameters) : undefined,
+    nonce: cVoteRegistrationParameters.nonce,
+    format: cVoteRegistrationParameters.format,
+    delegations: delegations?.map(transformDelegation),
+    voting_purpose: cVoteRegistrationParameters.votingPurpose,
+    payment_address: cVoteRegistrationParameters.paymentAddress
+  };
 };
-const transformAuxiliaryData = (auxiliaryData) => {
-    (0, schema_utils_1.Assert)(cardano_1.CardanoAuxiliaryData, auxiliaryData);
-    let cVoteRegistrationParameters;
-    if (auxiliaryData.cVoteRegistrationParameters) {
-        cVoteRegistrationParameters = transformCvoteRegistrationParameters(auxiliaryData.cVoteRegistrationParameters);
-    }
-    return {
-        hash: auxiliaryData.hash,
-        cvote_registration_parameters: cVoteRegistrationParameters,
-    };
+const transformAuxiliaryData = auxiliaryData => {
+  (0, schema_utils_1.Assert)(cardano_1.CardanoAuxiliaryData, auxiliaryData);
+  let cVoteRegistrationParameters;
+  if (auxiliaryData.cVoteRegistrationParameters) {
+    cVoteRegistrationParameters = transformCvoteRegistrationParameters(auxiliaryData.cVoteRegistrationParameters);
+  }
+  return {
+    hash: auxiliaryData.hash,
+    cvote_registration_parameters: cVoteRegistrationParameters
+  };
 };
 exports.transformAuxiliaryData = transformAuxiliaryData;
-const modifyAuxiliaryDataForBackwardsCompatibility = (auxiliary_data) => {
-    const { cvote_registration_parameters } = auxiliary_data;
-    if (cvote_registration_parameters?.payment_address_parameters) {
-        cvote_registration_parameters.payment_address_parameters =
-            (0, cardanoAddressParameters_1.modifyAddressParametersForBackwardsCompatibility)(cvote_registration_parameters.payment_address_parameters);
-        return {
-            ...auxiliary_data,
-            cvote_registration_parameters,
-        };
-    }
-    return auxiliary_data;
+const modifyAuxiliaryDataForBackwardsCompatibility = auxiliary_data => {
+  const {
+    cvote_registration_parameters
+  } = auxiliary_data;
+  if (cvote_registration_parameters?.payment_address_parameters) {
+    cvote_registration_parameters.payment_address_parameters = (0, cardanoAddressParameters_1.modifyAddressParametersForBackwardsCompatibility)(cvote_registration_parameters.payment_address_parameters);
+    return {
+      ...auxiliary_data,
+      cvote_registration_parameters
+    };
+  }
+  return auxiliary_data;
 };
 exports.modifyAuxiliaryDataForBackwardsCompatibility = modifyAuxiliaryDataForBackwardsCompatibility;
 //# sourceMappingURL=cardanoAuxiliaryData.js.map

package/lib/api/cardano/cardanoCertificate.js

@@ -1,144 +1,149 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.transformCertificate = void 0;
 const schema_utils_1 = require("@trezor/schema-utils");
 const constants_1 = require("../../constants");
 const cardano_1 = require("../../types/api/cardano");
 const pathUtils_1 = require("../../utils/pathUtils");
-const ipv4AddressToHex = (ipv4Address) => Buffer.from(ipv4Address.split('.').map(ipPart => parseInt(ipPart, 10))).toString('hex');
-const ipv6AddressToHex = (ipv6Address) => ipv6Address.split(':').join('');
-const validatePoolRelay = (relay) => {
-    (0, schema_utils_1.Assert)(cardano_1.CardanoPoolRelay, relay);
-    if (relay.type === constants_1.PROTO.CardanoPoolRelayType.SINGLE_HOST_IP) {
-        if (!relay.ipv4Address && !relay.ipv6Address) {
-            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Either ipv4Address or ipv6Address must be supplied');
-        }
+const ipv4AddressToHex = ipv4Address => Buffer.from(ipv4Address.split('.').map(ipPart => parseInt(ipPart, 10))).toString('hex');
+const ipv6AddressToHex = ipv6Address => ipv6Address.split(':').join('');
+const validatePoolRelay = relay => {
+  (0, schema_utils_1.Assert)(cardano_1.CardanoPoolRelay, relay);
+  if (relay.type === constants_1.PROTO.CardanoPoolRelayType.SINGLE_HOST_IP) {
+    if (!relay.ipv4Address && !relay.ipv6Address) {
+      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Either ipv4Address or ipv6Address must be supplied');
     }
-    else if (relay.type === constants_1.PROTO.CardanoPoolRelayType.SINGLE_HOST_NAME) {
-        if (!relay.hostName) {
-            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'hostName must be supplied');
-        }
-        if (!relay.port) {
-            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'port must be supplied');
-        }
+  } else if (relay.type === constants_1.PROTO.CardanoPoolRelayType.SINGLE_HOST_NAME) {
+    if (!relay.hostName) {
+      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'hostName must be supplied');
     }
-    else if (relay.type === constants_1.PROTO.CardanoPoolRelayType.MULTIPLE_HOST_NAME) {
-        if (!relay.hostName) {
-            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'hostName must be supplied');
-        }
+    if (!relay.port) {
+      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'port must be supplied');
     }
-};
-const validatePoolOwners = (owners) => {
-    owners.forEach(owner => {
-        if (owner.stakingKeyPath) {
-            (0, pathUtils_1.validatePath)(owner.stakingKeyPath, 5);
-        }
-        if (!owner.stakingKeyHash && !owner.stakingKeyPath) {
-            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Either stakingKeyHash or stakingKeyPath must be supplied');
-        }
-    });
-    const ownersAsPathCount = owners.filter(owner => !!owner.stakingKeyPath).length;
-    if (ownersAsPathCount !== 1) {
-        throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Exactly one pool owner must be given as a path');
+  } else if (relay.type === constants_1.PROTO.CardanoPoolRelayType.MULTIPLE_HOST_NAME) {
+    if (!relay.hostName) {
+      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'hostName must be supplied');
     }
+  }
 };
-const validatePoolParameters = (poolParameters) => {
-    (0, schema_utils_1.Assert)(cardano_1.CardanoPoolParameters, poolParameters);
-    validatePoolOwners(poolParameters.owners);
-    poolParameters.relays.forEach(validatePoolRelay);
-};
-const validateDRep = (dRep) => {
-    (0, schema_utils_1.Assert)(cardano_1.CardanoDRep, dRep);
-    if (dRep.type === constants_1.PROTO.CardanoDRepType.KEY_HASH && !dRep.keyHash) {
-        throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'keyHash must be supplied for KEY_HASH dRep type');
+const validatePoolOwners = owners => {
+  owners.forEach(owner => {
+    if (owner.stakingKeyPath) {
+      (0, pathUtils_1.validatePath)(owner.stakingKeyPath, 5);
     }
-    else if (dRep.type === constants_1.PROTO.CardanoDRepType.SCRIPT_HASH && !dRep.scriptHash) {
-        throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'scriptHash must be supplied for SCRIPT_HASH dRep type');
+    if (!owner.stakingKeyHash && !owner.stakingKeyPath) {
+      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Either stakingKeyHash or stakingKeyPath must be supplied');
     }
+  });
+  const ownersAsPathCount = owners.filter(owner => !!owner.stakingKeyPath).length;
+  if (ownersAsPathCount !== 1) {
+    throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Exactly one pool owner must be given as a path');
+  }
 };
-const transformPoolParameters = (poolParameters) => {
-    if (!poolParameters) {
-        return { poolParameters: undefined, poolOwners: [], poolRelays: [] };
-    }
-    validatePoolParameters(poolParameters);
-    return {
-        poolParameters: {
-            pool_id: poolParameters.poolId,
-            vrf_key_hash: poolParameters.vrfKeyHash,
-            pledge: poolParameters.pledge,
-            cost: poolParameters.cost,
-            margin_numerator: poolParameters.margin.numerator,
-            margin_denominator: poolParameters.margin.denominator,
-            reward_account: poolParameters.rewardAccount,
-            metadata: poolParameters.metadata,
-            owners_count: poolParameters.owners.length,
-            relays_count: poolParameters.relays.length,
-        },
-        poolOwners: poolParameters.owners.map(owner => ({
-            staking_key_hash: owner.stakingKeyHash,
-            staking_key_path: owner.stakingKeyPath
-                ? (0, pathUtils_1.validatePath)(owner.stakingKeyPath, 5)
-                : undefined,
-        })),
-        poolRelays: poolParameters.relays.map(relay => ({
-            type: relay.type,
-            ipv4_address: relay.ipv4Address ? ipv4AddressToHex(relay.ipv4Address) : undefined,
-            ipv6_address: relay.ipv6Address ? ipv6AddressToHex(relay.ipv6Address) : undefined,
-            host_name: relay.hostName,
-            port: relay.port,
-        })),
-    };
+const validatePoolParameters = poolParameters => {
+  (0, schema_utils_1.Assert)(cardano_1.CardanoPoolParameters, poolParameters);
+  validatePoolOwners(poolParameters.owners);
+  poolParameters.relays.forEach(validatePoolRelay);
 };
-const transformDRep = (dRep) => {
-    if (!dRep) {
-        return undefined;
-    }
-    validateDRep(dRep);
+const validateDRep = dRep => {
+  (0, schema_utils_1.Assert)(cardano_1.CardanoDRep, dRep);
+  if (dRep.type === constants_1.PROTO.CardanoDRepType.KEY_HASH && !dRep.keyHash) {
+    throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'keyHash must be supplied for KEY_HASH dRep type');
+  } else if (dRep.type === constants_1.PROTO.CardanoDRepType.SCRIPT_HASH && !dRep.scriptHash) {
+    throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'scriptHash must be supplied for SCRIPT_HASH dRep type');
+  }
+};
+const transformPoolParameters = poolParameters => {
+  if (!poolParameters) {
     return {
-        type: dRep.type,
-        key_hash: dRep.keyHash,
-        script_hash: dRep.scriptHash,
+      poolParameters: undefined,
+      poolOwners: [],
+      poolRelays: []
     };
+  }
+  validatePoolParameters(poolParameters);
+  return {
+    poolParameters: {
+      pool_id: poolParameters.poolId,
+      vrf_key_hash: poolParameters.vrfKeyHash,
+      pledge: poolParameters.pledge,
+      cost: poolParameters.cost,
+      margin_numerator: poolParameters.margin.numerator,
+      margin_denominator: poolParameters.margin.denominator,
+      reward_account: poolParameters.rewardAccount,
+      metadata: poolParameters.metadata,
+      owners_count: poolParameters.owners.length,
+      relays_count: poolParameters.relays.length
+    },
+    poolOwners: poolParameters.owners.map(owner => ({
+      staking_key_hash: owner.stakingKeyHash,
+      staking_key_path: owner.stakingKeyPath ? (0, pathUtils_1.validatePath)(owner.stakingKeyPath, 5) : undefined
+    })),
+    poolRelays: poolParameters.relays.map(relay => ({
+      type: relay.type,
+      ipv4_address: relay.ipv4Address ? ipv4AddressToHex(relay.ipv4Address) : undefined,
+      ipv6_address: relay.ipv6Address ? ipv6AddressToHex(relay.ipv6Address) : undefined,
+      host_name: relay.hostName,
+      port: relay.port
+    }))
+  };
+};
+const transformDRep = dRep => {
+  if (!dRep) {
+    return undefined;
+  }
+  validateDRep(dRep);
+  return {
+    type: dRep.type,
+    key_hash: dRep.keyHash,
+    script_hash: dRep.scriptHash
+  };
 };
-const transformCertificate = (certificate) => {
-    (0, schema_utils_1.Assert)(cardano_1.CardanoCertificate, certificate);
-    if (certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_DELEGATION) {
-        if (!certificate.pool) {
-            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'pool must be supplied for STAKE_DELEGATION');
-        }
+const transformCertificate = certificate => {
+  (0, schema_utils_1.Assert)(cardano_1.CardanoCertificate, certificate);
+  if (certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_DELEGATION) {
+    if (!certificate.pool) {
+      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'pool must be supplied for STAKE_DELEGATION');
     }
-    if (certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_POOL_REGISTRATION) {
-        if (!certificate.poolParameters) {
-            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'poolParameters must be supplied for STAKE_POOL_REGISTRATION');
-        }
+  }
+  if (certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_POOL_REGISTRATION) {
+    if (!certificate.poolParameters) {
+      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'poolParameters must be supplied for STAKE_POOL_REGISTRATION');
     }
-    if (certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_REGISTRATION_CONWAY ||
-        certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_DEREGISTRATION_CONWAY) {
-        if (!certificate.deposit) {
-            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'deposit must be supplied for STAKE_REGISTRATION_CONWAY or STAKE_DEREGISTRATION_CONWAY');
-        }
+  }
+  if (certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_REGISTRATION_CONWAY || certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_DEREGISTRATION_CONWAY) {
+    if (!certificate.deposit) {
+      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'deposit must be supplied for STAKE_REGISTRATION_CONWAY or STAKE_DEREGISTRATION_CONWAY');
     }
-    if (certificate.type === constants_1.PROTO.CardanoCertificateType.VOTE_DELEGATION) {
-        if (!certificate.dRep) {
-            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'dRep must be supplied for VOTE_DELEGATION');
-        }
+  }
+  if (certificate.type === constants_1.PROTO.CardanoCertificateType.VOTE_DELEGATION) {
+    if (!certificate.dRep) {
+      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'dRep must be supplied for VOTE_DELEGATION');
     }
-    const { poolParameters, poolOwners, poolRelays } = transformPoolParameters(certificate.poolParameters);
-    const dRep = transformDRep(certificate.dRep);
-    return {
-        certificate: {
-            type: certificate.type,
-            path: certificate.path ? (0, pathUtils_1.validatePath)(certificate.path, 5) : undefined,
-            script_hash: certificate.scriptHash,
-            key_hash: certificate.keyHash,
-            pool: certificate.pool,
-            pool_parameters: poolParameters,
-            deposit: certificate.deposit,
-            drep: dRep,
-        },
-        poolOwners,
-        poolRelays,
-    };
+  }
+  const {
+    poolParameters,
+    poolOwners,
+    poolRelays
+  } = transformPoolParameters(certificate.poolParameters);
+  const dRep = transformDRep(certificate.dRep);
+  return {
+    certificate: {
+      type: certificate.type,
+      path: certificate.path ? (0, pathUtils_1.validatePath)(certificate.path, 5) : undefined,
+      script_hash: certificate.scriptHash,
+      key_hash: certificate.keyHash,
+      pool: certificate.pool,
+      pool_parameters: poolParameters,
+      deposit: certificate.deposit,
+      drep: dRep
+    },
+    poolOwners,
+    poolRelays
+  };
 };
 exports.transformCertificate = transformCertificate;
 //# sourceMappingURL=cardanoCertificate.js.map