@onekeyfe/hd-web-sdk 0.2.8 → 0.2.10

package/build/onekey-js-sdk.js

@@ -7467,6 +7467,21 @@ const inject = ({
       connectId,
       deviceId,
       method: 'suiSignTransaction'
+    })),
+    cardanoGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
+      connectId,
+      deviceId,
+      method: 'cardanoGetAddress'
+    })),
+    cardanoGetPublicKey: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
+      connectId,
+      deviceId,
+      method: 'cardanoGetPublicKey'
+    })),
+    cardanoSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
+      connectId,
+      deviceId,
+      method: 'cardanoSignTransaction'
     }))
   };
   return api;
@@ -10268,6 +10283,45 @@ var nested = {
         rule: "required",
         type: "CardanoDerivationType",
         id: 14
+      },
+      include_network_id: {
+        type: "bool",
+        id: 15,
+        options: {
+          "default": false
+        }
+      },
+      script_data_hash: {
+        type: "bytes",
+        id: 16
+      },
+      collateral_inputs_count: {
+        rule: "required",
+        type: "uint32",
+        id: 17
+      },
+      required_signers_count: {
+        rule: "required",
+        type: "uint32",
+        id: 18
+      },
+      has_collateral_return: {
+        type: "bool",
+        id: 19,
+        options: {
+          "default": false
+        }
+      },
+      total_collateral: {
+        type: "uint64",
+        id: 20
+      },
+      reference_inputs_count: {
+        type: "uint32",
+        id: 21,
+        options: {
+          "default": 0
+        }
       }
     }
   },
@@ -19452,6 +19506,10 @@ class Device extends events.exports {
         payload.session_id = internalState;
       }
 
