@onekeyfe/hd-core 0.2.8 → 0.2.9

package/src/api/cardano/CardanoSignTransaction.ts

@@ -0,0 +1,309 @@
+import { BaseMethod } from '../BaseMethod';
+import { PROTO } from '../../constants';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validateParams } from '../helpers/paramsValidator';
+import {
+  transformInput,
+  Path,
+  CollateralInputWithPath,
+  transformCollateralInput,
+  transformReferenceInput,
+} from './helper/cardanoInputs';
+import { transformOutput, sendOutput } from './helper/cardanoOutputs';
+import { transformCertificate } from './helper/certificate';
+import { tokenBundleToProto } from './helper/token';
+import {
+  transformAuxiliaryData,
+  modifyAuxiliaryDataForBackwardsCompatibility,
+} from './helper/auxiliaryData';
+import { gatherWitnessPaths } from './helper/witnesses';
+import { validatePath } from '../helpers/pathUtils';
+import type {
+  CertificateWithPoolOwnersAndRelays,
+  AssetGroupWithTokens,
+  CardanoSignedTxData,
+  CardanoSignedTxWitness,
+  CardanoAuxiliaryDataSupplement,
+} from '../../types/api/cardano';
+
+export default class CardanoSignTransaction extends BaseMethod<any> {
+  hasBundle?: boolean;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+
+    this.hasBundle = !!this.payload?.bundle;
+
+    const { payload } = this;
+
+    // validate incoming parameters
+    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: CertificateWithPoolOwnersAndRelays[] = [];
+    if (payload.certificates) {
+      certificatesWithPoolOwnersAndRelays = payload.certificates.map(transformCertificate);
+    }
+
+    let withdrawals: PROTO.CardanoTxWithdrawal[] = [];
+    if (payload.withdrawals) {
+      withdrawals = payload.withdrawals.map((withdrawal: any) => {
+        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: AssetGroupWithTokens[] = [];
+    if (payload.mint) {
+      mint = tokenBundleToProto(payload.mint);
+    }
+
+    let auxiliaryData;
+    if (payload.auxiliaryData) {
+      auxiliaryData = transformAuxiliaryData(payload.auxiliaryData);
+    }
+
+    let additionalWitnessRequests: Path[] = [];
+    if (payload.additionalWitnessRequests) {
+      additionalWitnessRequests = payload.additionalWitnessRequests.map((witnessRequest: any) =>
+        validatePath(witnessRequest, 3)
+      );
+    }
+
+    let collateralInputsWithPath: CollateralInputWithPath[] = [];
+    if (payload.collateralInputs) {
+      collateralInputsWithPath = payload.collateralInputs.map(transformCollateralInput);
+    }
+
+    // @ts-expect-error
+    let requiredSigners: PROTO.CardanoTxRequiredSigner[] = [];
+    if (payload.requiredSigners) {
+      requiredSigners = payload.requiredSigners.map((requiredSigner: any) => {
+        validateParams(requiredSigner, [{ name: 'keyHash', type: 'string' }]);
+        return {
+          key_path: requiredSigner.keyPath ? validatePath(requiredSigner.keyPath, 3) : undefined,
+          key_hash: requiredSigner.keyHash,
+          // @ts-expect-error
+        } as PROTO.CardanoTxRequiredSigner;
+      });
+    }
+
+    const collateralReturnWithData = payload.collateralReturn
+      ? transformOutput(payload.collateralReturn)
+      : undefined;
+
+    // @ts-expect-error
+    let referenceInputs: PROTO.CardanoTxReferenceInput[] = [];
+    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
+          : PROTO.CardanoDerivationType.ICARUS_TREZOR,
+      includeNetworkId: payload.includeNetworkId,
+    };
+  }
+
+  async signTx(): Promise<CardanoSignedTxData> {
+    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,
+    };
+
+    // init
+    await typedCall('CardanoSignTxInit', 'CardanoTxItemAck', signTxInitMessage);
+    // inputs
+    for (const { input } of this.params.inputsWithPath) {
+      await typedCall('CardanoTxInput', 'CardanoTxItemAck', input);
+    }
+    // outputs and tokens
+    for (const outputWithData of this.params.outputsWithData) {
+      await sendOutput(typedCall, outputWithData);
+    }
+    // certificates, owners and relays
+    for (const { certificate, poolOwners, poolRelays } of this.params
+      .certificatesWithPoolOwnersAndRelays) {
+      await typedCall('CardanoTxCertificate', 'CardanoTxItemAck', certificate);
+      for (const poolOwner of poolOwners) {
+        await typedCall('CardanoPoolOwner', 'CardanoTxItemAck', poolOwner);
+      }
+      for (const poolRelay of poolRelays) {
+        await typedCall('CardanoPoolRelayParameters', 'CardanoTxItemAck', poolRelay);
+      }
+    }
+    // withdrawals
+    for (const withdrawal of this.params.withdrawals) {
+      await typedCall('CardanoTxWithdrawal', 'CardanoTxItemAck', withdrawal);
+    }
+    // auxiliary data
+    let auxiliaryDataSupplement: CardanoAuxiliaryDataSupplement | undefined;
+    if (this.params.auxiliaryData) {
+      const { catalyst_registration_parameters } = this.params.auxiliaryData;
+      if (catalyst_registration_parameters) {
+        this.params.auxiliaryData = modifyAuxiliaryDataForBackwardsCompatibility(
+          this.params.auxiliaryData
+        );
+      }
+
+      const { message } = await typedCall(
+        'CardanoTxAuxiliaryData',
+        'CardanoTxAuxiliaryDataSupplement',
+        this.params.auxiliaryData
+      );
+
+      const auxiliaryDataType: any = PROTO.CardanoTxAuxiliaryDataSupplementType[message.type];
+      if (auxiliaryDataType !== PROTO.CardanoTxAuxiliaryDataSupplementType.NONE) {
+        auxiliaryDataSupplement = {
+          type: auxiliaryDataType,
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          auxiliaryDataHash: message.auxiliary_data_hash!,
+          catalystSignature: message.catalyst_signature,
+        };
+      }
+      await typedCall('CardanoTxHostAck', 'CardanoTxItemAck');
+    }
+    // mint
+    if (this.params.mint.length > 0) {
+      await typedCall('CardanoTxMint', 'CardanoTxItemAck', {
+        asset_groups_count: this.params.mint.length,
+      });
+      for (const assetGroup of this.params.mint) {
+        await typedCall('CardanoAssetGroup', 'CardanoTxItemAck', {
+          policy_id: assetGroup.policyId,
+          tokens_count: assetGroup.tokens.length,
+        });
+        for (const token of assetGroup.tokens) {
+          await typedCall('CardanoToken', 'CardanoTxItemAck', token);
+        }
+      }
+    }
+    // collateral inputs
+    for (const { collateralInput } of this.params.collateralInputsWithPath) {
+      // @ts-expect-error
+      await typedCall('CardanoTxCollateralInput', 'CardanoTxItemAck', collateralInput);
+    }
+    // required signers
+    for (const requiredSigner of this.params.requiredSigners) {
+      // @ts-expect-error
+      await typedCall('CardanoTxRequiredSigner', 'CardanoTxItemAck', requiredSigner);
+    }
+    // collateral return
+    if (this.params.collateralReturnWithData) {
+      await sendOutput(typedCall, this.params.collateralReturnWithData);
+    }
+    // reference inputs
+    for (const referenceInput of this.params.referenceInputs) {
+      // @ts-expect-error
+      await typedCall('CardanoTxReferenceInput', 'CardanoTxItemAck', referenceInput);
+    }
+    // witnesses
+    const witnesses: CardanoSignedTxWitness[] = [];
+    for (const path of this.params.witnessPaths) {
+      const { message } = await typedCall('CardanoTxWitnessRequest', 'CardanoTxWitnessResponse', {
+        path,
+      });
+      witnesses.push({
+        type: PROTO.CardanoTxWitnessType[message.type] as any,
+        pubKey: message.pub_key,
+        signature: message.signature,
+        chainCode: message.chain_code,
+      });
+    }
+    // tx hash
+    const { message: txBodyHashMessage } = await typedCall('CardanoTxHostAck', 'CardanoTxBodyHash');
+    // finish
+    await typedCall('CardanoTxHostAck', 'CardanoSignTxFinished');
+
+    return { hash: txBodyHashMessage.tx_hash, witnesses, auxiliaryDataSupplement };
+  }
+
+  run() {
+    return this.signTx();
+  }
+}

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

@@ -0,0 +1,118 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { validatePath } from '../../helpers/pathUtils';
+import { validateParams } from '../../helpers/paramsValidator';
+import { PROTO } from '../../../constants';
+import type { CardanoAddressParameters } from '../../../types/api/cardano';
+
+export const validateAddressParameters = (addressParameters: CardanoAddressParameters) => {
+  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 },
+    ]);
+  }
+};
+
+export const addressParametersToProto = (
+  addressParameters: CardanoAddressParameters
+): PROTO.CardanoAddressParametersType => {
+  let path: number[] = [];
+  if (addressParameters.path) {
+    path = validatePath(addressParameters.path, 3);
+  }
+
+  let stakingPath: number[] = [];
+  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,
+  };
+};
+
+export const addressParametersFromProto = (
+  addressParameters: PROTO.CardanoAddressParametersType
+): CardanoAddressParameters => {
+  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,
+  };
+};
+
+export const modifyAddressParametersForBackwardsCompatibility = (
+  address_parameters: PROTO.CardanoAddressParametersType
+): PROTO.CardanoAddressParametersType => {
+  if (address_parameters.address_type === PROTO.CardanoAddressType.REWARD) {
+    // older firmware expects reward address path in path field instead of staking path
+    let { address_n, address_n_staking } = address_parameters;
+
+    if (address_n.length > 0 && address_n_staking.length > 0) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        `Only stakingPath is allowed for CardanoAddressType.REWARD`
+      );
+    }
+
+    if (address_n.length > 0) {
+      address_n_staking = address_n;
+      address_n = [];
+    }
+    // TODO: version check
+    // if (device.atLeast(['0', '2.4.3'])) {
+    // } else if (address_n_staking.length > 0) {
+    //   address_n = address_n_staking;
+    //   address_n_staking = [];
+    // }
+
+    return {
+      ...address_parameters,
+      address_n,
+      address_n_staking,
+    };
+  }
+
+  return address_parameters;
+};

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