+      if (options === null || options === void 0 ? void 0 : options.deriveCardano) {
+        payload.derive_cardano = true;
+      }
+
       Log$5.debug('initialize payload:', payload);
       const {
         message
@@ -19818,8 +19876,10 @@ class BaseMethod {
   checkDeviceSupportFeature() {
     if (!this.device || !this.device.features) return;
     const inputPinOnSoftware = supportInputPinOnSoftware(this.device.features);
+    const modifyHomescreen = supportModifyHomescreen(this.device.features);
     this.postMessage(createDeviceMessage(DEVICE.SUPPORT_FEATURES, {
       inputPinOnSoftware,
+      modifyHomescreen,
       device: this.device.toMessageObject()
     }));
   }
@@ -20149,6 +20209,17 @@ const validateParams = (values, fields) => {
 
           break;
 
+        case 'uint':
+          if (typeof value !== 'string' && typeof value !== 'number') {
+            throw invalidParameter(`Parameter [${field.name}] has invalid type. "string|number" expected.`);
+          }
+
+          if (typeof value === 'number' && !Number.isSafeInteger(value) || !/^(?:[1-9]\d*|\d)$/.test(value.toString().replace(/^-/, field.allowNegative ? '' : '-'))) {
+            throw invalidParameter(`Parameter [${field.name}] has invalid value "${value}". Integer representation expected.`);
+          }
+
+          break;
+
         case 'bigNumber':
           if (typeof value !== 'string') {
             throw invalidParameter(`Parameter [${field.name}] is of type invalid and should be [string].`);
@@ -20686,8 +20757,6 @@ const getInfo = ({
   return findLatestRelease(releaseInfo);
 };
 
-getLogger(exports.d0.Device);
-
 const postConfirmationMessage = device => {
   var _a;
 
@@ -22072,7 +22141,7 @@ const saveTxSignatures = (serializedTx, signatures, txRequest) => {
 
   if (typeof signature_index === 'number') {
     if (!signature) {
-      throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'saveTxSignatures: Unexpected null in trezor:TxRequestSerialized signature.');
+      throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'saveTxSignatures: Unexpected null in oneKey:TxRequestSerialized signature.');
     }
 
     signatures[signature_index] = signature;
@@ -25730,6 +25799,1196 @@ class SuiSignTransaction extends BaseMethod {
 
 }
 
+const safeThrowError = error => {
+  if (error instanceof hdShared.HardwareError) {
+    throw error;
+  } else if (error.code === 'ERR_NETWORK') {
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeNotInstalled);
+  } else if (error.code === 'ECONNABORTED') {
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeTimeoutError);
+  } else {
+    throw hdShared.ERRORS.TypedError(error);
+  }
+};
+
+const validateAddressParameters = addressParameters => {
+  validateParams(addressParameters, [{
+    name: 'addressType',
+    type: 'number',
+    required: true
+  }, {
+    name: 'stakingKeyHash',
+    type: 'string'
+  }, {
+    name: 'paymentScriptHash',
+    type: 'string'
+  }, {
+    name: 'stakingScriptHash',
+    type: 'string'
+  }]);
+
+  if (addressParameters.path) {
+    validatePath(addressParameters.path);
+  }
+
+  if (addressParameters.stakingPath) {
+    validatePath(addressParameters.stakingPath);
+  }
+
+  if (addressParameters.certificatePointer) {
+    validateParams(addressParameters.certificatePointer, [{
+      name: 'blockIndex',
+      type: 'number',
+      required: true
+    }, {
+      name: 'txIndex',
+      type: 'number',
+      required: true
+    }, {
+      name: 'certificateIndex',
+      type: 'number',
+      required: true
+    }]);
+  }
+};
+
+const addressParametersToProto = addressParameters => {
+  let path = [];
+
+  if (addressParameters.path) {
+    path = validatePath(addressParameters.path, 3);
+  }
+
+  let stakingPath = [];
+
+  if (addressParameters.stakingPath) {
+    stakingPath = 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
+  };
+};
+
+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 modifyAddressParametersForBackwardsCompatibility = address_parameters => {
+  if (address_parameters.address_type === hdTransport.Messages.CardanoAddressType.REWARD) {
+    let {
+      address_n,
+      address_n_staking
+    } = address_parameters;
+
+    if (address_n.length > 0 && address_n_staking.length > 0) {
+      throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, `Only stakingPath is allowed for CardanoAddressType.REWARD`);
+    }
+
+    if (address_n.length > 0) {
+      address_n_staking = address_n;
+      address_n = [];
+    }
+
+    return Object.assign(Object.assign({}, address_parameters), {
+      address_n,
+      address_n_staking
+    });
+  }
+
+  return address_parameters;
+};
+
+class CardanoGetAddress extends BaseMethod {
+  init() {
+    var _a, _b;
+
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+    this.hasBundle = !!((_a = this.payload) === null || _a === void 0 ? void 0 : _a.bundle);
+    this.isCheck = !!((_b = this.payload) === null || _b === void 0 ? void 0 : _b.isCheck);
+    const payload = this.hasBundle ? this.payload : {
+      bundle: [this.payload]
+    };
+    this.params = payload.bundle.map(batch => {
+      validateParams(batch, [{
+        name: 'addressParameters',
+        type: 'object',
+        required: true
+      }, {
+        name: 'networkId',
+        type: 'number',
+        required: true
+      }, {
+        name: 'protocolMagic',
+        type: 'number',
+        required: true
+      }, {
+        name: 'derivationType',
+        type: 'number'
+      }, {
+        name: 'address',
+        type: 'string'
+      }, {
+        name: 'showOnOneKey',
+        type: 'boolean'
+      }]);
+      validateAddressParameters(batch.addressParameters);
+      return {
+        address_parameters: addressParametersToProto(batch.addressParameters),
+        address: batch.address,
+        protocol_magic: batch.protocolMagic,
+        network_id: batch.networkId,
+        derivation_type: typeof batch.derivationType !== 'undefined' ? batch.derivationType : hdTransport.Messages.CardanoDerivationType.ICARUS_TREZOR,
+        show_display: typeof batch.showOnOneKey === 'boolean' ? !!batch.showOnOneKey : true
+      };
+    });
+  }
+
+  run() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const responses = [];
+
+      for (const batch of this.params) {
+        const {
+          address_parameters,
+          protocol_magic,
+          network_id,
+          derivation_type,
+          show_display
+        } = batch;
+        const response = yield this.device.commands.typedCall('CardanoGetAddress', 'CardanoAddress', {
+          address_parameters,
+          protocol_magic,
+          network_id,
+          derivation_type,
+          show_display
+        });
+        let xpub;
+        let stakeAddress;
+
+        if (address_parameters.address_type === hdTransport.Messages.CardanoAddressType.BASE && !this.isCheck) {
+          const publicKeyRes = yield this.device.commands.typedCall('CardanoGetPublicKey', 'CardanoPublicKey', {
+            address_n: address_parameters.address_n.slice(0, 3),
+            derivation_type,
+            show_display
+          });
+          xpub = publicKeyRes.message.xpub;
+          const stakeAddressRes = yield this.device.commands.typedCall('CardanoGetAddress', 'CardanoAddress', {
+            address_parameters: {
+              address_type: hdTransport.Messages.CardanoAddressType.REWARD,
+              address_n: [],
+              address_n_staking: address_parameters.address_n_staking
+            },
+            protocol_magic,
+            network_id,
+            derivation_type,
+            show_display
+          });
+          stakeAddress = stakeAddressRes.message.address;
+        }
+
+        responses.push({
+          addressParameters: addressParametersFromProto(batch.address_parameters),
+          protocolMagic: batch.protocol_magic,
+          networkId: batch.network_id,
+          serializedPath: serializedPath(batch.address_parameters.address_n),
+          serializedStakingPath: serializedPath(batch.address_parameters.address_n_staking),
+          address: response.message.address,
+          xpub,
+          stakeAddress
+        });
+      }
+
+      return this.hasBundle ? responses : responses[0];
+    });
+  }
+
+}
+
+class CardanoGetPublicKey extends BaseMethod {
+  init() {
+    var _a;
+
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+    this.hasBundle = !!((_a = this.payload) === null || _a === void 0 ? void 0 : _a.bundle);
+    const payload = this.hasBundle ? this.payload : {
+      bundle: [this.payload]
+    };
+    validateParams(payload, [{
+      name: 'bundle',
+      type: 'array'
+    }]);
+    this.params = payload.bundle.map(batch => {
+      validateParams(batch, [{
+        name: 'path',
+        required: true
+      }, {
+        name: 'derivationType',
+        type: 'number'
+      }, {
+        name: 'showOnTrezor',
+        type: 'boolean'
+      }]);
+      const path = validatePath(batch.path, 3);
+      return {
+        address_n: path,
+        derivation_type: typeof batch.derivationType !== 'undefined' ? batch.derivationType : hdTransport.Messages.CardanoDerivationType.ICARUS_TREZOR,
+        show_display: typeof batch.showOnOneKey === 'boolean' ? batch.showOnOneKey : false
+      };
+    });
+  }
+
+  run() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const responses = [];
+      const cmd = this.device.getCommands();
+
+      for (let i = 0; i < this.params.length; i++) {
+        const batch = this.params[i];
+        const {
+          message
+        } = yield cmd.typedCall('CardanoGetPublicKey', 'CardanoPublicKey', batch);
+        responses.push({
+          path: batch.address_n,
+          serializedPath: serializedPath(batch.address_n),
+          publicKey: message.xpub,
+          node: message.node
+        });
+      }
+
+      return this.hasBundle ? responses : responses[0];
+    });
+  }
+
+}
+
+const transformInput = input => {
+  validateParams(input, [{
+    name: 'prev_hash',
+    type: 'string',
+    required: true
+  }, {
+    name: 'prev_index',
+    type: 'number',
+    required: true
+  }]);
+  return {
+    input: {
+      prev_hash: input.prev_hash,
+      prev_index: input.prev_index
+    },
+    path: input.path ? validatePath(input.path, 5) : undefined
+  };
+};
+
+const transformCollateralInput = collateralInput => {
+  validateParams(collateralInput, [{
+    name: 'prev_hash',
+    type: 'string',
+    required: true
+  }, {
+    name: 'prev_index',
+    type: 'number',
+    required: true
+  }]);
+  return {
+    collateralInput: {
+      prev_hash: collateralInput.prev_hash,
+      prev_index: collateralInput.prev_index
+    },
+    path: collateralInput.path ? validatePath(collateralInput.path, 5) : undefined
+  };
+};
+
+const transformReferenceInput = referenceInput => {
+  validateParams(referenceInput, [{
+    name: 'prev_hash',
+    type: 'string',
+    required: true
+  }, {
+    name: 'prev_index',
+    type: 'number',
+    required: true
+  }]);
+  return {
+    prev_hash: referenceInput.prev_hash,
+    prev_index: referenceInput.prev_index
+  };
+};
+
+const validateTokens = tokenAmounts => {
+  tokenAmounts.forEach(tokenAmount => {
+    validateParams(tokenAmount, [{
+      name: 'assetNameBytes',
+      type: 'string',
+      required: true
+    }, {
+      name: 'amount',
+      type: 'uint'
+    }, {
+      name: 'mintAmount',
+      type: 'uint',
+      allowNegative: true
+    }]);
+  });
+};
+
+const validateTokenBundle = tokenBundle => {
+  tokenBundle.forEach(tokenGroup => {
+    validateParams(tokenGroup, [{
+      name: 'policyId',
+      type: 'string',
+      required: true
+    }, {
+      name: 'tokenAmounts',
+      type: 'array',
+      required: true
+    }]);
+    validateTokens(tokenGroup.tokenAmounts);
+  });
+};
+
+const tokenBundleToProto = tokenBundle => {
+  validateTokenBundle(tokenBundle);
+  return tokenBundle.map(tokenGroup => ({
+    policyId: tokenGroup.policyId,
+    tokens: tokenAmountsToProto(tokenGroup.tokenAmounts)
+  }));
+};
+
+const tokenAmountsToProto = tokenAmounts => tokenAmounts.map(tokenAmount => ({
+  asset_name_bytes: tokenAmount.assetNameBytes,
+  amount: tokenAmount.amount,
+  mint_amount: tokenAmount.mintAmount
+}));
+
+const hexStringByteLength = s => s.length / 2;
+
+const sendChunkedHexString = (typedCall, data, chunkSize, messageType) => __awaiter(void 0, void 0, void 0, function* () {
+  let processedSize = 0;
+
+  while (processedSize < data.length) {
+    const chunk = data.slice(processedSize, processedSize + chunkSize);
+    yield typedCall(messageType, 'CardanoTxItemAck', {
+      data: chunk
+    });
+    processedSize += chunkSize;
+  }
+});
+
+const transformOutput = output => {
+  validateParams(output, [{
+    name: 'address',
+    type: 'string'
+  }, {
+    name: 'amount',
+    type: 'uint',
+    required: true
+  }, {
+    name: 'tokenBundle',
+    type: 'array',
+    allowEmpty: true
+  }, {
+    name: 'datumHash',
+    type: 'string'
+  }, {
+    name: 'format',
+    type: 'number'
+  }, {
+    name: 'inlineDatum',
+    type: 'string'
+  }, {
+    name: 'referenceScript',
+    type: 'string'
+  }]);
+  const result = {
+    output: {
+      amount: output.amount,
+      asset_groups_count: 0,
+      datum_hash: output.datumHash,
+      format: output.format,
+      inline_datum_size: output.inlineDatum ? hexStringByteLength(output.inlineDatum) : undefined,
+      reference_script_size: output.referenceScript ? hexStringByteLength(output.referenceScript) : undefined
+    },
+    inlineDatum: output.inlineDatum,
+    referenceScript: output.referenceScript
+  };
+
+  if (output.addressParameters) {
+    validateAddressParameters(output.addressParameters);
+    result.output.address_parameters = addressParametersToProto(output.addressParameters);
+  } else {
+    result.output.address = output.address;
+  }
+
+  if (output.tokenBundle) {
+    result.tokenBundle = tokenBundleToProto(output.tokenBundle);
+    result.output.asset_groups_count = result.tokenBundle.length;
+  } else {
+    result.output.asset_groups_count = 0;
+  }
+
+  return result;
+};
+
+const sendOutput = (typedCall, outputWithData) => __awaiter(void 0, void 0, void 0, function* () {
+  const MAX_CHUNK_SIZE = 1024 * 2;
+  const {
+    output,
+    tokenBundle,
+    inlineDatum,
+    referenceScript
+  } = outputWithData;
+  yield typedCall('CardanoTxOutput', 'CardanoTxItemAck', output);
+
+  if (tokenBundle) {
+    for (const assetGroup of tokenBundle) {
+      yield typedCall('CardanoAssetGroup', 'CardanoTxItemAck', {
+        policy_id: assetGroup.policyId,
+        tokens_count: assetGroup.tokens.length
+      });
+
+      for (const token of assetGroup.tokens) {
+        yield typedCall('CardanoToken', 'CardanoTxItemAck', token);
+      }
+    }
+  }
+
+  if (inlineDatum) {
+    yield sendChunkedHexString(typedCall, inlineDatum, MAX_CHUNK_SIZE, 'CardanoTxInlineDatumChunk');
+  }
+
+  if (referenceScript) {
+    yield sendChunkedHexString(typedCall, referenceScript, MAX_CHUNK_SIZE, 'CardanoTxReferenceScriptChunk');
+  }
+});
+
+const ipv4AddressToHex = ipv4Address => Buffer.from(ipv4Address.split('.').map(ipPart => parseInt(ipPart, 10))).toString('hex');
+
+const ipv6AddressToHex = ipv6Address => ipv6Address.split(':').join('');
+
+const validatePoolMargin = margin => {
+  validateParams(margin, [{
+    name: 'numerator',
+    type: 'string',
+    required: true
+  }, {
+    name: 'denominator',
+    type: 'string',
+    required: true
+  }]);
+};
+
+const validatePoolMetadata = metadata => {
+  validateParams(metadata, [{
+    name: 'url',
+    type: 'string',
+    required: true
+  }, {
+    name: 'hash',
+    type: 'string',
+    required: true
+  }]);
+};
+
+const validatePoolRelay = relay => {
+  validateParams(relay, [{
+    name: 'type',
+    type: 'number',
+    required: true
+  }]);
+
+  if (relay.type === hdTransport.Messages.CardanoPoolRelayType.SINGLE_HOST_IP) {
+    const paramsToValidate = [{
+      name: 'port',
+      type: 'number',
+      required: true
+    }];
+
+    if (relay.ipv4Address) {
+      paramsToValidate.push({
+        name: 'ipv4Address',
+        type: 'string',
+        required: false
+      });
+    }
+
+    if (relay.ipv6Address) {
+      paramsToValidate.push({
+        name: 'ipv6Address',
+        type: 'string',
+        required: false
+      });
+    }
+
+    validateParams(relay, paramsToValidate);
+
+    if (!relay.ipv4Address && !relay.ipv6Address) {
+      throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Either ipv4Address or ipv6Address must be supplied');
+    }
+  } else if (relay.type === hdTransport.Messages.CardanoPoolRelayType.SINGLE_HOST_NAME) {
+    validateParams(relay, [{
+      name: 'hostName',
+      type: 'string',
+      required: true
+    }, {
+      name: 'port',
+      type: 'number',
+      required: true
+    }]);
+  } else if (relay.type === hdTransport.Messages.CardanoPoolRelayType.MULTIPLE_HOST_NAME) {
+    validateParams(relay, [{
+      name: 'hostName',
+      type: 'string',
+      required: true
+    }]);
+  }
+};
+
+const validatePoolOwners = owners => {
+  owners.forEach(owner => {
+    if (owner.stakingKeyHash) {
+      validateParams(owner, [{
+        name: 'stakingKeyHash',
+        type: 'string',
+        required: !owner.stakingKeyPath
+      }]);
+    }
+
+    if (owner.stakingKeyPath) {
+      validatePath(owner.stakingKeyPath, 5);
+    }
+
+    if (!owner.stakingKeyHash && !owner.stakingKeyPath) {
+      throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Either stakingKeyHash or stakingKeyPath must be supplied');
+    }
+  });
+  const ownersAsPathCount = owners.filter(owner => !!owner.stakingKeyPath).length;
+
+  if (ownersAsPathCount !== 1) {
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Exactly one pool owner must be given as a path');
+  }
+};
+
+const validatePoolParameters = poolParameters => {
+  validateParams(poolParameters, [{
+    name: 'poolId',
+    type: 'string',
+    required: true
+  }, {
+    name: 'vrfKeyHash',
+    type: 'string',
+    required: true
+  }, {
+    name: 'pledge',
+    type: 'string',
+    required: true
+  }, {
+    name: 'cost',
+    type: 'string',
+    required: true
+  }, {
+    name: 'margin',
+    type: 'object',
+    required: true
+  }, {
+    name: 'rewardAccount',
+    type: 'string',
+    required: true
+  }, {
+    name: 'owners',
+    type: 'array',
+    required: true
+  }, {
+    name: 'relays',
+    type: 'array',
+    required: true,
+    allowEmpty: true
+  }, {
+    name: 'metadata',
+    type: 'object'
+  }]);
+  validatePoolMargin(poolParameters.margin);
+  validatePoolOwners(poolParameters.owners);
+  poolParameters.relays.forEach(validatePoolRelay);
+
+  if (poolParameters.metadata) {
+    validatePoolMetadata(poolParameters.metadata);
+  }
+};
+
+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 ? 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 transformCertificate = certificate => {
+  const paramsToValidate = [{
+    name: 'type',
+    type: 'number',
+    required: true
+  }];
+
+  if (certificate.type !== hdTransport.Messages.CardanoCertificateType.STAKE_POOL_REGISTRATION) {
+    paramsToValidate.push({
+      name: 'scriptHash',
+      type: 'string'
+    });
+    paramsToValidate.push({
+      name: 'keyHash',
+      type: 'string'
+    });
+  }
+
+  if (certificate.type === hdTransport.Messages.CardanoCertificateType.STAKE_DELEGATION) {
+    paramsToValidate.push({
+      name: 'pool',
+      type: 'string',
+      required: true
+    });
+  }
+
+  if (certificate.type === hdTransport.Messages.CardanoCertificateType.STAKE_POOL_REGISTRATION) {
+    paramsToValidate.push({
+      name: 'poolParameters',
+      type: 'object',
+      required: true
+    });
+  }
+
+  validateParams(certificate, paramsToValidate);
+  const {
+    poolParameters,
+    poolOwners,
+    poolRelays
+  } = transformPoolParameters(certificate.poolParameters);
+  return {
+    certificate: {
+      type: certificate.type,
+      path: certificate.path ? validatePath(certificate.path, 5) : undefined,
+      script_hash: certificate.scriptHash,
+      key_hash: certificate.keyHash,
+      pool: certificate.pool,
+      pool_parameters: poolParameters
+    },
+    poolOwners,
+    poolRelays
+  };
+};
+
+const transformCatalystRegistrationParameters = catalystRegistrationParameters => {
+  validateParams(catalystRegistrationParameters, [{
+    name: 'votingPublicKey',
+    type: 'string',
+    required: true
+  }, {
+    name: 'stakingPath',
+    required: true
+  }, {
+    name: 'nonce',
+    type: 'uint',
+    required: true
+  }]);
+  validateAddressParameters(catalystRegistrationParameters.rewardAddressParameters);
+  return {
+    voting_public_key: catalystRegistrationParameters.votingPublicKey,
+    staking_path: validatePath(catalystRegistrationParameters.stakingPath, 3),
+    reward_address_parameters: addressParametersToProto(catalystRegistrationParameters.rewardAddressParameters),
+    nonce: catalystRegistrationParameters.nonce
+  };
+};
+
+const transformAuxiliaryData = auxiliaryData => {
+  validateParams(auxiliaryData, [{
+    name: 'hash',
+    type: 'string'
+  }]);
+  let catalystRegistrationParameters;
+
+  if (auxiliaryData.catalystRegistrationParameters) {
+    catalystRegistrationParameters = transformCatalystRegistrationParameters(auxiliaryData.catalystRegistrationParameters);
+  }
+
+  return {
+    hash: auxiliaryData.hash,
+    catalyst_registration_parameters: catalystRegistrationParameters
+  };
+};
+
+const modifyAuxiliaryDataForBackwardsCompatibility = auxiliary_data => {
+  const {
+    catalyst_registration_parameters
+  } = auxiliary_data;
+
+  if (catalyst_registration_parameters) {
+    catalyst_registration_parameters.reward_address_parameters = modifyAddressParametersForBackwardsCompatibility(catalyst_registration_parameters.reward_address_parameters);
+    return Object.assign(Object.assign({}, auxiliary_data), {
+      catalyst_registration_parameters
+    });
+  }
+
+  return auxiliary_data;
+};
+
+const gatherWitnessPaths = (inputsWithPath, certificatesWithPoolOwnersAndRelays, withdrawals, collateralInputsWithPath, requiredSigners, additionalWitnessRequests, signingMode) => {
+  const witnessPaths = new Map();
+
+  function _insert(path) {
+    const pathKey = JSON.stringify(path);
+    witnessPaths.set(pathKey, path);
+  }
+
+  if (signingMode !== hdTransport.Messages.CardanoTxSigningMode.MULTISIG_TRANSACTION) {
+    inputsWithPath.forEach(({
+      path
+    }) => {
+      if (path) _insert(path);
+    });
+    certificatesWithPoolOwnersAndRelays.forEach(({
+      certificate,
+      poolOwners
+    }) => {
+      if (certificate.path && (certificate.type === hdTransport.Messages.CardanoCertificateType.STAKE_DELEGATION || certificate.type === hdTransport.Messages.CardanoCertificateType.STAKE_DEREGISTRATION)) {
+        _insert(certificate.path);
+      }
+
+      poolOwners.forEach(poolOwner => {
+        if (poolOwner.staking_key_path) _insert(poolOwner.staking_key_path);
+      });
+    });
+    withdrawals.forEach(({
+      path
+    }) => {
+      if (path) _insert(path);
+    });
+  }
+
+  if (signingMode === hdTransport.Messages.CardanoTxSigningMode.PLUTUS_TRANSACTION) {
+    collateralInputsWithPath.forEach(({
+      path
+    }) => {
+      if (path) _insert(path);
+    });
+  }
+
+  requiredSigners.forEach(({
+    key_path
+  }) => {
+    if (key_path) _insert(key_path);
+  });
+  additionalWitnessRequests.forEach(path => {
+    _insert(path);
+  });
+  return Array.from(witnessPaths.values());
+};
+
+class CardanoSignTransaction extends BaseMethod {
+  init() {
+    var _a;
+
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+    this.hasBundle = !!((_a = this.payload) === null || _a === void 0 ? void 0 : _a.bundle);
+    const {
+      payload
+    } = this;
+    validateParams(payload, [{
+      name: 'signingMode',
+      type: 'number',
+      required: true
+    }, {
+      name: 'inputs',
+      type: 'array',
+      required: true
+    }, {
+      name: 'outputs',
+      type: 'array',
+      required: true,
+      allowEmpty: true
+    }, {
+      name: 'fee',
+      type: 'uint',
+      required: true
+    }, {
+      name: 'ttl',
+      type: 'uint'
+    }, {
+      name: 'certificates',
+      type: 'array',
+      allowEmpty: true
+    }, {
+      name: 'withdrawals',
+      type: 'array',
+      allowEmpty: true
+    }, {
+      name: 'mint',
+      type: 'array',
+      allowEmpty: true
+    }, {
+      name: 'validityIntervalStart',
+      type: 'uint'
+    }, {
+      name: 'scriptDataHash',
+      type: 'string'
+    }, {
+      name: 'collateralInputs',
+      type: 'array',
+      allowEmpty: true
+    }, {
+      name: 'requiredSigners',
+      type: 'array',
+      allowEmpty: true
+    }, {
+      name: 'totalCollateral',
+      type: 'uint'
+    }, {
+      name: 'referenceInputs',
+      type: 'array',
+      allowEmpty: true
+    }, {
+      name: 'protocolMagic',
+      type: 'number',
+      required: true
+    }, {
+      name: 'networkId',
+      type: 'number',
+      required: true
+    }, {
+      name: 'additionalWitnessRequests',
+      type: 'array',
+      allowEmpty: true
+    }, {
+      name: 'derivationType',
+      type: 'number'
+    }, {
+      name: 'includeNetworkId',
+      type: 'boolean'
+    }]);
+    const inputsWithPath = payload.inputs.map(transformInput);
+    const outputsWithData = payload.outputs.map(transformOutput);
+    let certificatesWithPoolOwnersAndRelays = [];
+
+    if (payload.certificates) {
+      certificatesWithPoolOwnersAndRelays = payload.certificates.map(transformCertificate);
+    }
+
+    let withdrawals = [];
+
+    if (payload.withdrawals) {
+      withdrawals = payload.withdrawals.map(withdrawal => {
+        validateParams(withdrawal, [{
+          name: 'amount',
+          type: 'uint',
+          required: true
+        }, {
+          name: 'scriptHash',
+          type: 'string'
+        }, {
+          name: 'keyHash',
+          type: 'string'
+        }]);
+        return {
+          path: withdrawal.path ? validatePath(withdrawal.path, 5) : undefined,
+          amount: withdrawal.amount,
+          script_hash: withdrawal.scriptHash,
+          key_hash: withdrawal.keyHash
+        };
+      });
+    }
+
+    let mint = [];
+
+    if (payload.mint) {
+      mint = tokenBundleToProto(payload.mint);
+    }
+
+    let auxiliaryData;
+
+    if (payload.auxiliaryData) {
+      auxiliaryData = transformAuxiliaryData(payload.auxiliaryData);
+    }
+
+    let additionalWitnessRequests = [];
+
+    if (payload.additionalWitnessRequests) {
+      additionalWitnessRequests = payload.additionalWitnessRequests.map(witnessRequest => validatePath(witnessRequest, 3));
+    }
+
+    let collateralInputsWithPath = [];
+
+    if (payload.collateralInputs) {
+      collateralInputsWithPath = payload.collateralInputs.map(transformCollateralInput);
+    }
+
+    let requiredSigners = [];
+
+    if (payload.requiredSigners) {
+      requiredSigners = payload.requiredSigners.map(requiredSigner => {
+        validateParams(requiredSigner, [{
+          name: 'keyHash',
+          type: 'string'
+        }]);
+        return {
+          key_path: requiredSigner.keyPath ? validatePath(requiredSigner.keyPath, 3) : undefined,
+          key_hash: requiredSigner.keyHash
+        };
+      });
+    }
+
+    const collateralReturnWithData = payload.collateralReturn ? transformOutput(payload.collateralReturn) : undefined;
+    let referenceInputs = [];
+
+    if (payload.referenceInputs) {
+      referenceInputs = payload.referenceInputs.map(transformReferenceInput);
+    }
+
+    this.params = {
+      signingMode: payload.signingMode,
+      inputsWithPath,
+      outputsWithData,
+      fee: payload.fee,
+      ttl: payload.ttl,
+      certificatesWithPoolOwnersAndRelays,
+      withdrawals,
+      mint,
+      auxiliaryData,
+      validityIntervalStart: payload.validityIntervalStart,
+      scriptDataHash: payload.scriptDataHash,
+      collateralInputsWithPath,
+      requiredSigners,
+      collateralReturnWithData,
+      totalCollateral: payload.totalCollateral,
+      referenceInputs,
+      protocolMagic: payload.protocolMagic,
+      networkId: payload.networkId,
+      witnessPaths: gatherWitnessPaths(inputsWithPath, certificatesWithPoolOwnersAndRelays, withdrawals, collateralInputsWithPath, requiredSigners, additionalWitnessRequests, payload.signingMode),
+      additionalWitnessRequests,
+      derivationType: typeof payload.derivationType !== 'undefined' ? payload.derivationType : hdTransport.Messages.CardanoDerivationType.ICARUS_TREZOR,
+      includeNetworkId: payload.includeNetworkId
+    };
+  }
+
+  signTx() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+      const hasAuxiliaryData = !!this.params.auxiliaryData;
+      const signTxInitMessage = {
+        signing_mode: this.params.signingMode,
+        protocol_magic: this.params.protocolMagic,
+        network_id: this.params.networkId,
+        inputs_count: this.params.inputsWithPath.length,
+        outputs_count: this.params.outputsWithData.length,
+        fee: this.params.fee,
+        ttl: this.params.ttl,
+        certificates_count: this.params.certificatesWithPoolOwnersAndRelays.length,
+        withdrawals_count: this.params.withdrawals.length,
+        has_auxiliary_data: hasAuxiliaryData,
+        validity_interval_start: this.params.validityIntervalStart,
+        witness_requests_count: this.params.witnessPaths.length,
+        minting_asset_groups_count: this.params.mint.length,
+        script_data_hash: this.params.scriptDataHash,
+        collateral_inputs_count: this.params.collateralInputsWithPath.length,
+        required_signers_count: this.params.requiredSigners.length,
+        has_collateral_return: this.params.collateralReturnWithData != null,
+        total_collateral: this.params.totalCollateral,
+        reference_inputs_count: this.params.referenceInputs.length,
+        derivation_type: this.params.derivationType,
+        include_network_id: this.params.includeNetworkId
+      };
+      yield typedCall('CardanoSignTxInit', 'CardanoTxItemAck', signTxInitMessage);
+
+      for (const {
+        input
+      } of this.params.inputsWithPath) {
+        yield typedCall('CardanoTxInput', 'CardanoTxItemAck', input);
+      }
+
+      for (const outputWithData of this.params.outputsWithData) {
+        yield sendOutput(typedCall, outputWithData);
+      }
+
+      for (const {
+        certificate,
+        poolOwners,
+        poolRelays
+      } of this.params.certificatesWithPoolOwnersAndRelays) {
+        yield typedCall('CardanoTxCertificate', 'CardanoTxItemAck', certificate);
+
+        for (const poolOwner of poolOwners) {
+          yield typedCall('CardanoPoolOwner', 'CardanoTxItemAck', poolOwner);
+        }
+
+        for (const poolRelay of poolRelays) {
+          yield typedCall('CardanoPoolRelayParameters', 'CardanoTxItemAck', poolRelay);
+        }
+      }
+
+      for (const withdrawal of this.params.withdrawals) {
+        yield typedCall('CardanoTxWithdrawal', 'CardanoTxItemAck', withdrawal);
+      }
+
+      let auxiliaryDataSupplement;
+
+      if (this.params.auxiliaryData) {
+        const {
+          catalyst_registration_parameters
+        } = this.params.auxiliaryData;
+
+        if (catalyst_registration_parameters) {
+          this.params.auxiliaryData = modifyAuxiliaryDataForBackwardsCompatibility(this.params.auxiliaryData);
+        }
+
+        const {
+          message
+        } = yield typedCall('CardanoTxAuxiliaryData', 'CardanoTxAuxiliaryDataSupplement', this.params.auxiliaryData);
+        const auxiliaryDataType = hdTransport.Messages.CardanoTxAuxiliaryDataSupplementType[message.type];
+
+        if (auxiliaryDataType !== hdTransport.Messages.CardanoTxAuxiliaryDataSupplementType.NONE) {
+          auxiliaryDataSupplement = {
+            type: auxiliaryDataType,
+            auxiliaryDataHash: message.auxiliary_data_hash,
+            catalystSignature: message.catalyst_signature
+          };
+        }
+
+        yield typedCall('CardanoTxHostAck', 'CardanoTxItemAck');
+      }
+
+      if (this.params.mint.length > 0) {
+        yield typedCall('CardanoTxMint', 'CardanoTxItemAck', {
+          asset_groups_count: this.params.mint.length
+        });
+
+        for (const assetGroup of this.params.mint) {
+          yield typedCall('CardanoAssetGroup', 'CardanoTxItemAck', {
+            policy_id: assetGroup.policyId,
+            tokens_count: assetGroup.tokens.length
+          });
+
+          for (const token of assetGroup.tokens) {
+            yield typedCall('CardanoToken', 'CardanoTxItemAck', token);
+          }
+        }
+      }
+
+      for (const {
+        collateralInput
+      } of this.params.collateralInputsWithPath) {
+        yield typedCall('CardanoTxCollateralInput', 'CardanoTxItemAck', collateralInput);
+      }
+
+      for (const requiredSigner of this.params.requiredSigners) {
+        yield typedCall('CardanoTxRequiredSigner', 'CardanoTxItemAck', requiredSigner);
+      }
+
+      if (this.params.collateralReturnWithData) {
+        yield sendOutput(typedCall, this.params.collateralReturnWithData);
+      }
+
+      for (const referenceInput of this.params.referenceInputs) {
+        yield typedCall('CardanoTxReferenceInput', 'CardanoTxItemAck', referenceInput);
+      }
+
+      const witnesses = [];
+
+      for (const path of this.params.witnessPaths) {
+        const {
+          message
+        } = yield typedCall('CardanoTxWitnessRequest', 'CardanoTxWitnessResponse', {
+          path
+        });
+        witnesses.push({
+          type: hdTransport.Messages.CardanoTxWitnessType[message.type],
+          pubKey: message.pub_key,
+          signature: message.signature,
+          chainCode: message.chain_code
+        });
+      }
+
+      const {
+        message: txBodyHashMessage
+      } = yield typedCall('CardanoTxHostAck', 'CardanoTxBodyHash');
+      yield typedCall('CardanoTxHostAck', 'CardanoSignTxFinished');
+      return {
+        hash: txBodyHashMessage.tx_hash,
+        witnesses,
+        auxiliaryDataSupplement
+      };
+    });
+  }
+
+  run() {
+    return this.signTx();
+  }
+
+}
+
 var ApiMethods = /*#__PURE__*/Object.freeze({
   __proto__: null,
   searchDevices: SearchDevices,
@@ -25802,7 +27061,10 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
   xrpSignTransaction: XrpGetAddress,
   suiGetAddress: SuiGetAddress,
   suiGetPublicKey: SuiGetPublicKey,
-  suiSignTransaction: SuiSignTransaction
+  suiSignTransaction: SuiSignTransaction,
+  cardanoGetAddress: CardanoGetAddress,
+  cardanoGetPublicKey: CardanoGetPublicKey,
+  cardanoSignTransaction: CardanoSignTransaction
 });
 
 function findMethod(message) {
@@ -25823,18 +27085,6 @@ function findMethod(message) {
   throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, `Method ${method} is not set`);
 }
 