@@ -0,0 +1,74 @@
+import {
+  validateAddressParameters,
+  addressParametersToProto,
+  modifyAddressParametersForBackwardsCompatibility,
+} from './addressParameters';
+import { validateParams } from '../../helpers/paramsValidator';
+import { validatePath } from '../../helpers/pathUtils';
+import type {
+  CardanoAuxiliaryData,
+  CardanoCatalystRegistrationParameters,
+} from '../../../types/api/cardano';
+import { PROTO } from '../../../constants';
+
+const transformCatalystRegistrationParameters = (
+  catalystRegistrationParameters: CardanoCatalystRegistrationParameters
+): PROTO.CardanoCatalystRegistrationParametersType => {
+  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,
+  };
+};
+
+export const transformAuxiliaryData = (
+  auxiliaryData: CardanoAuxiliaryData
+): PROTO.CardanoTxAuxiliaryData => {
+  validateParams(auxiliaryData, [
+    {
+      name: 'hash',
+      type: 'string',
+    },
+  ]);
+
+  let catalystRegistrationParameters;
+  if (auxiliaryData.catalystRegistrationParameters) {
+    catalystRegistrationParameters = transformCatalystRegistrationParameters(
+      auxiliaryData.catalystRegistrationParameters
+    );
+  }
+
+  return {
+    hash: auxiliaryData.hash,
+    catalyst_registration_parameters: catalystRegistrationParameters,
+  };
+};
+
+export const modifyAuxiliaryDataForBackwardsCompatibility = (
+  auxiliary_data: PROTO.CardanoTxAuxiliaryData
+): PROTO.CardanoTxAuxiliaryData => {
+  const { catalyst_registration_parameters } = auxiliary_data;
+  if (catalyst_registration_parameters) {
+    catalyst_registration_parameters.reward_address_parameters =
+      modifyAddressParametersForBackwardsCompatibility(
+        catalyst_registration_parameters.reward_address_parameters
+      );
+
+    return {
+      ...auxiliary_data,
+      catalyst_registration_parameters,
+    };
+  }
+
+  return auxiliary_data;
+};

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

@@ -0,0 +1,56 @@
+import { validateParams } from '../../helpers/paramsValidator';
+import { validatePath } from '../../helpers/pathUtils';
+import type { PROTO } from '../../../constants';
+
+export type Path = number[];
+
+export type InputWithPath = {
+  input: PROTO.CardanoTxInput;
+  path?: Path;
+};
+
+export type CollateralInputWithPath = {
+  // @ts-expect-error
+  collateralInput: PROTO.CardanoTxCollateralInput;
+  path?: Path;
+};
+
+export const transformInput = (input: any): InputWithPath => {
+  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,
+  };
+};
+
+export const transformCollateralInput = (collateralInput: any): CollateralInputWithPath => {
+  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,
+  };
+};
+
+// @ts-expect-error
+export const transformReferenceInput = (referenceInput: any): PROTO.CardanoTxReferenceInput => {
+  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,
+  };
+};

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

@@ -0,0 +1,89 @@
+import { validateParams } from '../../helpers/paramsValidator';
+import { tokenBundleToProto } from './token';
+import { addressParametersToProto, validateAddressParameters } from './addressParameters';
+import { hexStringByteLength, sendChunkedHexString } from './utils';
+import type { PROTO } from '../../../constants';
+import type { AssetGroupWithTokens } from '../../../types/api/cardano';
+
+export type OutputWithData = {
+  output: PROTO.CardanoTxOutput;
+  tokenBundle?: AssetGroupWithTokens[];
+  inlineDatum?: string;
+  referenceScript?: string;
+};
+
+export const transformOutput = (output: any): OutputWithData => {
+  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: OutputWithData = {
+    output: {
+      amount: output.amount,
+      asset_groups_count: 0,
+      // @ts-expect-error
+      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;
+};
+
+export const sendOutput = async (typedCall: any, outputWithData: OutputWithData) => {
+  const MAX_CHUNK_SIZE = 1024 * 2; // 1024 hex-encoded bytes
+
+  const { output, tokenBundle, inlineDatum, referenceScript } = outputWithData;
+
+  await typedCall('CardanoTxOutput', 'CardanoTxItemAck', output);
+  if (tokenBundle) {
+    for (const assetGroup of tokenBundle) {
+      await typedCall('CardanoAssetGroup', 'CardanoTxItemAck', {
+        policy_id: assetGroup.policyId,
+        tokens_count: assetGroup.tokens.length,
+      });
+      for (const token of assetGroup.tokens) {
+        await typedCall('CardanoToken', 'CardanoTxItemAck', token);
+      }
+    }
+  }
+
+  if (inlineDatum) {
+    await sendChunkedHexString(typedCall, inlineDatum, MAX_CHUNK_SIZE, 'CardanoTxInlineDatumChunk');
+  }
+
+  if (referenceScript) {
+    await sendChunkedHexString(
+      typedCall,
+      referenceScript,
+      MAX_CHUNK_SIZE,
+      'CardanoTxReferenceScriptChunk'
+    );
+  }
+};