-const safeThrowError = error => {
-  if (error instanceof hdShared.HardwareError) {
-    throw error;
-  } else if (error.code === 'ERR_NETWORK') {
-    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeNotInstalled);
-  } else if (error.code === 'ECONNABORTED') {
-    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeTimeoutError);
-  } else {
-    throw hdShared.ERRORS.TypedError(error);
-  }
-};
-
 const resolveAfter = (msec, value) => new Promise(resolve => {
   setTimeout(resolve, msec, value);
 });
@@ -25954,7 +27204,8 @@ const Log = getLogger(exports.d0.Core);
 const parseInitOptions = method => ({
   initSession: method === null || method === void 0 ? void 0 : method.payload.initSession,
   passphraseState: method === null || method === void 0 ? void 0 : method.payload.passphraseState,
-  deviceId: method === null || method === void 0 ? void 0 : method.payload.deviceId
+  deviceId: method === null || method === void 0 ? void 0 : method.payload.deviceId,
+  deriveCardano: method === null || method === void 0 ? void 0 : method.name.startsWith('cardano')
 });
 
 let _core;
@@ -72173,7 +73424,7 @@ module.exports = {"i8":"6.5.4"};
 /***/ ((module) => {
 
 "use strict";
-module.exports = JSON.parse('{"name":"@onekeyfe/hd-core","version":"0.2.8","description":"> TODO: description","author":"OneKey","homepage":"https://github.com/OneKeyHQ/hardware-js-sdk#readme","license":"ISC","main":"dist/index.js","types":"dist/index.d.ts","repository":{"type":"git","url":"git+https://github.com/OneKeyHQ/hardware-js-sdk.git"},"publishConfig":{"access":"public"},"scripts":{"dev":"rimraf dist && rollup -c ../../build/rollup.config.js -w","build":"rimraf dist && rollup -c ../../build/rollup.config.js","lint":"eslint .","lint:fix":"eslint . --fix"},"bugs":{"url":"https://github.com/OneKeyHQ/hardware-js-sdk/issues"},"dependencies":{"@onekeyfe/hd-shared":"^0.2.8","@onekeyfe/hd-transport":"^0.2.8","axios":"^0.27.2","bignumber.js":"^9.0.2","jszip":"^3.10.1","parse-uri":"^1.0.7","semver":"^7.3.7"},"peerDependencies":{"@noble/hashes":"^1.1.3","ripple-keypairs":"^1.1.4"},"devDependencies":{"@noble/hashes":"^1.1.3","@types/parse-uri":"^1.0.0","@types/semver":"^7.3.9","ripple-keypairs":"^1.1.4"}}');
+module.exports = JSON.parse('{"name":"@onekeyfe/hd-core","version":"0.2.10","description":"> TODO: description","author":"OneKey","homepage":"https://github.com/OneKeyHQ/hardware-js-sdk#readme","license":"ISC","main":"dist/index.js","types":"dist/index.d.ts","repository":{"type":"git","url":"git+https://github.com/OneKeyHQ/hardware-js-sdk.git"},"publishConfig":{"access":"public"},"scripts":{"dev":"rimraf dist && rollup -c ../../build/rollup.config.js -w","build":"rimraf dist && rollup -c ../../build/rollup.config.js","lint":"eslint .","lint:fix":"eslint . --fix"},"bugs":{"url":"https://github.com/OneKeyHQ/hardware-js-sdk/issues"},"dependencies":{"@onekeyfe/hd-shared":"^0.2.10","@onekeyfe/hd-transport":"^0.2.10","axios":"^0.27.2","bignumber.js":"^9.0.2","jszip":"^3.10.1","parse-uri":"^1.0.7","semver":"^7.3.7"},"peerDependencies":{"@noble/hashes":"^1.1.3","ripple-keypairs":"^1.1.4"},"devDependencies":{"@noble/hashes":"^1.1.3","@types/parse-uri":"^1.0.0","@types/semver":"^7.3.9","ripple-keypairs":"^1.1.4"}}');
 
 /***/ })
 
@@ -74712,7 +75963,7 @@ const src_init = async settings => {
 
   try {
     await init({ ..._settings,
-      version: "0.2.8"
+      version: "0.2.10"
     });
     return true;
   } catch (e) {