├── .circleci
    └── config.yml
├── .cspell.json
├── .eslintignore
├── .eslintrc.js
├── .flowconfig
├── .gitignore
├── .prettierignore
├── .prettierrc.js
├── CHANGELOG.md
├── LICENSE
├── README.md
├── _typedoc
    └── custom-theme
    │   ├── assets
    │       ├── css
    │       │   └── main.css
    │       ├── images
    │       │   ├── icons.png
    │       │   ├── icons@2x.png
    │       │   ├── widgets.png
    │       │   └── widgets@2x.png
    │       └── js
    │       │   └── main.js
    │   ├── layouts
    │       └── default.hbs
    │   ├── partials
    │       ├── analytics.hbs
    │       ├── breadcrumb.hbs
    │       ├── comment.hbs
    │       ├── footer.hbs
    │       ├── header.hbs
    │       ├── hierarchy.hbs
    │       ├── index.hbs
    │       ├── member.declaration.hbs
    │       ├── member.getterSetter.hbs
    │       ├── member.hbs
    │       ├── member.reference.hbs
    │       ├── member.signature.body.hbs
    │       ├── member.signature.title.hbs
    │       ├── member.signatures.hbs
    │       ├── member.sources.hbs
    │       ├── members.group.hbs
    │       ├── members.hbs
    │       ├── navigation.hbs
    │       ├── parameter.hbs
    │       ├── toc.hbs
    │       ├── toc.root.hbs
    │       ├── type.hbs
    │       ├── typeAndParent.hbs
    │       └── typeParameters.hbs
    │   └── templates
    │       ├── index.hbs
    │       └── reflection.hbs
├── example-node
    ├── index.ts
    └── tsconfig.json
├── package.json
├── src
    ├── Ada.ts
    ├── errors
    │   ├── deviceStatusError.ts
    │   ├── deviceUnsupported.ts
    │   ├── errorBase.ts
    │   ├── index.ts
    │   ├── invalidData.ts
    │   └── invalidDataReason.ts
    ├── interactions
    │   ├── common
    │   │   ├── ins.ts
    │   │   └── types.ts
    │   ├── deriveAddress.ts
    │   ├── deriveNativeScriptHash.ts
    │   ├── getExtendedPublicKeys.ts
    │   ├── getSerial.ts
    │   ├── getVersion.ts
    │   ├── runTests.ts
    │   ├── serialization
    │   │   ├── addressParams.ts
    │   │   ├── cVoteRegistration.ts
    │   │   ├── messageData.ts
    │   │   ├── nativeScript.ts
    │   │   ├── operationalCertificate.ts
    │   │   ├── poolRegistrationCertificate.ts
    │   │   ├── txAuxiliaryData.ts
    │   │   ├── txCertificate.ts
    │   │   ├── txInit.ts
    │   │   ├── txOther.ts
    │   │   └── txOutput.ts
    │   ├── showAddress.ts
    │   ├── signCVote.ts
    │   ├── signMessage.ts
    │   ├── signOperationalCertificate.ts
    │   └── signTx.ts
    ├── parsing
    │   ├── address.ts
    │   ├── cVote.ts
    │   ├── certificate.ts
    │   ├── constants.ts
    │   ├── messageData.ts
    │   ├── nativeScript.ts
    │   ├── network.ts
    │   ├── operationalCertificate.ts
    │   ├── output.ts
    │   ├── poolRegistration.ts
    │   ├── transaction.ts
    │   └── txAuxiliaryData.ts
    ├── tsconfig.json
    ├── types
    │   ├── internal.ts
    │   └── public.ts
    ├── utils.ts
    └── utils
    │   ├── address.ts
    │   ├── assert.ts
    │   ├── parse.ts
    │   └── serialize.ts
├── test
    ├── device-self-test
    │   └── runTestsDevice.test.ts
    ├── integration
    │   ├── __fixtures__
    │   │   ├── deriveAddress.ts
    │   │   ├── deriveNativeScriptHash.ts
    │   │   ├── getExtendedPublicKey.ts
    │   │   ├── signCVote.ts
    │   │   ├── signMessage.ts
    │   │   ├── signOperationalCertificate.ts
    │   │   ├── signTx.ts
    │   │   ├── signTxCVote.ts
    │   │   ├── signTxPlutus.ts
    │   │   ├── signTxPoolRegistration.ts
    │   │   ├── signTxPoolRegistrationRejects.ts
    │   │   ├── signTxRejects.ts
    │   │   └── txElements.ts
    │   ├── deriveAddress.test.ts
    │   ├── deriveNativeScriptHash.test.ts
    │   ├── getExtendedPublicKey.test.ts
    │   ├── getSerial.test.ts
    │   ├── getVersion.test.ts
    │   ├── signCVote.test.ts
    │   ├── signMessage.test.ts
    │   ├── signOperationalCertificate.test.ts
    │   ├── signTx.test.ts
    │   ├── signTxCVote.test.ts
    │   └── signTxPoolRegistration.test.ts
    ├── test_utils.ts
    ├── tsconfig.json
    └── unit
    │   └── parse.test.ts
├── tsconfig.base.json
├── tsconfig.json
├── typedoc.json
├── workspace.code-workspace
└── yarn.lock


/.circleci/config.yml:
--------------------------------------------------------------------------------
  1 | # Javascript Node CircleCI 2.0 configuration file
  2 | #
  3 | # Check https://circleci.com/docs/2.0/language-javascript/ for more details
  4 | #
  5 | version: 2.1
  6 | jobs:
  7 |   build_and_test:
  8 |     docker:
  9 |       - image: cimg/node:18.12
 10 |     working_directory: ~/repo
 11 |     steps:
 12 |       - checkout
 13 |       - run:
 14 |           name: Install system dependencies
 15 |           command: sudo apt-get update && sudo apt-get install -y libusb-1.0-0-dev libudev-dev
 16 | 
 17 |       - restore_cache:
 18 |           key: v2-dependencies-{{ checksum "yarn.lock" }}
 19 |       - run:
 20 |           name: Install dependencies
 21 |           command: yarn install
 22 |       - save_cache:
 23 |           paths:
 24 |             - node_modules
 25 |           key: v2-dependencies-{{ checksum "yarn.lock" }}
 26 | 
 27 |       - run:
 28 |           name: Lint
 29 |           command: yarn lint
 30 |       - run:
 31 |           name: Spellcheck
 32 |           command: yarn spell:check
 33 |       - run:
 34 |           name: Audit dependencies
 35 |           command: yarn audit
 36 |       - run:
 37 |           name: Build
 38 |           command: yarn build
 39 |       - run:
 40 |           name: Try building the example
 41 |           command: yarn tsc -p example-node/tsconfig.json --noEmit
 42 |       - run:
 43 |           name: Try generating the docs
 44 |           command: yarn typedoc
 45 |       - run:
 46 |           name: Try generating and checking flow types
 47 |           # piping output to cat to bypass process.stdout.columns being 0
 48 |           # which causes flowgen console logging to crash
 49 |           # see https://github.com/aws/aws-cdk/issues/2253
 50 |           command: |
 51 |             yarn build:flowtypes | cat
 52 |             yarn run flow
 53 | 
 54 |   update_docs:
 55 |     docker:
 56 |       - image: cimg/node:18.12
 57 |     working_directory: ~/repo
 58 |     steps:
 59 |       - checkout
 60 |       - run:
 61 |           name: Install system dependencies
 62 |           command: sudo apt-get update && sudo apt-get install -y libusb-1.0-0-dev libudev-dev
 63 |       - restore_cache:
 64 |           keys:
 65 |           - v2-dependencies-{{ checksum "yarn.lock" }}
 66 |       - run:
 67 |           name: Install dependencies
 68 |           command: yarn install
 69 |       - save_cache:
 70 |           paths:
 71 |             - node_modules
 72 |           key: v2-dependencies-{{ checksum "yarn.lock" }}
 73 | 
 74 |       - run:
 75 |           name: Get ledgerjs library version
 76 |           command: |
 77 |             LEDGERJS_PACKAGE_VERSION=$(cat package.json \
 78 |             | grep version \
 79 |             | head -1 \
 80 |             | awk -F: '{ print $2 }' \
 81 |             | sed 's/[",]//g')
 82 |             echo $LEDGERJS_PACKAGE_VERSION > ledgerjs_version.tmp
 83 |       - run:
 84 |           name: Build docs
 85 |           command: yarn typedoc --out docs_build/$(cat ledgerjs_version.tmp)
 86 | 
 87 |       - run:
 88 |           name: Generate redirect to current version of docs
 89 |           command: echo '<!DOCTYPE html><html><head><meta http-equiv = "refresh" content = "1; url = ./'$(cat ledgerjs_version.tmp)'" /></head><body></body></html>' > docs_build/index.html
 90 | 
 91 |       - add_ssh_keys:
 92 |           fingerprints:
 93 |             - e4:d2:8d:f4:aa:02:4a:ea:ed:72:00:62:1e:f7:9b:bc
 94 |       - run:
 95 |           name: Setup git
 96 |           command: |
 97 |             git config user.email "ci-build@vacuumlabs.com"
 98 |             git config user.name "ci-build@vacuumlabs.com"
 99 |       - run:
100 |           name: Deploy docs
101 |           command: yarn gh-pages --add --dist docs_build --message "[ci skip] Docs for v$(cat ledgerjs_version.tmp)"
102 | 
103 | 
104 | workflows:
105 |   version: 2
106 |   main_workflow:
107 |     jobs:
108 |       - build_and_test
109 |       - update_docs:
110 |           requires:
111 |             - build_and_test
112 |           filters:
113 |             branches:
114 |               only:
115 |                 - master
116 | 


--------------------------------------------------------------------------------
/.cspell.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "version": "0.2",
 3 |   "language": "en",
 4 |   "ignorePaths": [
 5 |     ".cspell.json",
 6 |     "build",
 7 |     "node_modules",
 8 |     "**/*.tgz",
 9 |     "**/package.json",
10 |     "**/tsconfig.json",
11 |     ".vscode/**",
12 |     "_typedoc"
13 |   ],
14 |   "ignoreRegExpList": [
15 |     "0x[A-Z]{7,25}",
16 |     "\\S{32,}",
17 |     "[A-Za-z0-9+/]+={1,2}",
18 |     "deadbe[ea]f",
19 |     "'[a-z0-9]{16}'"
20 |   ],
21 |   "words": [
22 |     "Adalite",
23 |     "APDU",
24 |     "argparse",
25 |     "basex",
26 |     "bbbc",
27 |     "bech",
28 |     "Benc",
29 |     "bytestring",
30 |     "cardano",
31 |     "cbor",
32 |     "CHAINCODE",
33 |     "chsh",
34 |     "cimg",
35 |     "concats",
36 |     "cryptoprovider",
37 |     "cvote",
38 |     "cword",
39 |     "czvf",
40 |     "Deregisters",
41 |     "deregistration",
42 |     "DEVEL",
43 |     "dpkg",
44 |     "DREP",
45 |     "endians",
46 |     "financials",
47 |     "hwsfile",
48 |     "insertable",
49 |     "jcli",
50 |     "jormungandr",
51 |     "keyhash",
52 |     "Kojn",
53 |     "ledgerhq",
54 |     "ledgerjs",
55 |     "libudev",
56 |     "libusb",
57 |     "multiasset",
58 |     "multidelegation",
59 |     "nargs",
60 |     "opcert",
61 |     "PAYMENTADDRESS",
62 |     "PAYMENTPATH",
63 |     "pkey",
64 |     "policyid",
65 |     "ppershing",
66 |     "PREPROD",
67 |     "pubkey",
68 |     "pubkeys",
69 |     "retcode",
70 |     "scripthash",
71 |     "skey",
72 |     "speculos",
73 |     "STAKINGPATH",
74 |     "Stax",
75 |     "subarray",
76 |     "subparser",
77 |     "subparsers",
78 |     "TLDR",
79 |     "unfixable",
80 |     "uniquifier",
81 |     "uniquify",
82 |     "utxo",
83 |     "vacuumlabs",
84 |     "vkey",
85 |     "votecast",
86 |     "VOTINGPURPOSE",
87 |     "yoroi",
88 |     "zxvf"
89 |   ]
90 | }
91 | 


--------------------------------------------------------------------------------
/.eslintignore:
--------------------------------------------------------------------------------
1 | dist/
2 | docs_generated/
3 | _typedoc/
4 | node_modules/
5 | 


--------------------------------------------------------------------------------
/.eslintrc.js:
--------------------------------------------------------------------------------
 1 | // copied from https://github.com/vacuumlabs/nufi and adjusted
 2 | module.exports = {
 3 |   extends: [
 4 |     'plugin:@typescript-eslint/recommended',
 5 |     'plugin:import/typescript',
 6 |     'vacuumlabs',
 7 |     'prettier',
 8 |   ],
 9 |   env: {
10 |     "es6": true,
11 |     "node": true,
12 |     "mocha": true
13 |   },
14 |   rules: {
15 |     '@typescript-eslint/no-explicit-any': [
16 |       'error',
17 |       {
18 |         ignoreRestArgs: true,
19 |       },
20 |     ],
21 |     '@typescript-eslint/no-var-requires': 'off',
22 |     '@typescript-eslint/explicit-module-boundary-types': 'off',
23 | 
24 |     // https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/no-use-before-define.md#how-to-use
25 |     // note you must disable the base rule as it can report incorrect errors
26 |     'no-use-before-define': 'off',
27 |     '@typescript-eslint/no-use-before-define': ['error'],
28 |     'no-unused-vars': 'off',
29 |     '@typescript-eslint/no-unused-vars': ['error', {argsIgnorePattern: '^_'}],
30 |     // Why detect cycles: https://spin.atomicobject.com/2018/06/25/circular-dependencies-javascript
31 |     // TLDR - memory crashes, tangled architecture, unreadable code, undefined imports
32 |     'import/no-cycle': [
33 |       'error',
34 |     ],
35 |     'import/no-extraneous-dependencies': ['error'],
36 |     'no-duplicate-imports': 'off',
37 |     'import/no-duplicates': ['error'],
38 |     'spaced-comment': ['error', 'always', {block: {balanced: true}}],
39 |     'quote-props': ['error', 'consistent'],
40 |     '@typescript-eslint/no-redeclare': ['error'],
41 | 
42 |     // redundant, suggested in https://github.com/typescript-eslint/typescript-eslint/issues/4510
43 |     'consistent-return': 'off',
44 |   },
45 |   parser: '@typescript-eslint/parser',
46 |   parserOptions: {
47 |     ecmaVersion: 2020,
48 |     sourceType: 'module',
49 |     createDefaultProgram: true,
50 |   },
51 |   settings: {
52 |     'import/resolver': {
53 |       node: {
54 |         extensions: ['.js', '.ts'],
55 |       },
56 |     },
57 |   },
58 |   plugins: ['import'],
59 | }
60 | 


--------------------------------------------------------------------------------
/.flowconfig:
--------------------------------------------------------------------------------
 1 | [ignore]
 2 | .*/node_modules/resolve/test/resolver/malformed_package_json/package.json
 3 | 
 4 | [include]
 5 | 
 6 | [untyped]
 7 | 
 8 | [libs]
 9 | 
10 | [lints]
11 | 
12 | [options]
13 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | dist
2 | node_modules
3 | .vscode
4 | docs_generated/
5 | 


--------------------------------------------------------------------------------
/.prettierignore:
--------------------------------------------------------------------------------
 1 | .eslintrc.js
 2 | README.md
 3 | CHANGELOG.md
 4 | docs
 5 | docs_generated/
 6 | .vscode
 7 | .circleci
 8 | dist/
 9 | _typedoc/
10 | 


--------------------------------------------------------------------------------
/.prettierrc.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 |   bracketSpacing: false,
3 |   quoteProps: 'consistent',
4 |   semi: false,
5 |   singleQuote: true,
6 |   trailingComma: 'all',
7 | }
8 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ![image](https://user-images.githubusercontent.com/837681/53001830-d7c8a600-342b-11e9-9038-e745cc91e543.png)
 2 | 
 3 | ### @cardano-foundation/ledgerjs-hw-app-cardano
 4 | 
 5 | JS Library for communication with Ledger Hardware Wallets.
 6 | This library is compatible with the [Cardano ADA Ledger Application](https://github.com/cardano-foundation/ledger-app-cardano).
 7 | 
 8 | Note: this project comes with both [Typescript](https://www.typescriptlang.org/) and [Flow](https://flow.org/) type definitions, but only the Typescript ones are checked for correctness.
 9 | 
10 | ### Example code
11 | 
12 | Example code interacting with `hw-app-cardano` is provided in `example-node` directory.
13 | You can execute it with the `yarn run-example` command.
14 | 
15 | ### Tests
16 | 
17 | Automated tests are provided. There are two types of tests
18 | 
19 | 1. `yarn test-integration`. Tests JS API and integration with the physical Ledger device.
20 |     * `yarn test-speculos`. Runs the `test-integration` test against the Speculos emulator.
21 | 
22 | 2. `yarn device-self-test`. Runs tests defined in the application code of the Ledger application, requires development build of the application.
23 |     * `yarn device-self-test-speculos`. Runs `yarn device-self-test` on Speculos (useful because the full app in debug mode with self-tests does not fit on Nano S).
24 | 
25 | Note that for these tests it is advisable to install the developer build of the Cardano app with _headless_ mode enabled unless you want to verify the UI flows, otherwise you will need a significant amount of time to manually confirm all prompts on the device.
26 | 
27 | #### Speculos
28 | 
29 | To run the Speculos emulator, you first need to install it. The [Speculos documentation](https://speculos.ledger.com/installation/build.html) should take you through the installation process.
30 | After installing you can start the emulator with the correct seed:
31 | ``
32 | speculos /path/to/your/ledger-app-cardano-shelley/bin/app.elf --seed "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about" --display headless
33 | ``
34 | *Note: replace `/path/to/your/ledger-app-cardano-shelley/bin/app.elf` with a path to the `app.elf` file of the Cardano ledger app.*
35 | This will start the emulator with a TCP server listening on port 9999 for APDU messages and a web interface running on port 5000 (http://localhost:5000) which can be used to interact with the app.
36 | The `--display headless` option just hides any window UI.
37 | 
38 | ### Documentation
39 | 
40 | - you can build the docs by running `yarn gen-docs` and then navigate to docs_generated/index.html
41 | - generated docs can also be found at (https://vacuumlabs.github.io/ledgerjs-cardano-shelley)
42 | - [CHANGELOG](CHANGELOG.md)
43 | 


--------------------------------------------------------------------------------
/_typedoc/custom-theme/assets/images/icons.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cardano-foundation/ledgerjs-hw-app-cardano/ee543694deaa9dd39d049d3efb888515bf058faa/_typedoc/custom-theme/assets/images/icons.png


--------------------------------------------------------------------------------
/_typedoc/custom-theme/assets/images/icons@2x.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cardano-foundation/ledgerjs-hw-app-cardano/ee543694deaa9dd39d049d3efb888515bf058faa/_typedoc/custom-theme/assets/images/icons@2x.png


--------------------------------------------------------------------------------
/_typedoc/custom-theme/assets/images/widgets.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cardano-foundation/ledgerjs-hw-app-cardano/ee543694deaa9dd39d049d3efb888515bf058faa/_typedoc/custom-theme/assets/images/widgets.png


--------------------------------------------------------------------------------
/_typedoc/custom-theme/assets/images/widgets@2x.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cardano-foundation/ledgerjs-hw-app-cardano/ee543694deaa9dd39d049d3efb888515bf058faa/_typedoc/custom-theme/assets/images/widgets@2x.png


--------------------------------------------------------------------------------
/_typedoc/custom-theme/layouts/default.hbs:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html class="default no-js">
 3 | <head>
 4 |     <meta charset="utf-8">
 5 |     <meta http-equiv="X-UA-Compatible" content="IE=edge">
 6 |     <title>{{#ifCond model.name '==' project.name}}{{project.name}}{{else}}{{model.name}} | {{project.name}}{{/ifCond}}</title>
 7 |     <meta name="description" content="Documentation for {{project.name}}">
 8 |     <meta name="viewport" content="width=device-width, initial-scale=1">
 9 | 
10 |     <link rel="stylesheet" href="{{relativeURL "assets/css/main.css"}}">
11 |     <script async src="{{relativeURL "assets/js/search.js"}}" id="search-script"></script>
12 | </head>
13 | <body>
14 | 
15 | {{> header}}
16 | 
17 | <div class="container container-main">
18 |     <div class="row">
19 |         <div class="col-8 col-content">
20 |             {{{contents}}}
21 |         </div>
22 |         <div class="col-4 col-menu menu-sticky-wrap menu-highlight">
23 |             <nav class="tsd-navigation primary">
24 |                 <ul>
25 |                     {{#each navigation.children}}
26 |                         {{> navigation}}
27 |                     {{/each}}
28 |                 </ul>
29 |             </nav>
30 | 
31 |             <nav class="tsd-navigation secondary menu-sticky">
32 |                 <ul class="before-current">
33 |                     {{#each toc.children}}
34 |                         {{> toc.root}}
35 |                     {{/each}}
36 |                 </ul>
37 |             </nav>
38 |         </div>
39 |     </div>
40 | </div>
41 | 
42 | {{> footer}}
43 | 
44 | <div class="overlay"></div>
45 | <script src="{{relativeURL "assets/js/main.js"}}"></script>
46 | 
47 | {{> analytics}}
48 | 
49 | </body>
50 | </html>
51 | 


--------------------------------------------------------------------------------
/_typedoc/custom-theme/partials/analytics.hbs:
--------------------------------------------------------------------------------
 1 | {{#if settings.gaID}}
 2 |     <script>
 3 |         (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
 4 |             (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
 5 |                 m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
 6 |         })(window,document,'script','//www.google-analytics.com/analytics.js','ga');
 7 | 
 8 |         ga('create', '{{settings.gaID}}', '{{settings.gaSite}}');
 9 |         ga('send', 'pageview');
10 |     </script>
11 | {{/if}}


--------------------------------------------------------------------------------
/_typedoc/custom-theme/partials/breadcrumb.hbs:
--------------------------------------------------------------------------------
 1 | {{#if parent}}
 2 |     {{#with parent}}{{> breadcrumb}}{{/with}}
 3 |     <li>
 4 |         {{#if url}}
 5 |             <a href="{{relativeURL url}}">{{name}}</a>
 6 |         {{else}}
 7 |             <span>{{name}}</span>
 8 |         {{/if}}
 9 |     </li>
10 | {{else}}
11 |     {{#if url}}
12 |         <li>
13 |             <a href="{{relativeURL url}}">{{ name }}</a>
14 |         </li>
15 |     {{/if}}
16 | {{/if}}
17 | 


--------------------------------------------------------------------------------
/_typedoc/custom-theme/partials/comment.hbs:
--------------------------------------------------------------------------------
 1 | {{#with comment}}
 2 |     {{#if hasVisibleComponent}}
 3 |         <div class="tsd-comment tsd-typography">
 4 |             {{#if shortText}}
 5 |                 <div class="lead">
 6 |                     {{#markdown}}{{{shortText}}}{{/markdown}}
 7 |                 </div>
 8 |             {{/if}}
 9 |             {{#if text}}
10 |                 {{#markdown}}{{{text}}}{{/markdown}}
11 |             {{/if}}
12 |             {{#if tags}}
13 |                 <dl class="tsd-comment-tags">
14 |                     {{#each tags}}
15 |                         <dt>{{tagName}}</dt>
16 |                         <dd>{{#markdown}}{{{text}}}{{/markdown}}</dd>
17 |                     {{/each}}
18 |                 </dl>
19 |             {{/if}}
20 |         </div>
21 |     {{/if}}
22 | {{/with}}


--------------------------------------------------------------------------------
/_typedoc/custom-theme/partials/footer.hbs:
--------------------------------------------------------------------------------
 1 | 
 2 | <footer{{#unless settings.hideGenerator}} class="with-border-bottom"{{/unless}}>
 3 |     <div class="container">
 4 |         <h2>Legend</h2>
 5 |         <div class="tsd-legend-group">
 6 |             {{#each legend}}
 7 |                 <ul class="tsd-legend">
 8 |                     {{#each .}}
 9 |                         <li class="{{#compact}}{{#each classes}} {{.}}{{/each}}{{/compact}}"><span class="tsd-kind-icon">{{name}}</span></li>
10 |                     {{/each}}
11 |                 </ul>
12 |             {{/each}}
13 |         </div>
14 |     </div>
15 | </footer>
16 | 
17 | {{#unless settings.hideGenerator}}
18 |     <div class="container tsd-generator">
19 |         <p>Generated using <a href="https://typedoc.org/" target="_blank">TypeDoc</a></p>
20 |     </div>
21 | {{/unless}}


--------------------------------------------------------------------------------
/_typedoc/custom-theme/partials/header.hbs:
--------------------------------------------------------------------------------
 1 | <header>
 2 |     <div class="tsd-page-toolbar">
 3 |         <div class="container">
 4 |             <div class="table-wrap">
 5 |                 <div class="table-cell" id="tsd-search" data-index="{{relativeURL "assets/js/search.json"}}" data-base="{{relativeURL "./"}}">
 6 |                     <div class="field">
 7 |                         <label for="tsd-search-field" class="tsd-widget search no-caption">Search</label>
 8 |                         <input id="tsd-search-field" type="text" />
 9 |                     </div>
10 | 
11 |                     <ul class="results">
12 |                         <li class="state loading">Preparing search index...</li>
13 |                         <li class="state failure">The search index is not available</li>
14 |                     </ul>
15 | 
16 |                     <a href="{{relativeURL "index.html"}}" class="title">{{project.name}}</a>
17 |                 </div>
18 | 
19 |                 <div class="table-cell" id="tsd-widgets">
20 |                     <div id="tsd-filter">
21 |                         <a href="#" class="tsd-widget options no-caption" data-toggle="options">Options</a>
22 |                         <div class="tsd-filter-group">
23 |                             <div class="tsd-select" id="tsd-filter-visibility">
24 |                                 <span class="tsd-select-label">All</span>
25 |                                 <ul class="tsd-select-list">
26 |                                     <li data-value="public">Public</li>
27 |                                     <li data-value="protected">Public/Protected</li>
28 |                                     <li data-value="private" class="selected">All</li>
29 |                                 </ul>
30 |                             </div>
31 | 
32 |                             <input type="checkbox" id="tsd-filter-inherited" checked />
33 |                             <label class="tsd-widget" for="tsd-filter-inherited">Inherited</label>
34 | 
35 |                             {{#unless settings.excludeExternals}}
36 |                                 <input type="checkbox" id="tsd-filter-externals" checked />
37 |                                 <label class="tsd-widget" for="tsd-filter-externals">Externals</label>
38 |                             {{/unless}}
39 |                         </div>
40 |                     </div>
41 | 
42 |                     <a href="#" class="tsd-widget menu no-caption" data-toggle="menu">Menu</a>
43 |                 </div>
44 |             </div>
45 |         </div>
46 |     </div>
47 |     <div class="tsd-page-title">
48 |         <div class="container">
49 |             {{#if model.parent}} {{! Don't show breadcrumbs on main project page, it is the root page. !}}
50 |                 <ul class="tsd-breadcrumb">
51 |                     {{#with model}}{{> breadcrumb}}{{/with}}
52 |                 </ul>
53 |             {{/if}}
54 |             <h1>{{#compact}}
55 |                 {{#ifCond model.kindString "!==" "Project" }}
56 |                     {{model.kindString}}&nbsp;
57 |                 {{/ifCond}}
58 |                 {{model.name}}
59 |                 {{#if model.typeParameters}}
60 |                     &lt;
61 |                     {{#each model.typeParameters}}
62 |                         {{#if @index}},&nbsp;{{/if}}
63 |                         {{name}}
64 |                     {{/each}}
65 |                     &gt;
66 |                 {{/if}}
67 |             {{/compact}}</h1>
68 |         </div>
69 |     </div>
70 | </header>
71 | 


--------------------------------------------------------------------------------
/_typedoc/custom-theme/partials/hierarchy.hbs:
--------------------------------------------------------------------------------
 1 | <ul class="tsd-hierarchy">
 2 |     {{#each types}}
 3 |         <li>
 4 |             {{#if ../isTarget}}
 5 |                 <span class="target">{{this}}</span>
 6 |             {{else}}
 7 |                 {{#compact}}{{> type}}{{/compact}}
 8 |             {{/if}}
 9 | 
10 |             {{#if @last}}
11 |                 {{#with ../next}}
12 |                     {{> hierarchy}}
13 |                 {{/with}}
14 |             {{/if}}
15 |         </li>
16 |     {{/each}}
17 | </ul>
18 | 


--------------------------------------------------------------------------------
/_typedoc/custom-theme/partials/index.hbs:
--------------------------------------------------------------------------------
 1 | {{#if categories}}
 2 |     <section class="tsd-panel-group tsd-index-group">
 3 |         <h2>Index</h2>
 4 |         <section class="tsd-panel tsd-index-panel">
 5 |             <div class="tsd-index-content">
 6 |                 {{#each categories}}
 7 |                     <section class="tsd-index-section">
 8 |                         <h3>{{title}}</h3>
 9 |                         <ul class="tsd-index-list">
10 |                             {{#each children}}
11 |                                 <li class="{{cssClasses}}"><a href="{{relativeURL url}}" class="tsd-kind-icon">{{#if name}}{{{wbr name}}}{{else}}<em>{{{wbr kindString}}}</em>{{/if}}</a></li>
12 |                             {{/each}}
13 |                         </ul>
14 |                     </section>
15 |                 {{/each}}
16 |             </div>
17 |         </section>
18 |     </section>
19 | {{else}}
20 |     {{#if groups}}
21 |     <section class="tsd-panel-group tsd-index-group">
22 |         <h2>Index</h2>
23 |         <section class="tsd-panel tsd-index-panel">
24 |             <div class="tsd-index-content">
25 |                 {{#each groups}}
26 |                     <section class="tsd-index-section {{cssClasses}}">
27 |                         {{#if categories}}
28 |                             {{#each categories}}
29 |                                 <h3>{{#if title}}{{title}} {{/if}}{{../title}}</h3>
30 |                                 <ul class="tsd-index-list">
31 |                                     {{#each children}}
32 |                                         <li class="{{cssClasses}}"><a href="{{relativeURL url}}" class="tsd-kind-icon">{{#if name}}{{{wbr name}}}{{else}}<em>{{{wbr kindString}}}</em>{{/if}}</a></li>
33 |                                     {{/each}}
34 |                                 </ul>
35 |                             {{/each}}
36 |                         {{else}}
37 |                             <h3>{{title}}</h3>
38 |                             <ul class="tsd-index-list">
39 |                                 {{#each children}}
40 |                                     <li class="{{cssClasses}}"><a href="{{relativeURL url}}" class="tsd-kind-icon">{{#if name}}{{{wbr name}}}{{else}}<em>{{{wbr kindString}}}</em>{{/if}}</a></li>
41 |                                 {{/each}}
42 |                             </ul>
43 |                         {{/if}}
44 |                     </section>
45 |                 {{/each}}
46 |             </div>
47 |         </section>
48 |     </section>
49 |     {{/if}}
50 | {{/if}}
51 | 


--------------------------------------------------------------------------------
/_typedoc/custom-theme/partials/member.declaration.hbs:
--------------------------------------------------------------------------------
 1 | {{> comment}}
 2 | 
 3 | <div class="tsd-signature tsd-kind-icon">{{#compact}}
 4 |     {{{wbr name}}}
 5 |     {{#if typeParameters}}
 6 |         &lt;
 7 |         {{#each typeParameters}}
 8 |             {{#if @index}},&nbsp;{{/if}}
 9 |             {{name}}
10 |         {{/each}}
11 |         &gt;
12 |     {{/if}}
13 |     <span class="tsd-signature-symbol">{{#if isOptional}}?{{/if}}:</span>&nbsp;{{#with type}}{{>type}}{{/with}}
14 |     {{#if defaultValue}}
15 |         <span class="tsd-signature-symbol">
16 |         &nbsp;=&nbsp;
17 |         {{defaultValue}}
18 |         </span>
19 |     {{/if}}
20 | {{/compact}}</div>
21 | 
22 | {{> member.sources}}
23 | 
24 | 
25 | {{#if typeParameters}}
26 |     <h4 class="tsd-type-parameters-title">Type parameters</h4>
27 |     {{> typeParameters}}
28 | {{/if}}
29 | 
30 | {{#if type.declaration}}
31 |     <div class="tsd-type-declaration">
32 |         <h4>Type declaration</h4>
33 |         {{#with type.declaration}}
34 |             {{> parameter}}
35 |         {{/with}}
36 |     </div>
37 | {{/if}}
38 | 


--------------------------------------------------------------------------------
/_typedoc/custom-theme/partials/member.getterSetter.hbs:
--------------------------------------------------------------------------------
 1 | <ul class="tsd-signatures {{cssClasses}}">
 2 |     {{#if getSignature}}
 3 |         {{#with getSignature}}
 4 |             <li class="tsd-signature tsd-kind-icon">{{#compact}}
 5 |                 <span class="tsd-signature-symbol">get</span>&nbsp;
 6 |                 {{../name}}
 7 |                 {{> member.signature.title hideName=true }}
 8 |             {{/compact}}</li>
 9 |         {{/with}}
10 |     {{/if}}
11 |     {{#if setSignature}}
12 |         {{#with setSignature}}
13 |             <li class="tsd-signature tsd-kind-icon">{{#compact}}
14 |                 <span class="tsd-signature-symbol">set</span>&nbsp;
15 |                 {{../name}}
16 |                 {{> member.signature.title hideName=true }}
17 |             {{/compact}}</li>
18 |         {{/with}}
19 |     {{/if}}
20 | </ul>
21 | 
22 | <ul class="tsd-descriptions">
23 |     {{#if getSignature}}
24 |         {{#with getSignature}}
25 |             <li class="tsd-description">
26 |                 {{> member.signature.body }}
27 |             </li>
28 |         {{/with}}
29 |     {{/if}}
30 |     {{#if setSignature}}
31 |         {{#with setSignature}}
32 |             <li class="tsd-description">
33 |                 {{> member.signature.body }}
34 |             </li>
35 |         {{/with}}
36 |     {{/if}}
37 | </ul>
38 | 


--------------------------------------------------------------------------------
/_typedoc/custom-theme/partials/member.hbs:
--------------------------------------------------------------------------------
 1 | <section class="tsd-panel tsd-member {{cssClasses}}">
 2 |     <a name="{{anchor}}" class="tsd-anchor"></a>
 3 |     {{#if name}}
 4 |         <h3>{{#each flags}}<span class="tsd-flag ts-flag{{this}}">{{this}}</span> {{/each}}{{{wbr name}}}</h3>
 5 |     {{/if}}
 6 | 
 7 |     {{#if signatures}}
 8 |         {{> member.signatures}}
 9 |     {{else}}{{#if hasGetterOrSetter}}
10 |         {{> member.getterSetter}}
11 |     {{else}}{{#if isReference}}
12 |         {{> member.reference}}
13 |     {{else}}
14 |         {{> member.declaration}}
15 |     {{/if}}{{/if}}{{/if}}
16 | 
17 |     {{#each groups}}
18 |         {{#each children}}
19 |             {{#unless hasOwnDocument}}
20 |                 {{> member}}
21 |             {{/unless}}
22 |         {{/each}}
23 |     {{/each}}
24 | </section>
25 | 


--------------------------------------------------------------------------------
/_typedoc/custom-theme/partials/member.reference.hbs:
--------------------------------------------------------------------------------
 1 | {{#with tryGetTargetReflectionDeep}}
 2 |     {{#ifCond ../name '===' name}}
 3 |         Re-exports <a href="{{relativeURL url}}">{{name}}</a>
 4 |     {{else if flags.isExported}}
 5 |         Renames and re-exports <a href="{{relativeURL url}}">{{name}}</a>
 6 |     {{else}}
 7 |         Renames and exports <a href="{{relativeURL url}}">{{name}}</a>
 8 |     {{/ifCond}}
 9 | {{else}}
10 |     Re-exports {{name}}
11 | {{/with}}
12 | 


--------------------------------------------------------------------------------
/_typedoc/custom-theme/partials/member.signature.body.hbs:
--------------------------------------------------------------------------------
 1 | {{#unless hideSources}}
 2 |     {{> member.sources}}
 3 | {{/unless}}
 4 | 
 5 | {{> comment}}
 6 | 
 7 | {{#if typeParameters}}
 8 |     <h4 class="tsd-type-parameters-title">Type parameters</h4>
 9 |     {{> typeParameters}}
10 | {{/if}}
11 | 
12 | {{#if parameters}}
13 |     <h4 class="tsd-parameters-title">Parameters</h4>
14 |     <ul class="tsd-parameters">
15 |         {{#each parameters}}
16 |             <li>
17 |                 <h5>{{#compact}}
18 |                     {{#each flags}}
19 |                         <span class="tsd-flag ts-flag{{this}}">{{this}}</span>&nbsp;
20 |                     {{/each}}
21 |                     {{#if flags.isRest}}<span class="tsd-signature-symbol">...</span>{{/if}}
22 |                     {{name}}:&nbsp;
23 |                     {{#with type}}{{>type}}{{/with}}
24 |                     {{#if defaultValue}}
25 |                         <span class="tsd-signature-symbol">
26 |                         &nbsp;=&nbsp;
27 |                         {{defaultValue}}
28 |                         </span>
29 |                     {{/if}}
30 |                 {{/compact}}</h5>
31 | 
32 |                 {{> comment}}
33 | 
34 |                 {{#if type.declaration}}
35 |                     {{#with type.declaration}}
36 |                         {{> parameter}}
37 |                     {{/with}}
38 |                 {{/if}}
39 |             </li>
40 |         {{/each}}
41 |     </ul>
42 | {{/if}}
43 | 
44 | {{#if type}}
45 |     <h4 class="tsd-returns-title">Returns {{#compact}}{{#with type}}{{>type}}{{/with}}{{/compact}}</h4>
46 | 
47 |     {{#if comment.returns}}
48 |         {{#markdown}}{{{comment.returns}}}{{/markdown}}
49 |     {{/if}}
50 | 
51 |     {{#if type.declaration}}
52 |         {{#with type.declaration}}
53 |             {{> parameter}}
54 |         {{/with}}
55 |     {{/if}}
56 | {{/if}}
57 | 


--------------------------------------------------------------------------------
/_typedoc/custom-theme/partials/member.signature.title.hbs:
--------------------------------------------------------------------------------
 1 | {{#unless hideName}}
 2 |     {{{wbr name}}}
 3 | {{else}} {{! This ugliness goes away when we stop naming constructor signatures "new X"}}
 4 |     {{#ifCond kindString "===" "Constructor signature"}}
 5 |         {{#if flags.isAbstract}}
 6 |             <span class="tsd-signature-symbol">abstract </span>
 7 |         {{/if}}
 8 |         <span class="tsd-signature-symbol">new </span>
 9 |     {{/ifCond}}
10 | {{/unless}}
11 | {{#if typeParameters}}
12 |     &lt;
13 |     {{#each typeParameters}}
14 |         {{#if @index}},&nbsp;{{/if}}
15 |         {{name}}
16 |     {{/each}}
17 |     &gt;
18 | {{/if}}
19 | <span class="tsd-signature-symbol">(</span>
20 | {{#each parameters}}
21 |     {{#if @index}},&nbsp;{{/if}}
22 |     {{#if flags.isRest}}<span class="tsd-signature-symbol">...</span>{{/if}}
23 |     {{name}}
24 |     <span class="tsd-signature-symbol">
25 |         {{#if flags.isOptional}}?{{/if}}
26 |         {{#if defaultValue}}?{{/if}}
27 |         :&nbsp;
28 |     </span>
29 |     {{#with type}}{{>type}}{{/with}}
30 | {{/each}}
31 | <span class="tsd-signature-symbol">)</span>
32 | {{#if type}}
33 |     {{#if arrowStyle}}
34 |         <span class="tsd-signature-symbol"> =&gt; </span>
35 |     {{else}}
36 |         <span class="tsd-signature-symbol">: </span>
37 |     {{/if}}
38 |     {{#with type}}
39 |         {{>type}}
40 |     {{/with}}
41 | {{/if}}
42 | 


--------------------------------------------------------------------------------
/_typedoc/custom-theme/partials/member.signatures.hbs:
--------------------------------------------------------------------------------
 1 | <ul class="tsd-signatures {{cssClasses}}">
 2 |     {{#each signatures}}
 3 |         <li class="tsd-signature tsd-kind-icon">{{#compact}}{{> member.signature.title }}{{/compact}}</li>
 4 |     {{/each}}
 5 | </ul>
 6 | 
 7 | <ul class="tsd-descriptions">
 8 |     {{#each signatures}}
 9 |         <li class="tsd-description">
10 |             {{> member.signature.body }}
11 |         </li>
12 |     {{/each}}
13 | </ul>
14 | 


--------------------------------------------------------------------------------
/_typedoc/custom-theme/partials/member.sources.hbs:
--------------------------------------------------------------------------------
 1 | <aside class="tsd-sources">
 2 |     {{#if implementationOf}}
 3 |         <p>Implementation of {{#with implementationOf}}{{> typeAndParent}}{{/with}}</p>
 4 |     {{/if}}
 5 |     {{#if inheritedFrom}}
 6 |         <p>Inherited from {{#with inheritedFrom}}{{> typeAndParent}}{{/with}}</p>
 7 |     {{/if}}
 8 |     {{#if overwrites}}
 9 |         <p>Overrides {{#with overwrites}}{{> typeAndParent}}{{/with}}</p>
10 |     {{/if}}
11 |     {{#if sources}}
12 |         <ul>
13 |             {{#each sources}}
14 |                 {{#if url}}
15 |                     <li>Defined in <a href="{{url}}">{{fileName}}:{{line}}</a></li>
16 |                 {{else}}
17 |                     <li>Defined in {{fileName}}:{{line}}</li>
18 |                 {{/if}}
19 |             {{/each}}
20 |         </ul>
21 |     {{/if}}
22 | </aside>


--------------------------------------------------------------------------------
/_typedoc/custom-theme/partials/members.group.hbs:
--------------------------------------------------------------------------------
 1 | {{#if categories}}
 2 |     {{#each categories}}
 3 |         <section class="tsd-panel-group tsd-member-group {{cssClasses}}">
 4 |             <h2>{{#if title}}{{title}} {{/if}}{{../title}}</h2>
 5 |             {{#each children}}
 6 |                 {{#unless hasOwnDocument}}
 7 |                     {{> member}}
 8 |                 {{/unless}}
 9 |             {{/each}}
10 |         </section>
11 |     {{/each}}
12 | {{else}}
13 |     <section class="tsd-panel-group tsd-member-group {{cssClasses}}">
14 |         <h2>{{title}}</h2>
15 |         {{#each children}}
16 |             {{#unless hasOwnDocument}}
17 |                 {{> member}}
18 |             {{/unless}}
19 |         {{/each}}
20 |     </section>
21 | {{/if}}


--------------------------------------------------------------------------------
/_typedoc/custom-theme/partials/members.hbs:
--------------------------------------------------------------------------------
 1 | {{#if categories}}
 2 |     {{#each categories}}
 3 |         {{#unless allChildrenHaveOwnDocument}}
 4 |             <section class="tsd-panel-group tsd-member-group {{cssClasses}}">
 5 |                 <h2>{{title}}</h2>
 6 |                 {{#each children}}
 7 |                     {{#unless hasOwnDocument}}
 8 |                         {{> member}}
 9 |                     {{/unless}}
10 |                 {{/each}}
11 |             </section>
12 |         {{/unless}}
13 |     {{/each}}
14 | {{else}}
15 |     {{#each groups}}
16 |         {{#unless allChildrenHaveOwnDocument}}
17 |             {{> members.group}}
18 |         {{/unless}}
19 |     {{/each}}
20 | {{/if}}


--------------------------------------------------------------------------------
/_typedoc/custom-theme/partials/navigation.hbs:
--------------------------------------------------------------------------------
 1 | {{#if isVisible}}
 2 |     {{#if isLabel}}
 3 |         <li class="label {{cssClasses}}">
 4 |             <span>{{{wbr title}}}</span>
 5 |         </li>
 6 |     {{else}}
 7 |         {{#if isGlobals}}
 8 |             <li class="globals {{#if isInPath}}current{{/if}} {{cssClasses}}">
 9 |                 <a href="{{relativeURL url}}"><em>{{{wbr title}}}</em></a>
10 |             </li>
11 |         {{else}}
12 |             <li class="{{#if isInPath}}current{{/if}} {{cssClasses}}">
13 |                 <a href="{{relativeURL url}}">{{{wbr title}}}</a>
14 |                 {{#if isInPath}}
15 |                     {{#if children}}
16 |                         <ul>
17 |                             {{#each children}}
18 |                                 {{> navigation}}
19 |                             {{/each}}
20 |                         </ul>
21 |                     {{/if}}
22 |                 {{/if}}
23 |             </li>
24 |         {{/if}}
25 |     {{/if}}
26 | {{/if}}
27 | 


--------------------------------------------------------------------------------
/_typedoc/custom-theme/partials/parameter.hbs:
--------------------------------------------------------------------------------
  1 | <ul class="tsd-parameters">
  2 |     {{#if signatures}}
  3 |         <li class="tsd-parameter-signature">
  4 |             <ul class="tsd-signatures {{cssClasses}}">
  5 |                 {{#each signatures}}
  6 |                     <li class="tsd-signature tsd-kind-icon">{{#compact}}
  7 |                         {{> member.signature.title hideName=true }}
  8 |                     {{/compact}}</li>
  9 |                 {{/each}}
 10 |             </ul>
 11 | 
 12 |             <ul class="tsd-descriptions">
 13 |                 {{#each signatures}}
 14 |                     <li class="tsd-description">{{> member.signature.body hideSources=true }}</li>
 15 |                 {{/each}}
 16 |             </ul>
 17 |         </li>
 18 |     {{/if}}
 19 |     {{#if indexSignature}}
 20 |         <li class="tsd-parameter-index-signature">
 21 |             <h5>{{#compact}}
 22 |                 <span class="tsd-signature-symbol">[</span>
 23 |                 {{#each indexSignature.parameters}}
 24 |                     {{#if flags.isRest}}<span class="tsd-signature-symbol">...</span>{{/if}}{{name}}:&nbsp;{{#with type}}{{>type}}{{/with}}
 25 |                 {{/each}}
 26 |                 <span class="tsd-signature-symbol">]:&nbsp;</span>
 27 |                 {{#with indexSignature.type}}{{>type}}{{/with}}
 28 |             {{/compact}}</h5>
 29 | 
 30 |             {{#with indexSignature}}
 31 |                 {{> comment}}
 32 |             {{/with}}
 33 | 
 34 |             {{#if indexSignature.type.declaration}}
 35 |                 {{#with indexSignature.type.declaration}}
 36 |                     {{> parameter}}
 37 |                 {{/with}}
 38 |             {{/if}}
 39 |         </li>
 40 |     {{/if}}
 41 |     {{#each children}}
 42 |         {{#if signatures}}
 43 |             <li class="tsd-parameter">
 44 |                 <h5>{{#compact}}
 45 |                     {{#if flags.isRest}}<span class="tsd-signature-symbol">...</span>{{/if}}
 46 |                     {{{wbr name}}}
 47 |                     <span class="tsd-signature-symbol">
 48 |                         {{#if isOptional}}?{{/if}}
 49 |                         :&nbsp;
 50 |                     </span>
 51 |                     function
 52 |                 {{/compact}}</h5>
 53 | 
 54 |                 {{> member.signatures}}
 55 |             </li>
 56 |         {{else}}{{#if type}} {{! standard type }}
 57 |             <li class="tsd-parameter">
 58 |                 <h5>{{#compact}}
 59 |                     {{#each flags}}
 60 |                         <span class="tsd-flag ts-flag{{this}}">{{this}}</span>&nbsp;
 61 |                     {{/each}}
 62 |                     {{#if flags.isRest}}<span class="tsd-signature-symbol">...</span>{{/if}}
 63 |                     {{#with type}}
 64 |                         {{{wbr ../name}}}
 65 |                         <span class="tsd-signature-symbol">
 66 |                             {{#if ../flags.isOptional}}?{{/if}}
 67 |                             :&nbsp;
 68 |                         </span>
 69 |                         {{>type}}
 70 |                     {{/with}}
 71 |                 {{/compact}}</h5>
 72 | 
 73 |                 {{> comment}}
 74 | 
 75 |                 {{#if children}}
 76 |                     {{> parameter}}
 77 |                 {{/if}}
 78 | 
 79 |                 {{#if type.declaration}}
 80 |                     {{#with type.declaration}}
 81 |                         {{> parameter}}
 82 |                     {{/with}}
 83 |                 {{/if}}
 84 |             </li>
 85 |         {{else}} {{! getter/setter }}
 86 |             {{#with getSignature}} {{! getter }}
 87 |                 <li class="tsd-parameter">
 88 |                     <h5>{{#compact}}
 89 |                         {{#each flags}}
 90 |                             <span class="tsd-flag ts-flag{{this}}">{{this}}</span>&nbsp;
 91 |                         {{/each}}
 92 |                         <span class="tsd-signature-symbol">get&nbsp;</span>
 93 |                         {{{wbr ../name}}}
 94 |                         <span class="tsd-signature-symbol">():&nbsp;</span>
 95 |                         {{#with type}}
 96 |                             {{> type}}
 97 |                         {{/with}}
 98 |                     {{/compact}}</h5>
 99 | 
100 |                     {{> comment }}
101 |                 </li>
102 |             {{/with}}
103 |             {{#with setSignature}} {{! setter }}
104 |                 <li class="tsd-parameter">
105 |                     <h5>{{#compact}}
106 |                         {{#each flags}}
107 |                             <span class="tsd-flag ts-flag{{this}}">{{this}}</span>&nbsp;
108 |                         {{/each}}
109 |                         <span class="tsd-signature-symbol">set&nbsp;</span>
110 |                         {{{wbr ../name}}}
111 |                         <span class="tsd-signature-symbol">(</span>
112 |                         {{#each parameters}}
113 |                             {{name}}
114 |                             <span class="tsd-signature-symbol">: </span>
115 |                             {{#with type}}
116 |                                 {{> type}}
117 |                             {{else}}
118 |                                 <span class="tsd-signature-type">any</span>
119 |                             {{/with}}
120 |                         {{/each}}
121 |                         <span class="tsd-signature-symbol">):&nbsp;</span>
122 |                         {{#with type}}
123 |                             {{> type}}
124 |                         {{/with}}
125 |                     {{/compact}}</h5>
126 | 
127 |                     {{> comment }}
128 |                 </li>
129 |             {{/with}}
130 |         {{/if}}{{/if}}
131 |     {{/each}}
132 | </ul>
133 | 


--------------------------------------------------------------------------------
/_typedoc/custom-theme/partials/toc.hbs:
--------------------------------------------------------------------------------
 1 | <li class="{{#if isInPath}}current{{/if}} {{cssClasses}}">
 2 |     <a href="{{relativeURL url}}" class="tsd-kind-icon">{{{wbr title}}}</a>
 3 |     {{#if children}}
 4 |         <ul>
 5 |             {{#each children}}
 6 |                 {{> toc}}
 7 |             {{/each}}
 8 |         </ul>
 9 |     {{/if}}
10 | </li>
11 | 


--------------------------------------------------------------------------------
/_typedoc/custom-theme/partials/toc.root.hbs:
--------------------------------------------------------------------------------
 1 | {{#if isInPath}}
 2 |     </ul>
 3 |     <ul class="current">
 4 | {{/if}}
 5 | <li class="{{#if isInPath}}current{{/if}} {{cssClasses}}">
 6 |     <a href="{{relativeURL url}}" class="tsd-kind-icon">{{{wbr title}}}</a>
 7 |     {{#if children}}
 8 |         <ul>
 9 |             {{#each children}}
10 |                 {{> toc}}
11 |             {{/each}}
12 |         </ul>
13 |     {{/if}}
14 | </li>
15 | {{#if isInPath}}
16 |     </ul>
17 |     <ul class="after-current">
18 | {{/if}}
19 | 


--------------------------------------------------------------------------------
/_typedoc/custom-theme/partials/typeAndParent.hbs:
--------------------------------------------------------------------------------
 1 | {{#compact}}
 2 |     {{#if this}}
 3 |         {{#if elementType}}
 4 |             {{#with elementType}}
 5 |                 {{> typeAndParent}}
 6 |             {{/with}}
 7 |             []
 8 |         {{else}}
 9 |             {{#if reflection}}
10 |                 {{#ifSignature reflection}}
11 |                     {{#if reflection.parent.parent.url}}
12 |                         <a href="{{relativeURL reflection.parent.parent.url}}">{{reflection.parent.parent.name}}</a>
13 |                     {{else}}
14 |                         {{reflection.parent.parent.name}}
15 |                     {{/if}}
16 |                     .
17 |                     {{#if reflection.parent.url}}
18 |                         <a href="{{relativeURL reflection.parent.url}}">{{reflection.parent.name}}</a>
19 |                     {{else}}
20 |                         {{reflection.parent.name}}
21 |                     {{/if}}
22 |                 {{else}}
23 |                     {{#if reflection.parent.url}}
24 |                         <a href="{{relativeURL reflection.parent.url}}">{{reflection.parent.name}}</a>
25 |                     {{else}}
26 |                         {{reflection.parent.name}}
27 |                     {{/if}}
28 |                     .
29 |                     {{#if reflection.url}}
30 |                         <a href="{{relativeURL reflection.url}}">{{reflection.name}}</a>
31 |                     {{else}}
32 |                         {{reflection.name}}
33 |                     {{/if}}
34 |                 {{/ifSignature}}
35 |             {{else}}
36 |                 {{this}}
37 |             {{/if}}
38 |         {{/if}}
39 |     {{else}}
40 |         void
41 |     {{/if}}
42 | {{/compact}}


--------------------------------------------------------------------------------
/_typedoc/custom-theme/partials/typeParameters.hbs:
--------------------------------------------------------------------------------
 1 | <ul class="tsd-type-parameters">
 2 |     {{#each typeParameters}}
 3 |         <li>
 4 |             <h4>{{#compact}}
 5 |                 {{name}}
 6 |                 {{#if type}}
 7 |                     <span class="tsd-signature-symbol">:&nbsp;</span>
 8 |                     {{#with type}}{{> type}}{{/with}}
 9 |                 {{/if}}
10 |                 {{#if default}}
11 |                     &nbsp;=&nbsp;{{#with default}}{{> type}}{{/with}}
12 |                 {{/if}}
13 |             {{/compact}}</h4>
14 |             {{> comment}}
15 |         </li>
16 |     {{/each}}
17 | </ul>
18 | 


--------------------------------------------------------------------------------
/_typedoc/custom-theme/templates/index.hbs:
--------------------------------------------------------------------------------
1 | <div class="tsd-panel tsd-typography">
2 |     {{#markdown}}{{{model.readme}}}{{/markdown}}
3 | </div>


--------------------------------------------------------------------------------
/_typedoc/custom-theme/templates/reflection.hbs:
--------------------------------------------------------------------------------
 1 | {{#with model}}
 2 |     {{#if hasComment}}
 3 |         <section class="tsd-panel tsd-comment">
 4 |             {{> comment}}
 5 |         </section>
 6 |     {{/if}}
 7 | {{/with}}
 8 | 
 9 | {{#if model.typeParameters}}
10 |     <section class="tsd-panel tsd-type-parameters">
11 |         <h3>Type parameters</h3>
12 |         {{#with model}}{{> typeParameters}}{{/with}}
13 |     </section>
14 | {{/if}}
15 | 
16 | {{#if model.typeHierarchy}}
17 |     <section class="tsd-panel tsd-hierarchy">
18 |         <h3>Hierarchy</h3>
19 |         {{#with model.typeHierarchy}}{{> hierarchy}}{{/with}}
20 |     </section>
21 | {{/if}}
22 | 
23 | {{#if model.implementedTypes}}
24 |     <section class="tsd-panel">
25 |         <h3>Implements</h3>
26 |         <ul class="tsd-hierarchy">
27 |             {{#each model.implementedTypes}}
28 |                 <li>{{#compact}}{{> type}}{{/compact}}</li>
29 |             {{/each}}
30 |         </ul>
31 |     </section>
32 | {{/if}}
33 | 
34 | {{#if model.implementedBy}}
35 |     <section class="tsd-panel">
36 |         <h3>Implemented by</h3>
37 |         <ul class="tsd-hierarchy">
38 |             {{#each model.implementedBy}}
39 |                 <li>{{#compact}}{{> type}}{{/compact}}</li>
40 |             {{/each}}
41 |         </ul>
42 |     </section>
43 | {{/if}}
44 | 
45 | {{#if model.signatures}}
46 |     <section class="tsd-panel">
47 |         <h3 class="tsd-before-signature">Callable</h3>
48 |         {{#with model}}{{> member.signatures}}{{/with}}
49 |     </section>
50 | {{/if}}
51 | 
52 | {{#if model.indexSignature}}
53 |     <section class="tsd-panel {{model.cssClasses}}">
54 |         <h3 class="tsd-before-signature">Indexable</h3>
55 |         <div class="tsd-signature tsd-kind-icon">{{#compact}}
56 |             <span class="tsd-signature-symbol">[</span>
57 |             {{#each model.indexSignature.parameters}}
58 |                 {{name}}:&nbsp;{{#with type}}{{>type}}{{/with}}
59 |             {{/each}}
60 |             <span class="tsd-signature-symbol">]:&nbsp;</span>
61 |             {{#with model.indexSignature.type}}{{>type}}{{/with}}
62 |         {{/compact}}</div>
63 | 
64 |         {{#with model.indexSignature}}
65 |             {{> comment}}
66 |         {{/with}}
67 | 
68 |         {{#if model.indexSignature.type.declaration}}
69 |             {{#with model.indexSignature.type.declaration}}
70 |                 {{> parameter}}
71 |             {{/with}}
72 |         {{/if}}
73 |     </section>
74 | {{/if}}
75 | 
76 | {{#with model}}
77 |     {{> index}}
78 |     {{> members}}
79 | {{/with}}
80 | 


--------------------------------------------------------------------------------
/example-node/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 |   "extends": "../tsconfig.base",
3 |   "compilerOptions": {
4 |     "lib": ["es2019"],
5 |     "outDir": "lib"
6 |   },
7 |   "include": ["./**/*.ts", "../src/**/*.ts"]
8 | }
9 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "@cardano-foundation/ledgerjs-hw-app-cardano",
 3 |   "version": "7.1.3",
 4 |   "files": [
 5 |     "dist"
 6 |   ],
 7 |   "types": "./dist/Ada.d.ts",
 8 |   "description": "Ledger Hardware Wallet Cardano ADA API",
 9 |   "main": "dist/Ada.js",
10 |   "repository": "github:cardano-foundation/ledgerjs-hw-app-cardano",
11 |   "keywords": [
12 |     "Ledger",
13 |     "LedgerWallet",
14 |     "ADA",
15 |     "Cardano",
16 |     "SL",
17 |     "NanoS",
18 |     "Hardware",
19 |     "Wallet"
20 |   ],
21 |   "author": "VacuumLabs <adalite@vacuumlabs.com>",
22 |   "license": "Apache-2.0",
23 |   "dependencies": {
24 |     "@ledgerhq/hw-transport": "^6.27.10",
25 |     "base-x": "^3.0.5",
26 |     "bech32": "^1.1.4",
27 |     "int64-buffer": "^1.0.1"
28 |   },
29 |   "devDependencies": {
30 |     "@ledgerhq/hw-transport-node-hid": "^6.27.10",
31 |     "@ledgerhq/hw-transport-node-speculos": "^6.27.10",
32 |     "@types/blake2": "^4.0.1",
33 |     "@types/chai": "^4.2.15",
34 |     "@types/chai-as-promised": "^7.1.3",
35 |     "@types/mocha": "^10.0.0",
36 |     "@types/node": "^18.12.0",
37 |     "@typescript-eslint/eslint-plugin": "^5.42.1",
38 |     "@typescript-eslint/parser": "^5.42.1",
39 |     "blake2": "^4.0.2",
40 |     "chai": "^4.2.0",
41 |     "chai-as-promised": "^7.1.1",
42 |     "chalk": "^4.0.0",
43 |     "cspell": "^6.10.1",
44 |     "eslint": "^8.27.0",
45 |     "eslint-config-prettier": "^8.5.0",
46 |     "eslint-config-vacuumlabs": "^8.0.2",
47 |     "eslint-plugin-import": "^2.25.4",
48 |     "eslint-plugin-mocha": "^10.1.0",
49 |     "eslint-plugin-simple-import-sort": "^7.0.0",
50 |     "flow-bin": "^0.195.0",
51 |     "flowgen": "^1.21.0",
52 |     "gh-pages": "^5.0.0",
53 |     "mocha": "^10.2.0",
54 |     "prettier": "^2.6.2",
55 |     "sinon": "^14.0.0",
56 |     "ts-mock-imports": "^1.3.7",
57 |     "ts-node": "^10.9.1",
58 |     "typedoc": "^0.23.24",
59 |     "typescript": "^4.9.4"
60 |   },
61 |   "bugs": {
62 |     "url": "https://github.com/cardano-foundation/ledgerjs-hw-app-cardano/issues"
63 |   },
64 |   "homepage": "https://github.com/cardano-foundation/ledgerjs-hw-app-cardano",
65 |   "scripts": {
66 |     "clean": "rm -rf dist/",
67 |     "lint": "eslint src/ test/ example-node/ --max-warnings=0 --ext .ts,.js",
68 |     "prettier:check": "prettier --check .",
69 |     "prettier": "prettier --write .",
70 |     "spell:check": "yarn cspell lint --gitignore '**' 2>/dev/null",
71 |     "build": "yarn tsc -p src/tsconfig.json --removeComments",
72 |     "build-with-comments": "yarn tsc -p src/tsconfig.json",
73 |     "build:flowtypes": "yarn build-with-comments && find . -type f -not -path './node_modules/*' -not -path './example-node/*' -name '*.d.ts' -exec sh -c 'yarn flowgen --add-flow-header --no-inexact $1 -o ${1%.*.*}.js.flow' _ '{}' \\;",
74 |     "flow": "flow --show-all-errors dist/",
75 |     "gen-docs": "yarn typedoc",
76 |     "prepack": "yarn build:flowtypes && yarn flow && yarn build",
77 |     "prepublish": "yarn run clean && yarn run build",
78 |     "run-example": "yarn ts-node -P example-node/tsconfig.json example-node/index.ts",
79 |     "run-example-speculos": "LEDGER_TRANSPORT=speculos yarn ts-node -P example-node/tsconfig.json example-node/index.ts",
80 |     "device-self-test": "mocha --timeout 3600000 -r ts-node/register test/device-self-test/**/*.test.ts",
81 |     "device-self-test-speculos": "LEDGER_TRANSPORT=speculos yarn device-self-test",
82 |     "test-all": "yarn device-self-test && yarn test-integration",
83 |     "test-integration": "yarn mocha --timeout 3600000 -r ts-node/register test/integration/**/*.test.ts",
84 |     "test-speculos": "LEDGER_TRANSPORT=speculos yarn test-integration",
85 |     "test-unit": "yarn mocha -r ts-node/register test/unit/**/*.test.ts",
86 |     "//": "run single test by specifying --grep <name> parameter in test-integration"
87 |   },
88 |   "resolutions": {
89 |     "chalk/ansi-regex": "<6.0.6",
90 |     "prettier-eslint/**/ansi-regex": "<6.0.0",
91 |     "eslint/**/ansi-regex": "<6.0.0",
92 |     "@ledgerhq/hw-transport-node-hid/**/ansi-regex": "<6.0.0",
93 |     "mocha/**/ansi-regex": "<6.0.0",
94 |     "mocha/**/minimatch": "^3.1.2"
95 |   }
96 | }
97 | 


--------------------------------------------------------------------------------
/src/errors/deviceStatusError.ts:
--------------------------------------------------------------------------------
 1 | import {ErrorBase} from './errorBase'
 2 | 
 3 | /**
 4 |  * Raw error codes returned by APDU protocol. Note that this is *not* an exhaustive list.
 5 |  * @category Errors
 6 |  */
 7 | export const DeviceStatusCodes = {
 8 |   ERR_STILL_IN_CALL: 0x6e04 as const, // internal
 9 |   ERR_INVALID_DATA: 0x6e07 as const,
10 |   ERR_INVALID_BIP_PATH: 0x6e08 as const,
11 |   ERR_REJECTED_BY_USER: 0x6e09 as const,
12 |   ERR_REJECTED_BY_POLICY: 0x6e10 as const,
13 |   ERR_DEVICE_LOCKED: 0x6e11 as const,
14 |   ERR_UNSUPPORTED_ADDRESS_TYPE: 0x6e12 as const,
15 | 
16 |   // Not thrown by ledger-app-cardano itself but other apps
17 |   ERR_CLA_NOT_SUPPORTED: 0x6e00 as const,
18 | }
19 | 
20 | // Human-readable version of errors reported by APDU protocol
21 | export const DeviceStatusMessages: Record<number, string> = {
22 |   [DeviceStatusCodes.ERR_INVALID_DATA]: 'Invalid data supplied to Ledger',
23 |   [DeviceStatusCodes.ERR_INVALID_BIP_PATH]:
24 |     'Invalid derivation path supplied to Ledger',
25 |   [DeviceStatusCodes.ERR_REJECTED_BY_USER]: 'Action rejected by user',
26 |   [DeviceStatusCodes.ERR_REJECTED_BY_POLICY]:
27 |     "Action rejected by Ledger's security policy",
28 |   [DeviceStatusCodes.ERR_DEVICE_LOCKED]: 'Device is locked',
29 |   [DeviceStatusCodes.ERR_CLA_NOT_SUPPORTED]: 'Wrong Ledger app',
30 |   [DeviceStatusCodes.ERR_UNSUPPORTED_ADDRESS_TYPE]: 'Unsupported address type',
31 | }
32 | 
33 | const GH_DEVICE_ERRORS_LINK =
34 |   'https://github.com/cardano-foundation/ledger-app-cardano/blob/master/src/errors.h'
35 | 
36 | const getDeviceErrorDescription = (statusCode: number) => {
37 |   const statusCodeHex = `0x${statusCode.toString(16)}`
38 |   const defaultMsg = `General error ${statusCodeHex}. Please consult ${GH_DEVICE_ERRORS_LINK}`
39 | 
40 |   return DeviceStatusMessages[statusCode] ?? defaultMsg
41 | }
42 | 
43 | /**
44 |  * Error wrapping APDU device error codes with human-readable message.
45 |  * Use [[code]] for accessing underlying status code.
46 |  * @category Errors
47 |  */
48 | export class DeviceStatusError extends ErrorBase {
49 |   public code: number
50 | 
51 |   public constructor(code: number) {
52 |     super(getDeviceErrorDescription(code))
53 |     this.code = code
54 |   }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/errors/deviceUnsupported.ts:
--------------------------------------------------------------------------------
1 | import {ErrorBase} from './errorBase'
2 | 
3 | /**
4 |  * Thrown when user tried to call a method with incompatible Ledger App version
5 |  * @category Errors
6 |  */
7 | export class DeviceVersionUnsupported extends ErrorBase {}
8 | 


--------------------------------------------------------------------------------
/src/errors/errorBase.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Base error for errors thrown by the code
 3 |  * @category Errors
 4 |  */
 5 | export class ErrorBase extends Error {
 6 |   public constructor(message: string) {
 7 |     super(message)
 8 |     this.name = this.constructor.name
 9 |   }
10 | }
11 | 


--------------------------------------------------------------------------------
/src/errors/index.ts:
--------------------------------------------------------------------------------
 1 | export {ErrorBase} from './errorBase'
 2 | export {InvalidData} from './invalidData'
 3 | export {DeviceVersionUnsupported} from './deviceUnsupported'
 4 | export {
 5 |   DeviceStatusCodes,
 6 |   DeviceStatusError,
 7 |   DeviceStatusMessages,
 8 | } from './deviceStatusError'
 9 | export {InvalidDataReason} from './invalidDataReason'
10 | 


--------------------------------------------------------------------------------
/src/errors/invalidData.ts:
--------------------------------------------------------------------------------
 1 | import {ErrorBase} from './errorBase'
 2 | import type {InvalidDataReason} from './invalidDataReason'
 3 | 
 4 | /**
 5 |  * Request data is invalid, caller should check what is feeding to us
 6 |  * @category Errors
 7 |  */
 8 | export class InvalidData extends ErrorBase {
 9 |   public constructor(reason: InvalidDataReason) {
10 |     super(reason as string)
11 |   }
12 | }
13 | 


--------------------------------------------------------------------------------
/src/interactions/common/ins.ts:
--------------------------------------------------------------------------------
 1 | export const enum INS {
 2 |   GET_VERSION = 0x00,
 3 |   GET_SERIAL = 0x01,
 4 | 
 5 |   GET_EXT_PUBLIC_KEY = 0x10,
 6 |   DERIVE_ADDRESS = 0x11,
 7 |   DERIVE_NATIVE_SCRIPT_HASH = 0x12,
 8 | 
 9 |   SIGN_TX = 0x21,
10 |   SIGN_OPERATIONAL_CERTIFICATE = 0x22,
11 |   SIGN_CIP36_VOTE = 0x23,
12 |   SIGN_MESSAGE = 0x24,
13 | 
14 |   RUN_TESTS = 0xf0,
15 | }
16 | 


--------------------------------------------------------------------------------
/src/interactions/common/types.ts:
--------------------------------------------------------------------------------
 1 | export type SendParams = {
 2 |   ins: number
 3 |   p1: number
 4 |   p2: number
 5 |   data: Buffer
 6 |   expectedResponseLength?: number
 7 | }
 8 | 
 9 | export type Interaction<RetValue> = Generator<SendParams, RetValue, Buffer>
10 | 


--------------------------------------------------------------------------------
/src/interactions/deriveAddress.ts:
--------------------------------------------------------------------------------
 1 | import {DeviceVersionUnsupported} from '../errors'
 2 | import {getVersionString} from '../utils'
 3 | import type {ParsedAddressParams, Version} from '../types/internal'
 4 | import {AddressType} from '../types/public'
 5 | import type {DerivedAddress} from '../types/public'
 6 | import {INS} from './common/ins'
 7 | import type {Interaction, SendParams} from './common/types'
 8 | import {ensureLedgerAppVersionCompatible, getCompatibility} from './getVersion'
 9 | import {serializeAddressParams} from './serialization/addressParams'
10 | 
11 | const send = (params: {
12 |   p1: number
13 |   p2: number
14 |   data: Buffer
15 |   expectedResponseLength?: number
16 | }): SendParams => ({ins: INS.DERIVE_ADDRESS, ...params})
17 | 
18 | export function ensureAddressDerivationSupportedByAppVersion(
19 |   version: Version,
20 |   addressParams: ParsedAddressParams,
21 | ): void {
22 |   ensureLedgerAppVersionCompatible(version)
23 | 
24 |   if (
25 |     addressParams.type === AddressType.BYRON &&
26 |     !getCompatibility(version).supportsByronAddressDerivation
27 |   ) {
28 |     throw new DeviceVersionUnsupported(
29 |       `Byron address parameters not supported by Ledger app version ${getVersionString(
30 |         version,
31 |       )}.`,
32 |     )
33 |   }
34 | }
35 | 
36 | export function* deriveAddress(
37 |   version: Version,
38 |   addressParams: ParsedAddressParams,
39 | ): Interaction<DerivedAddress> {
40 |   ensureAddressDerivationSupportedByAppVersion(version, addressParams)
41 | 
42 |   const P1_RETURN = 0x01
43 |   const P2_UNUSED = 0x00
44 | 
45 |   const response = yield send({
46 |     p1: P1_RETURN,
47 |     p2: P2_UNUSED,
48 |     data: serializeAddressParams(addressParams, version),
49 |   })
50 | 
51 |   return {
52 |     addressHex: response.toString('hex'),
53 |   }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/interactions/deriveNativeScriptHash.ts:
--------------------------------------------------------------------------------
  1 | import {DeviceVersionUnsupported} from '../errors'
  2 | import type {
  3 |   ParsedComplexNativeScript,
  4 |   ParsedNativeScript,
  5 |   ParsedSimpleNativeScript,
  6 | } from '../types/internal'
  7 | import {NATIVE_SCRIPT_HASH_LENGTH} from '../types/internal'
  8 | import type {
  9 |   NativeScriptHash,
 10 |   NativeScriptHashDisplayFormat,
 11 |   Version,
 12 | } from '../types/public'
 13 | import {NativeScriptType} from '../types/public'
 14 | import {getVersionString} from '../utils'
 15 | import {INS} from './common/ins'
 16 | import type {Interaction, SendParams} from './common/types'
 17 | import {ensureLedgerAppVersionCompatible, getCompatibility} from './getVersion'
 18 | import {
 19 |   serializeComplexNativeScriptStart,
 20 |   serializeSimpleNativeScript,
 21 |   serializeWholeNativeScriptFinish,
 22 | } from './serialization/nativeScript'
 23 | 
 24 | const send = (params: {
 25 |   p1: number
 26 |   p2: number
 27 |   data: Buffer
 28 |   expectedResponseLength?: number
 29 | }): SendParams => ({ins: INS.DERIVE_NATIVE_SCRIPT_HASH, ...params})
 30 | 
 31 | const enum P1 {
 32 |   STAGE_COMPLEX_SCRIPT_START = 0x01,
 33 |   STAGE_ADD_SIMPLE_SCRIPT = 0x02,
 34 |   STAGE_WHOLE_NATIVE_SCRIPT_FINISH = 0x03,
 35 | }
 36 | 
 37 | const enum P2 {
 38 |   UNUSED = 0x00,
 39 | }
 40 | 
 41 | type ScriptHashResponse = {scriptHashHex: string}
 42 | 
 43 | function* deriveScriptHash_startComplexScript(
 44 |   script: ParsedComplexNativeScript,
 45 | ): Interaction<void> {
 46 |   yield send({
 47 |     p1: P1.STAGE_COMPLEX_SCRIPT_START,
 48 |     p2: P2.UNUSED,
 49 |     data: serializeComplexNativeScriptStart(script),
 50 |     expectedResponseLength: 0,
 51 |   })
 52 | }
 53 | 
 54 | function* deriveNativeScriptHash_addSimpleScript(
 55 |   script: ParsedSimpleNativeScript,
 56 | ): Interaction<void> {
 57 |   yield send({
 58 |     p1: P1.STAGE_ADD_SIMPLE_SCRIPT,
 59 |     p2: P2.UNUSED,
 60 |     data: serializeSimpleNativeScript(script),
 61 |     expectedResponseLength: 0,
 62 |   })
 63 | }
 64 | 
 65 | function isComplexScript(
 66 |   script: ParsedNativeScript,
 67 | ): script is ParsedComplexNativeScript {
 68 |   switch (script.type) {
 69 |     case NativeScriptType.ALL:
 70 |     case NativeScriptType.ANY:
 71 |     case NativeScriptType.N_OF_K:
 72 |       return true
 73 |     default:
 74 |       return false
 75 |   }
 76 | }
 77 | 
 78 | function* deriveNativeScriptHash_addScript(
 79 |   script: ParsedNativeScript,
 80 | ): Interaction<void> {
 81 |   if (isComplexScript(script)) {
 82 |     yield* deriveScriptHash_startComplexScript(script)
 83 |     for (const subscript of script.params.scripts) {
 84 |       yield* deriveNativeScriptHash_addScript(subscript)
 85 |     }
 86 |   } else {
 87 |     return yield* deriveNativeScriptHash_addSimpleScript(script)
 88 |   }
 89 | }
 90 | 
 91 | function* deriveNativeScriptHash_finishWholeNativeScript(
 92 |   displayFormat: NativeScriptHashDisplayFormat,
 93 | ): Interaction<ScriptHashResponse> {
 94 |   const response = yield send({
 95 |     p1: P1.STAGE_WHOLE_NATIVE_SCRIPT_FINISH,
 96 |     p2: P2.UNUSED,
 97 |     data: serializeWholeNativeScriptFinish(displayFormat),
 98 |     expectedResponseLength: NATIVE_SCRIPT_HASH_LENGTH,
 99 |   })
100 | 
101 |   return {
102 |     scriptHashHex: response.toString('hex'),
103 |   }
104 | }
105 | 
106 | function ensureScriptHashDerivationSupportedByAppVersion(
107 |   version: Version,
108 | ): void {
109 |   if (!getCompatibility(version).supportsNativeScriptHashDerivation) {
110 |     throw new DeviceVersionUnsupported(
111 |       `Native script hash derivation not supported by Ledger app version ${getVersionString(
112 |         version,
113 |       )}.`,
114 |     )
115 |   }
116 | }
117 | 
118 | export function* deriveNativeScriptHash(
119 |   version: Version,
120 |   script: ParsedNativeScript,
121 |   displayFormat: NativeScriptHashDisplayFormat,
122 | ): Interaction<NativeScriptHash> {
123 |   ensureLedgerAppVersionCompatible(version)
124 |   ensureScriptHashDerivationSupportedByAppVersion(version)
125 | 
126 |   yield* deriveNativeScriptHash_addScript(script)
127 |   const {scriptHashHex} = yield* deriveNativeScriptHash_finishWholeNativeScript(
128 |     displayFormat,
129 |   )
130 | 
131 |   return {
132 |     scriptHashHex,
133 |   }
134 | }
135 | 


--------------------------------------------------------------------------------
/src/interactions/getExtendedPublicKeys.ts:
--------------------------------------------------------------------------------
 1 | import {DeviceVersionUnsupported} from '../errors'
 2 | import type {Uint32_t, ValidBIP32Path, Version} from '../types/internal'
 3 | import {EXTENDED_PUBLIC_KEY_LENGTH} from '../types/internal'
 4 | import type {ExtendedPublicKey} from '../types/public'
 5 | import {HARDENED} from '../types/public'
 6 | import {chunkBy, getVersionString} from '../utils'
 7 | import {assert} from '../utils/assert'
 8 | import {path_to_buf, uint32_to_buf} from '../utils/serialize'
 9 | import {INS} from './common/ins'
10 | import type {Interaction, SendParams} from './common/types'
11 | import {ensureLedgerAppVersionCompatible, getCompatibility} from './getVersion'
12 | 
13 | function ensureLedgerAppVersionCompatibleForPaths(
14 |   version: Version,
15 |   paths: Array<ValidBIP32Path>,
16 | ): void {
17 |   const voteKeysPresent = paths.some((path) => path[0] === 1694 + HARDENED)
18 |   if (voteKeysPresent && !getCompatibility(version).supportsCIP36Vote) {
19 |     throw new DeviceVersionUnsupported(
20 |       `CIP36 vote keys not supported by Ledger app version ${getVersionString(
21 |         version,
22 |       )}.`,
23 |     )
24 |   }
25 | }
26 | 
27 | const send = (params: {
28 |   p1: number
29 |   p2: number
30 |   data: Buffer
31 |   expectedResponseLength?: number
32 | }): SendParams => ({ins: INS.GET_EXT_PUBLIC_KEY, ...params})
33 | 
34 | export function* getExtendedPublicKeys(
35 |   version: Version,
36 |   paths: Array<ValidBIP32Path>,
37 | ): Interaction<Array<ExtendedPublicKey>> {
38 |   ensureLedgerAppVersionCompatible(version)
39 |   ensureLedgerAppVersionCompatibleForPaths(version, paths)
40 | 
41 |   const enum P1 {
42 |     INIT = 0x00,
43 |     NEXT_KEY = 0x01,
44 |   }
45 |   const enum P2 {
46 |     UNUSED = 0x00,
47 |   }
48 |   const result = []
49 | 
50 |   for (let i = 0; i < paths.length; i++) {
51 |     const pathData = Buffer.concat([path_to_buf(paths[i])])
52 | 
53 |     let response: Buffer
54 |     if (i === 0) {
55 |       // initial APDU
56 | 
57 |       // passing empty Buffer for backwards compatibility
58 |       // of single key export on Ledger app version 2.0.4
59 |       const remainingKeysData =
60 |         paths.length > 1
61 |           ? uint32_to_buf((paths.length - 1) as Uint32_t)
62 |           : Buffer.from([])
63 | 
64 |       response = yield send({
65 |         p1: P1.INIT,
66 |         p2: P2.UNUSED,
67 |         data: Buffer.concat([pathData, remainingKeysData]),
68 |         expectedResponseLength: EXTENDED_PUBLIC_KEY_LENGTH,
69 |       })
70 |     } else {
71 |       // next key APDU
72 |       response = yield send({
73 |         p1: P1.NEXT_KEY,
74 |         p2: P2.UNUSED,
75 |         data: pathData,
76 |         expectedResponseLength: EXTENDED_PUBLIC_KEY_LENGTH,
77 |       })
78 |     }
79 | 
80 |     const VKEY_LENGTH = 32
81 |     const CHAINCODE_LENGTH = 32
82 |     const [publicKey, chainCode, rest] = chunkBy(response, [
83 |       VKEY_LENGTH,
84 |       CHAINCODE_LENGTH,
85 |     ])
86 |     assert(rest.length === 0, 'invalid response length')
87 | 
88 |     result.push({
89 |       publicKeyHex: publicKey.toString('hex'),
90 |       chainCodeHex: chainCode.toString('hex'),
91 |     })
92 |   }
93 | 
94 |   return result
95 | }
96 | 


--------------------------------------------------------------------------------
/src/interactions/getSerial.ts:
--------------------------------------------------------------------------------
 1 | import type {Version} from '../types/internal'
 2 | import type {Serial} from '../types/public'
 3 | import utils from '../utils'
 4 | import {INS} from './common/ins'
 5 | import type {Interaction, SendParams} from './common/types'
 6 | import {ensureLedgerAppVersionCompatible} from './getVersion'
 7 | 
 8 | const send = (params: {
 9 |   p1: number
10 |   p2: number
11 |   data: Buffer
12 |   expectedResponseLength?: number
13 | }): SendParams => ({ins: INS.GET_SERIAL, ...params})
14 | 
15 | export function* getSerial(version: Version): Interaction<Serial> {
16 |   ensureLedgerAppVersionCompatible(version)
17 | 
18 |   const P1_UNUSED = 0x00
19 |   const P2_UNUSED = 0x00
20 |   const response = yield send({
21 |     p1: P1_UNUSED,
22 |     p2: P2_UNUSED,
23 |     data: Buffer.alloc(0),
24 |     expectedResponseLength: 7,
25 |   })
26 | 
27 |   const serialHex = utils.buf_to_hex(response)
28 |   return {serialHex}
29 | }
30 | 


--------------------------------------------------------------------------------
/src/interactions/getVersion.ts:
--------------------------------------------------------------------------------
  1 | import {DeviceVersionUnsupported} from '../errors'
  2 | import type {DeviceCompatibility, Version} from '../types/internal'
  3 | import {getVersionString} from '../utils'
  4 | import {INS} from './common/ins'
  5 | import type {Interaction, SendParams} from './common/types'
  6 | 
  7 | const send = (params: {
  8 |   p1: number
  9 |   p2: number
 10 |   data: Buffer
 11 |   expectedResponseLength?: number
 12 | }): SendParams => ({ins: INS.GET_VERSION, ...params})
 13 | 
 14 | export function* getVersion(): Interaction<Version> {
 15 |   // moving getVersion() logic to private function in order
 16 |   // to disable concurrent execution protection done by this.transport.decorateAppAPIMethods()
 17 |   // when invoked from within other calls to check app version
 18 | 
 19 |   const P1_UNUSED = 0x00
 20 |   const P2_UNUSED = 0x00
 21 |   const response = yield send({
 22 |     p1: P1_UNUSED,
 23 |     p2: P2_UNUSED,
 24 |     data: Buffer.alloc(0),
 25 |     expectedResponseLength: 4,
 26 |   })
 27 |   const [major, minor, patch, flags_value] = response
 28 | 
 29 |   const FLAG_IS_DEBUG = 1
 30 |   // const FLAG_IS_HEADLESS = 2;
 31 |   const FLAG_IS_APP_XS = 4
 32 | 
 33 |   const flags = {
 34 |     // eslint-disable-next-line no-bitwise
 35 |     isDebug: (flags_value & FLAG_IS_DEBUG) === FLAG_IS_DEBUG,
 36 |     // eslint-disable-next-line no-bitwise
 37 |     isAppXS: (flags_value & FLAG_IS_APP_XS) === FLAG_IS_APP_XS,
 38 |   }
 39 |   return {major, minor, patch, flags}
 40 | }
 41 | 
 42 | export function isLedgerAppVersionAtLeast(
 43 |   version: Version,
 44 |   minMajor: number,
 45 |   minMinor: number,
 46 | ): boolean {
 47 |   const {major, minor} = version
 48 | 
 49 |   return major > minMajor || (major === minMajor && minor >= minMinor)
 50 | }
 51 | 
 52 | export function isLedgerAppVersionAtMost(
 53 |   version: Version,
 54 |   maxMajor: number,
 55 |   maxMinor: number,
 56 | ): boolean {
 57 |   const {major, minor} = version
 58 | 
 59 |   return major < maxMajor || (major === maxMajor && minor <= maxMinor)
 60 | }
 61 | 
 62 | export function getCompatibility(version: Version): DeviceCompatibility {
 63 |   // We restrict forward compatibility only to backward-compatible semver changes
 64 |   const v2_2 =
 65 |     isLedgerAppVersionAtLeast(version, 2, 2) &&
 66 |     isLedgerAppVersionAtMost(version, 7, Infinity)
 67 |   const v2_3 =
 68 |     isLedgerAppVersionAtLeast(version, 2, 3) &&
 69 |     isLedgerAppVersionAtMost(version, 7, Infinity)
 70 |   const v2_4 =
 71 |     isLedgerAppVersionAtLeast(version, 2, 4) &&
 72 |     isLedgerAppVersionAtMost(version, 7, Infinity)
 73 |   const v3_0 =
 74 |     isLedgerAppVersionAtLeast(version, 3, 0) &&
 75 |     isLedgerAppVersionAtMost(version, 7, Infinity)
 76 |   const v4_0 =
 77 |     isLedgerAppVersionAtLeast(version, 4, 0) &&
 78 |     isLedgerAppVersionAtMost(version, 7, Infinity)
 79 |   const v4_1 =
 80 |     isLedgerAppVersionAtLeast(version, 4, 1) &&
 81 |     isLedgerAppVersionAtMost(version, 7, Infinity)
 82 |   const v5_0 =
 83 |     isLedgerAppVersionAtLeast(version, 5, 0) &&
 84 |     isLedgerAppVersionAtMost(version, 7, Infinity)
 85 |   const v6_0 =
 86 |     isLedgerAppVersionAtLeast(version, 6, 0) &&
 87 |     isLedgerAppVersionAtMost(version, 7, Infinity)
 88 |   const v7_0 =
 89 |     isLedgerAppVersionAtLeast(version, 7, 0) &&
 90 |     isLedgerAppVersionAtMost(version, 7, Infinity)
 91 |   const v7_1 =
 92 |     isLedgerAppVersionAtLeast(version, 7, 1) &&
 93 |     isLedgerAppVersionAtMost(version, 7, Infinity)
 94 | 
 95 |   const isAppXS = version.flags.isAppXS
 96 | 
 97 |   return {
 98 |     isCompatible: v2_2,
 99 |     recommendedVersion: v2_2 ? null : '7.0',
100 |     supportsByronAddressDerivation: v2_2 && !isAppXS,
101 |     supportsMary: v2_2,
102 |     supportsCatalystRegistration: v2_3, // CIP-15
103 |     supportsCIP36: v6_0,
104 |     supportsZeroTtl: v2_3,
105 |     supportsPoolRegistrationAsOwner: v2_2 && !isAppXS,
106 |     supportsPoolRegistrationAsOperator: v2_4 && !isAppXS,
107 |     supportsPoolRetirement: v2_4 && !isAppXS,
108 |     supportsNativeScriptHashDerivation: v3_0 && !isAppXS,
109 |     supportsMultisigTransaction: v3_0,
110 |     supportsMint: v3_0,
111 |     supportsAlonzo: v4_0,
112 |     supportsReqSignersInOrdinaryTx: v4_1,
113 |     supportsBabbage: v5_0,
114 |     supportsCIP36Vote: v6_0,
115 |     supportsConway: v7_0,
116 |     supportsMessageSigning: v7_1,
117 |   }
118 | }
119 | 
120 | export function ensureLedgerAppVersionCompatible(version: Version): void {
121 |   const {isCompatible, recommendedVersion} = getCompatibility(version)
122 | 
123 |   if (!isCompatible) {
124 |     throw new DeviceVersionUnsupported(
125 |       `Device app version ${getVersionString(
126 |         version,
127 |       )} unsupported, recommended version is ${recommendedVersion}.`,
128 |     )
129 |   }
130 | }
131 | 


--------------------------------------------------------------------------------
/src/interactions/runTests.ts:
--------------------------------------------------------------------------------
 1 | import type {Version} from '../types/internal'
 2 | import {INS} from './common/ins'
 3 | import type {Interaction, SendParams} from './common/types'
 4 | 
 5 | const send = (params: {
 6 |   p1: number
 7 |   p2: number
 8 |   data: Buffer
 9 |   expectedResponseLength?: number
10 | }): SendParams => ({ins: INS.RUN_TESTS, ...params})
11 | 
12 | export function* runTests(_version: Version): Interaction<void> {
13 |   yield send({
14 |     p1: 0x00,
15 |     p2: 0x00,
16 |     data: Buffer.alloc(0),
17 |     expectedResponseLength: 0,
18 |   })
19 | }
20 | 


--------------------------------------------------------------------------------
/src/interactions/serialization/addressParams.ts:
--------------------------------------------------------------------------------
  1 | import {DeviceVersionUnsupported} from '../../errors'
  2 | import {InvalidDataReason} from '../../errors/invalidDataReason'
  3 | import type {
  4 |   ParsedAddressParams,
  5 |   SpendingDataSource,
  6 |   StakingDataSource,
  7 |   Uint8_t,
  8 |   Version,
  9 | } from '../../types/internal'
 10 | import {
 11 |   SpendingDataSourceType,
 12 |   AddressType,
 13 |   StakingDataSourceType,
 14 | } from '../../types/internal'
 15 | import {getVersionString} from '../../utils'
 16 | import {assert, unreachable} from '../../utils/assert'
 17 | import {
 18 |   hex_to_buf,
 19 |   path_to_buf,
 20 |   uint8_to_buf,
 21 |   uint32_to_buf,
 22 | } from '../../utils/serialize'
 23 | import {getCompatibility} from '../getVersion'
 24 | 
 25 | function serializeSpendingDataSource(dataSource: SpendingDataSource): Buffer {
 26 |   switch (dataSource.type) {
 27 |     case SpendingDataSourceType.PATH:
 28 |       return path_to_buf(dataSource.path)
 29 |     case SpendingDataSourceType.SCRIPT_HASH:
 30 |       return hex_to_buf(dataSource.scriptHashHex)
 31 |     case SpendingDataSourceType.NONE:
 32 |       return Buffer.alloc(0)
 33 |     default:
 34 |       unreachable(dataSource)
 35 |   }
 36 | }
 37 | 
 38 | function serializeStakingDataSource(dataSource: StakingDataSource): Buffer {
 39 |   const stakingChoicesEncoding = {
 40 |     [StakingDataSourceType.NONE]: 0x11,
 41 |     [StakingDataSourceType.KEY_PATH]: 0x22,
 42 |     [StakingDataSourceType.KEY_HASH]: 0x33,
 43 |     [StakingDataSourceType.BLOCKCHAIN_POINTER]: 0x44,
 44 |     [StakingDataSourceType.SCRIPT_HASH]: 0x55,
 45 |   } as const
 46 | 
 47 |   switch (dataSource.type) {
 48 |     case StakingDataSourceType.NONE: {
 49 |       return Buffer.concat([
 50 |         uint8_to_buf(stakingChoicesEncoding[dataSource.type] as Uint8_t),
 51 |       ])
 52 |     }
 53 |     case StakingDataSourceType.KEY_HASH: {
 54 |       return Buffer.concat([
 55 |         uint8_to_buf(stakingChoicesEncoding[dataSource.type] as Uint8_t),
 56 |         hex_to_buf(dataSource.keyHashHex),
 57 |       ])
 58 |     }
 59 |     case StakingDataSourceType.SCRIPT_HASH: {
 60 |       return Buffer.concat([
 61 |         uint8_to_buf(stakingChoicesEncoding[dataSource.type] as Uint8_t),
 62 |         hex_to_buf(dataSource.scriptHashHex),
 63 |       ])
 64 |     }
 65 |     case StakingDataSourceType.KEY_PATH: {
 66 |       return Buffer.concat([
 67 |         uint8_to_buf(stakingChoicesEncoding[dataSource.type] as Uint8_t),
 68 |         path_to_buf(dataSource.path),
 69 |       ])
 70 |     }
 71 |     case StakingDataSourceType.BLOCKCHAIN_POINTER: {
 72 |       return Buffer.concat([
 73 |         uint8_to_buf(stakingChoicesEncoding[dataSource.type] as Uint8_t),
 74 |         uint32_to_buf(dataSource.pointer.blockIndex),
 75 |         uint32_to_buf(dataSource.pointer.txIndex),
 76 |         uint32_to_buf(dataSource.pointer.certificateIndex),
 77 |       ])
 78 |     }
 79 |     default:
 80 |       unreachable(dataSource)
 81 |   }
 82 | }
 83 | 
 84 | export function serializeAddressParams(
 85 |   params: ParsedAddressParams,
 86 |   version: Version,
 87 | ): Buffer {
 88 |   let spending: SpendingDataSource = params.spendingDataSource
 89 |   let staking: StakingDataSource = params.stakingDataSource
 90 |   if (!getCompatibility(version).supportsMultisigTransaction) {
 91 |     if (params.type === AddressType.REWARD_KEY) {
 92 |       assert(
 93 |         staking.type === StakingDataSourceType.KEY_PATH,
 94 |         InvalidDataReason.ADDRESS_INVALID_STAKING_INFO,
 95 |       )
 96 |       spending = {
 97 |         type: SpendingDataSourceType.PATH,
 98 |         path: staking.path,
 99 |       }
100 |       staking = {
101 |         type: StakingDataSourceType.NONE,
102 |       }
103 |     } else if (params.type === AddressType.REWARD_SCRIPT) {
104 |       throw new DeviceVersionUnsupported(
105 |         `Scripthash based address derivation not supported by Ledger app version ${getVersionString(
106 |           version,
107 |         )}.`,
108 |       )
109 |     }
110 |   }
111 |   return Buffer.concat([
112 |     uint8_to_buf(params.type as Uint8_t),
113 |     params.type === AddressType.BYRON
114 |       ? uint32_to_buf(params.protocolMagic)
115 |       : uint8_to_buf(params.networkId),
116 |     serializeSpendingDataSource(spending),
117 |     serializeStakingDataSource(staking),
118 |   ])
119 | }
120 | 


--------------------------------------------------------------------------------
/src/interactions/serialization/cVoteRegistration.ts:
--------------------------------------------------------------------------------
  1 | import {getCompatibility} from '../../interactions/getVersion'
  2 | import type {
  3 |   CVotePublicKey,
  4 |   ParsedCVoteDelegation,
  5 |   ParsedCVoteRegistrationParams,
  6 |   ParsedOutputDestination,
  7 |   Uint8_t,
  8 |   Uint32_t,
  9 |   Uint64_str,
 10 |   ValidBIP32Path,
 11 | } from '../../types/internal'
 12 | import type {Version} from '../../types/public'
 13 | import {
 14 |   TxOutputDestinationType,
 15 |   CIP36VoteDelegationType,
 16 |   CIP36VoteRegistrationFormat,
 17 | } from '../../types/public'
 18 | import {assert, unreachable} from '../../utils/assert'
 19 | import {
 20 |   hex_to_buf,
 21 |   path_to_buf,
 22 |   serializeOptionFlag,
 23 |   uint8_to_buf,
 24 |   uint32_to_buf,
 25 |   uint64_to_buf,
 26 | } from '../../utils/serialize'
 27 | import {serializeAddressParams} from './addressParams'
 28 | import {serializeTxOutputDestination} from './txOutput'
 29 | 
 30 | export function serializeCVoteRegistrationInit(
 31 |   params: ParsedCVoteRegistrationParams,
 32 | ): Buffer {
 33 |   const registrationFormatEncoding = {
 34 |     [CIP36VoteRegistrationFormat.CIP_15]: 0x01,
 35 |     [CIP36VoteRegistrationFormat.CIP_36]: 0x02,
 36 |   } as const
 37 |   const formatBuffer = uint8_to_buf(
 38 |     registrationFormatEncoding[params.format] as Uint8_t,
 39 |   )
 40 | 
 41 |   const numDelegations =
 42 |     params.delegations != null ? params.delegations.length : 0
 43 |   const numDelegationsBuffer = uint32_to_buf(numDelegations as Uint32_t)
 44 | 
 45 |   return Buffer.concat([
 46 |     formatBuffer, // 1 B
 47 |     numDelegationsBuffer, // 4 B
 48 |   ])
 49 | }
 50 | 
 51 | function serializeDelegationType(type: CIP36VoteDelegationType): Buffer {
 52 |   const delegationTypeEncoding = {
 53 |     [CIP36VoteDelegationType.KEY]: 0x01,
 54 |     [CIP36VoteDelegationType.PATH]: 0x02,
 55 |   } as const
 56 |   return uint8_to_buf(delegationTypeEncoding[type] as Uint8_t)
 57 | }
 58 | 
 59 | export function serializeCVoteRegistrationVoteKey(
 60 |   votePublicKey: CVotePublicKey | null,
 61 |   votePublicKeyPath: ValidBIP32Path | null,
 62 |   version: Version,
 63 | ): Buffer {
 64 |   if (votePublicKey != null) {
 65 |     assert(votePublicKeyPath == null, 'redundant vote key path')
 66 | 
 67 |     const delegationTypeBuffer = getCompatibility(version).supportsCIP36
 68 |       ? serializeDelegationType(CIP36VoteDelegationType.KEY)
 69 |       : Buffer.from([])
 70 | 
 71 |     return Buffer.concat([delegationTypeBuffer, hex_to_buf(votePublicKey)])
 72 |   } else {
 73 |     assert(votePublicKeyPath != null, 'missing vote key')
 74 |     assert(
 75 |       getCompatibility(version).supportsCIP36Vote,
 76 |       'key derivation path for vote keys not supported by the device',
 77 |     )
 78 | 
 79 |     return Buffer.concat([
 80 |       serializeDelegationType(CIP36VoteDelegationType.PATH),
 81 |       path_to_buf(votePublicKeyPath),
 82 |     ])
 83 |   }
 84 | }
 85 | 
 86 | export function serializeCVoteRegistrationDelegation(
 87 |   delegation: ParsedCVoteDelegation,
 88 | ): Buffer {
 89 |   const typeBuffer = serializeDelegationType(delegation.type)
 90 | 
 91 |   const weightBuffer = uint32_to_buf(delegation.weight)
 92 | 
 93 |   switch (delegation.type) {
 94 |     case CIP36VoteDelegationType.KEY:
 95 |       return Buffer.concat([
 96 |         typeBuffer,
 97 |         hex_to_buf(delegation.voteKey),
 98 |         weightBuffer,
 99 |       ])
100 | 
101 |     case CIP36VoteDelegationType.PATH:
102 |       return Buffer.concat([
103 |         typeBuffer,
104 |         path_to_buf(delegation.voteKeyPath),
105 |         weightBuffer,
106 |       ])
107 | 
108 |     default:
109 |       unreachable(delegation)
110 |   }
111 | }
112 | 
113 | export function serializeCVoteRegistrationStakingPath(
114 |   stakingPath: ValidBIP32Path,
115 | ): Buffer {
116 |   return Buffer.concat([path_to_buf(stakingPath)])
117 | }
118 | 
119 | export function serializeCVoteRegistrationPaymentDestination(
120 |   paymentDestination: ParsedOutputDestination,
121 |   version: Version,
122 | ): Buffer {
123 |   if (getCompatibility(version).supportsCIP36) {
124 |     return serializeTxOutputDestination(paymentDestination, version)
125 |   } else {
126 |     // older ledger versions with only Catalyst as in CIP-15
127 |     assert(
128 |       paymentDestination.type === TxOutputDestinationType.DEVICE_OWNED,
129 |       'wrong destination for payment address in Catalyst',
130 |     )
131 |     return serializeAddressParams(paymentDestination.addressParams, version)
132 |   }
133 | }
134 | 
135 | export function serializeCVoteRegistrationNonce(nonce: Uint64_str): Buffer {
136 |   return Buffer.concat([uint64_to_buf(nonce)])
137 | }
138 | 
139 | export function serializeCVoteRegistrationVotingPurpose(
140 |   votingPurpose: Uint64_str | null,
141 | ): Buffer {
142 |   const includeVotingPurposeBuffer = serializeOptionFlag(votingPurpose != null)
143 | 
144 |   const votingPurposeBuffer =
145 |     votingPurpose != null ? uint64_to_buf(votingPurpose) : Buffer.from([])
146 | 
147 |   return Buffer.concat([
148 |     includeVotingPurposeBuffer, // 1 B
149 |     votingPurposeBuffer, // 0 or 8 B
150 |   ])
151 | }
152 | 


--------------------------------------------------------------------------------
/src/interactions/serialization/messageData.ts:
--------------------------------------------------------------------------------
 1 | import type {Version} from '../../types/public'
 2 | import {MessageAddressFieldType} from '../../types/public'
 3 | import type {ParsedMessageData, Uint32_t, Uint8_t} from '../../types/internal'
 4 | import {path_to_buf, uint32_to_buf, uint8_to_buf} from '../../utils/serialize'
 5 | import {serializeAddressParams} from './addressParams'
 6 | 
 7 | export function serializeMessageDataInit(
 8 |   version: Version,
 9 |   msgData: ParsedMessageData,
10 | ): Buffer {
11 |   const msgLengthBuffer = uint32_to_buf(
12 |     (msgData.messageHex.length / 2) as Uint32_t,
13 |   )
14 | 
15 |   const hashPayloadBuffer = msgData.hashPayload
16 |     ? uint8_to_buf(1 as Uint8_t)
17 |     : uint8_to_buf(0 as Uint8_t)
18 | 
19 |   const isAsciiBuffer = msgData.isAscii
20 |     ? uint8_to_buf(1 as Uint8_t)
21 |     : uint8_to_buf(0 as Uint8_t)
22 | 
23 |   const addressFieldTypeEncoding = {
24 |     [MessageAddressFieldType.ADDRESS]: 0x01,
25 |     [MessageAddressFieldType.KEY_HASH]: 0x02,
26 |   } as const
27 |   const addressFieldTypeBuffer = uint8_to_buf(
28 |     addressFieldTypeEncoding[msgData.addressFieldType] as Uint8_t,
29 |   )
30 | 
31 |   const addressBuffer =
32 |     msgData.addressFieldType === MessageAddressFieldType.ADDRESS
33 |       ? serializeAddressParams(msgData.address, version)
34 |       : Buffer.concat([])
35 | 
36 |   return Buffer.concat([
37 |     msgLengthBuffer,
38 |     path_to_buf(msgData.signingPath),
39 |     hashPayloadBuffer,
40 |     isAsciiBuffer,
41 |     addressFieldTypeBuffer,
42 |     addressBuffer,
43 |   ])
44 | }
45 | 


--------------------------------------------------------------------------------
/src/interactions/serialization/nativeScript.ts:
--------------------------------------------------------------------------------
 1 | import type {
 2 |   ParsedComplexNativeScript,
 3 |   ParsedSimpleNativeScript,
 4 |   Uint8_t,
 5 |   Uint32_t,
 6 | } from '../../types/internal'
 7 | import {
 8 |   NativeScriptHashDisplayFormat,
 9 |   NativeScriptType,
10 | } from '../../types/internal'
11 | import {unreachable} from '../../utils/assert'
12 | import {
13 |   hex_to_buf,
14 |   path_to_buf,
15 |   uint8_to_buf,
16 |   uint32_to_buf,
17 |   uint64_to_buf,
18 | } from '../../utils/serialize'
19 | 
20 | const TYPE_ENCODING = {
21 |   [NativeScriptType.PUBKEY_DEVICE_OWNED]: 0 as Uint8_t,
22 |   [NativeScriptType.PUBKEY_THIRD_PARTY]: 0 as Uint8_t,
23 |   [NativeScriptType.ALL]: 1 as Uint8_t,
24 |   [NativeScriptType.ANY]: 2 as Uint8_t,
25 |   [NativeScriptType.N_OF_K]: 3 as Uint8_t,
26 |   [NativeScriptType.INVALID_BEFORE]: 4 as Uint8_t,
27 |   [NativeScriptType.INVALID_HEREAFTER]: 5 as Uint8_t,
28 | }
29 | 
30 | const PUBKEY_TYPE_ENCODING = {
31 |   [NativeScriptType.PUBKEY_DEVICE_OWNED]: 1 as Uint8_t,
32 |   [NativeScriptType.PUBKEY_THIRD_PARTY]: 2 as Uint8_t,
33 | }
34 | 
35 | const DISPLAY_FORMAT_ENCODING = {
36 |   [NativeScriptHashDisplayFormat.BECH32]: 1 as Uint8_t,
37 |   [NativeScriptHashDisplayFormat.POLICY_ID]: 2 as Uint8_t,
38 | }
39 | 
40 | export function serializeComplexNativeScriptStart(
41 |   script: ParsedComplexNativeScript,
42 | ): Buffer {
43 |   switch (script.type) {
44 |     case NativeScriptType.ALL:
45 |     case NativeScriptType.ANY:
46 |       return Buffer.concat([
47 |         uint8_to_buf(TYPE_ENCODING[script.type]),
48 |         uint32_to_buf(script.params.scripts.length as Uint32_t),
49 |       ])
50 |     case NativeScriptType.N_OF_K:
51 |       return Buffer.concat([
52 |         uint8_to_buf(TYPE_ENCODING[script.type]),
53 |         uint32_to_buf(script.params.scripts.length as Uint32_t), // K
54 |         uint32_to_buf(script.params.requiredCount), // N
55 |       ])
56 |     default:
57 |       unreachable(script)
58 |   }
59 | }
60 | 
61 | export function serializeSimpleNativeScript(
62 |   script: ParsedSimpleNativeScript,
63 | ): Buffer {
64 |   switch (script.type) {
65 |     case NativeScriptType.PUBKEY_DEVICE_OWNED:
66 |       return Buffer.concat([
67 |         uint8_to_buf(TYPE_ENCODING[script.type]),
68 |         uint8_to_buf(PUBKEY_TYPE_ENCODING[script.type]),
69 |         path_to_buf(script.params.path),
70 |       ])
71 |     case NativeScriptType.PUBKEY_THIRD_PARTY:
72 |       return Buffer.concat([
73 |         uint8_to_buf(TYPE_ENCODING[script.type]),
74 |         uint8_to_buf(PUBKEY_TYPE_ENCODING[script.type]),
75 |         hex_to_buf(script.params.keyHashHex),
76 |       ])
77 |     case NativeScriptType.INVALID_BEFORE:
78 |       return Buffer.concat([
79 |         uint8_to_buf(TYPE_ENCODING[script.type]),
80 |         uint64_to_buf(script.params.slot),
81 |       ])
82 |     case NativeScriptType.INVALID_HEREAFTER:
83 |       return Buffer.concat([
84 |         uint8_to_buf(TYPE_ENCODING[script.type]),
85 |         uint64_to_buf(script.params.slot),
86 |       ])
87 |     default:
88 |       unreachable(script)
89 |   }
90 | }
91 | 
92 | export function serializeWholeNativeScriptFinish(
93 |   displayFormat: NativeScriptHashDisplayFormat,
94 | ): Buffer {
95 |   return Buffer.concat([uint8_to_buf(DISPLAY_FORMAT_ENCODING[displayFormat])])
96 | }
97 | 


--------------------------------------------------------------------------------
/src/interactions/serialization/operationalCertificate.ts:
--------------------------------------------------------------------------------
 1 | import type {ParsedOperationalCertificate} from '../../types/internal'
 2 | import {hex_to_buf, path_to_buf, uint64_to_buf} from '../../utils/serialize'
 3 | 
 4 | export function serializeOperationalCertificate({
 5 |   kesPublicKeyHex,
 6 |   kesPeriod,
 7 |   issueCounter,
 8 |   coldKeyPath,
 9 | }: ParsedOperationalCertificate): Buffer {
10 |   return Buffer.concat([
11 |     hex_to_buf(kesPublicKeyHex),
12 |     uint64_to_buf(kesPeriod),
13 |     uint64_to_buf(issueCounter),
14 |     path_to_buf(coldKeyPath),
15 |   ])
16 | }
17 | 


--------------------------------------------------------------------------------
/src/interactions/serialization/poolRegistrationCertificate.ts:
--------------------------------------------------------------------------------
  1 | import type {
  2 |   ParsedPoolKey,
  3 |   ParsedPoolMetadata,
  4 |   ParsedPoolOwner,
  5 |   ParsedPoolParams,
  6 |   ParsedPoolRelay,
  7 |   ParsedPoolRewardAccount,
  8 |   Uint8_t,
  9 |   Uint32_t,
 10 | } from '../../types/internal'
 11 | import {
 12 |   PoolKeyType,
 13 |   PoolOwnerType,
 14 |   PoolRewardAccountType,
 15 |   RelayType,
 16 | } from '../../types/internal'
 17 | import {assert, unreachable} from '../../utils/assert'
 18 | import {
 19 |   hex_to_buf,
 20 |   path_to_buf,
 21 |   uint8_to_buf,
 22 |   uint16_to_buf,
 23 |   uint32_to_buf,
 24 |   uint64_to_buf,
 25 |   serializeCoin,
 26 | } from '../../utils/serialize'
 27 | 
 28 | const SignTxIncluded = Object.freeze({
 29 |   SIGN_TX_INCLUDED_NO: 1,
 30 |   SIGN_TX_INCLUDED_YES: 2,
 31 | })
 32 | 
 33 | export function serializePoolInitialParams(pool: ParsedPoolParams): Buffer {
 34 |   return Buffer.concat([
 35 |     uint32_to_buf(pool.owners.length as Uint32_t),
 36 |     uint32_to_buf(pool.relays.length as Uint32_t),
 37 |   ])
 38 | }
 39 | 
 40 | export function serializePoolInitialParamsLegacy(
 41 |   pool: ParsedPoolParams,
 42 | ): Buffer {
 43 |   return Buffer.concat([
 44 |     // eslint-disable-next-line @typescript-eslint/no-use-before-define
 45 |     serializePoolKeyLegacy(pool.poolKey),
 46 |     hex_to_buf(pool.vrfHashHex),
 47 |     serializeCoin(pool.pledge),
 48 |     serializeCoin(pool.cost),
 49 |     uint64_to_buf(pool.margin.numerator),
 50 |     uint64_to_buf(pool.margin.denominator),
 51 |     // eslint-disable-next-line @typescript-eslint/no-use-before-define
 52 |     serializePoolRewardAccountLegacy(pool.rewardAccount),
 53 |     uint32_to_buf(pool.owners.length as Uint32_t),
 54 |     uint32_to_buf(pool.relays.length as Uint32_t),
 55 |   ])
 56 | }
 57 | 
 58 | export function serializeFinancials(pool: ParsedPoolParams): Buffer {
 59 |   return Buffer.concat([
 60 |     serializeCoin(pool.pledge),
 61 |     serializeCoin(pool.cost),
 62 |     uint64_to_buf(pool.margin.numerator),
 63 |     uint64_to_buf(pool.margin.denominator),
 64 |   ])
 65 | }
 66 | 
 67 | export function serializePoolKey(key: ParsedPoolKey): Buffer {
 68 |   const typeHeader: Record<PoolKeyType, Uint8_t> = {
 69 |     [PoolKeyType.DEVICE_OWNED]: 1 as Uint8_t,
 70 |     [PoolKeyType.THIRD_PARTY]: 2 as Uint8_t,
 71 |   }
 72 |   switch (key.type) {
 73 |     case PoolKeyType.DEVICE_OWNED: {
 74 |       return Buffer.concat([
 75 |         uint8_to_buf(typeHeader[key.type]),
 76 |         path_to_buf(key.path),
 77 |       ])
 78 |     }
 79 |     case PoolKeyType.THIRD_PARTY: {
 80 |       return Buffer.concat([
 81 |         uint8_to_buf(typeHeader[key.type]),
 82 |         hex_to_buf(key.hashHex),
 83 |       ])
 84 |     }
 85 |     default:
 86 |       unreachable(key)
 87 |   }
 88 | }
 89 | 
 90 | export function serializePoolKeyLegacy(key: ParsedPoolKey): Buffer {
 91 |   assert(
 92 |     key.type === PoolKeyType.THIRD_PARTY,
 93 |     'invalid pool key type for legacy Ledger version',
 94 |   )
 95 |   return hex_to_buf(key.hashHex)
 96 | }
 97 | 
 98 | export function serializePoolOwner(owner: ParsedPoolOwner): Buffer {
 99 |   const typeHeader: Record<PoolOwnerType, Uint8_t> = {
100 |     [PoolOwnerType.DEVICE_OWNED]: 1 as Uint8_t,
101 |     [PoolOwnerType.THIRD_PARTY]: 2 as Uint8_t,
102 |   }
103 |   switch (owner.type) {
104 |     case PoolOwnerType.DEVICE_OWNED: {
105 |       return Buffer.concat([
106 |         uint8_to_buf(typeHeader[owner.type]),
107 |         path_to_buf(owner.path),
108 |       ])
109 |     }
110 |     case PoolOwnerType.THIRD_PARTY: {
111 |       return Buffer.concat([
112 |         uint8_to_buf(typeHeader[owner.type]),
113 |         hex_to_buf(owner.hashHex),
114 |       ])
115 |     }
116 |     default:
117 |       unreachable(owner)
118 |   }
119 | }
120 | 
121 | export function serializePoolRewardAccount(
122 |   rewardAccount: ParsedPoolRewardAccount,
123 | ): Buffer {
124 |   const typeHeader: Record<PoolRewardAccountType, Uint8_t> = {
125 |     [PoolRewardAccountType.DEVICE_OWNED]: 1 as Uint8_t,
126 |     [PoolRewardAccountType.THIRD_PARTY]: 2 as Uint8_t,
127 |   }
128 |   switch (rewardAccount.type) {
129 |     case PoolRewardAccountType.DEVICE_OWNED: {
130 |       return Buffer.concat([
131 |         uint8_to_buf(typeHeader[rewardAccount.type]),
132 |         path_to_buf(rewardAccount.path),
133 |       ])
134 |     }
135 |     case PoolRewardAccountType.THIRD_PARTY: {
136 |       return Buffer.concat([
137 |         uint8_to_buf(typeHeader[rewardAccount.type]),
138 |         hex_to_buf(rewardAccount.rewardAccountHex),
139 |       ])
140 |     }
141 |     default:
142 |       unreachable(rewardAccount)
143 |   }
144 | }
145 | 
146 | export function serializePoolRewardAccountLegacy(
147 |   rewardAccount: ParsedPoolRewardAccount,
148 | ): Buffer {
149 |   assert(
150 |     rewardAccount.type === PoolRewardAccountType.THIRD_PARTY,
151 |     'invalid pool reward account type for legacy Ledger version',
152 |   )
153 |   return hex_to_buf(rewardAccount.rewardAccountHex)
154 | }
155 | 
156 | export function serializePoolRelay(relay: ParsedPoolRelay): Buffer {
157 |   function serializeOptional<T>(x: T | null, cb: (t: T) => Buffer): Buffer {
158 |     const enum Optional {
159 |       NONE = 1,
160 |       SOME = 2,
161 |     }
162 | 
163 |     if (x == null) {
164 |       return Buffer.concat([uint8_to_buf(Optional.NONE as Uint8_t)])
165 |     } else {
166 |       return Buffer.concat([uint8_to_buf(Optional.SOME as Uint8_t), cb(x)])
167 |     }
168 |   }
169 | 
170 |   switch (relay.type) {
171 |     case RelayType.SINGLE_HOST_IP_ADDR: {
172 |       return Buffer.concat([
173 |         uint8_to_buf(relay.type as Uint8_t),
174 |         serializeOptional(relay.port, (port) => uint16_to_buf(port)),
175 |         serializeOptional(relay.ipv4, (ipv4) => ipv4),
176 |         serializeOptional(relay.ipv6, (ipv6) => ipv6),
177 |       ])
178 |     }
179 |     case RelayType.SINGLE_HOST_HOSTNAME: {
180 |       return Buffer.concat([
181 |         uint8_to_buf(relay.type as Uint8_t),
182 |         serializeOptional(relay.port, (port) => uint16_to_buf(port)),
183 |         Buffer.from(relay.dnsName, 'ascii'),
184 |       ])
185 |     }
186 |     case RelayType.MULTI_HOST: {
187 |       return Buffer.concat([
188 |         uint8_to_buf(relay.type as Uint8_t),
189 |         Buffer.from(relay.dnsName, 'ascii'),
190 |       ])
191 |     }
192 |     default:
193 |       unreachable(relay)
194 |   }
195 | }
196 | 
197 | export function serializePoolMetadata(
198 |   metadata: ParsedPoolMetadata | null,
199 | ): Buffer {
200 |   if (metadata == null) {
201 |     return Buffer.concat([
202 |       uint8_to_buf(SignTxIncluded.SIGN_TX_INCLUDED_NO as Uint8_t),
203 |     ])
204 |   } else {
205 |     return Buffer.concat([
206 |       uint8_to_buf(SignTxIncluded.SIGN_TX_INCLUDED_YES as Uint8_t),
207 |       hex_to_buf(metadata.hashHex),
208 |       Buffer.from(metadata.url, 'ascii'),
209 |     ])
210 |   }
211 | }
212 | 


--------------------------------------------------------------------------------
/src/interactions/serialization/txAuxiliaryData.ts:
--------------------------------------------------------------------------------
 1 | import type {ParsedTxAuxiliaryData, Uint8_t} from '../../types/internal'
 2 | import {TxAuxiliaryDataType} from '../../types/internal'
 3 | import {unreachable} from '../../utils/assert'
 4 | import {hex_to_buf, uint8_to_buf} from '../../utils/serialize'
 5 | 
 6 | export function serializeTxAuxiliaryData(
 7 |   auxiliaryData: ParsedTxAuxiliaryData,
 8 | ): Buffer {
 9 |   const auxiliaryDataTypesEncoding = {
10 |     [TxAuxiliaryDataType.ARBITRARY_HASH]: 0x00,
11 |     [TxAuxiliaryDataType.CIP36_REGISTRATION]: 0x01,
12 |   } as const
13 | 
14 |   switch (auxiliaryData.type) {
15 |     case TxAuxiliaryDataType.ARBITRARY_HASH: {
16 |       return Buffer.concat([
17 |         uint8_to_buf(auxiliaryDataTypesEncoding[auxiliaryData.type] as Uint8_t),
18 |         hex_to_buf(auxiliaryData.hashHex),
19 |       ])
20 |     }
21 |     case TxAuxiliaryDataType.CIP36_REGISTRATION: {
22 |       return Buffer.concat([
23 |         uint8_to_buf(auxiliaryDataTypesEncoding[auxiliaryData.type] as Uint8_t),
24 |       ])
25 |     }
26 |     default:
27 |       unreachable(auxiliaryData)
28 |   }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/interactions/serialization/txCertificate.ts:
--------------------------------------------------------------------------------
  1 | import {
  2 |   DRepType,
  3 |   Uint8_t,
  4 |   CredentialType,
  5 |   CertificateType,
  6 | } from '../../types/internal'
  7 | import type {ParsedCertificate, ParsedDRep, Version} from '../../types/internal'
  8 | import {assert, unreachable} from '../../utils/assert'
  9 | import {
 10 |   hex_to_buf,
 11 |   path_to_buf,
 12 |   serializeCredential,
 13 |   uint8_to_buf,
 14 |   uint64_to_buf,
 15 |   serializeCoin,
 16 |   serializeAnchor,
 17 | } from '../../utils/serialize'
 18 | import {getCompatibility} from '../getVersion'
 19 | 
 20 | export function serializeDRep(dRep: ParsedDRep): Buffer {
 21 |   switch (dRep.type) {
 22 |     case DRepType.KEY_PATH:
 23 |       return Buffer.concat([
 24 |         uint8_to_buf(dRep.type as Uint8_t),
 25 |         path_to_buf(dRep.path),
 26 |       ])
 27 |     case DRepType.KEY_HASH:
 28 |       return Buffer.concat([
 29 |         uint8_to_buf(dRep.type as Uint8_t),
 30 |         hex_to_buf(dRep.keyHashHex),
 31 |       ])
 32 |     case DRepType.SCRIPT_HASH:
 33 |       return Buffer.concat([
 34 |         uint8_to_buf(dRep.type as Uint8_t),
 35 |         hex_to_buf(dRep.scriptHashHex),
 36 |       ])
 37 |     case DRepType.ABSTAIN:
 38 |     case DRepType.NO_CONFIDENCE:
 39 |       return Buffer.concat([uint8_to_buf(dRep.type as Uint8_t)])
 40 |     default:
 41 |       unreachable(dRep)
 42 |   }
 43 | }
 44 | 
 45 | export function serializeTxCertificatePreMultisig(
 46 |   certificate: ParsedCertificate,
 47 | ) {
 48 |   switch (certificate.type) {
 49 |     case CertificateType.STAKE_REGISTRATION:
 50 |     case CertificateType.STAKE_DEREGISTRATION: {
 51 |       assert(
 52 |         certificate.stakeCredential.type === CredentialType.KEY_PATH,
 53 |         'invalid stake credential',
 54 |       )
 55 |       return Buffer.concat([
 56 |         uint8_to_buf(certificate.type as Uint8_t),
 57 |         path_to_buf(certificate.stakeCredential.path),
 58 |       ])
 59 |     }
 60 |     case CertificateType.STAKE_DELEGATION: {
 61 |       assert(
 62 |         certificate.stakeCredential.type === CredentialType.KEY_PATH,
 63 |         'invalid stake credential',
 64 |       )
 65 |       return Buffer.concat([
 66 |         uint8_to_buf(certificate.type as Uint8_t),
 67 |         path_to_buf(certificate.stakeCredential.path),
 68 |         hex_to_buf(certificate.poolKeyHashHex),
 69 |       ])
 70 |     }
 71 |     case CertificateType.STAKE_POOL_REGISTRATION: {
 72 |       return Buffer.concat([uint8_to_buf(certificate.type as Uint8_t)])
 73 |     }
 74 |     case CertificateType.STAKE_POOL_RETIREMENT: {
 75 |       return Buffer.concat([
 76 |         uint8_to_buf(certificate.type as Uint8_t),
 77 |         path_to_buf(certificate.path),
 78 |         uint64_to_buf(certificate.retirementEpoch),
 79 |       ])
 80 |     }
 81 |     case CertificateType.STAKE_REGISTRATION_CONWAY:
 82 |     case CertificateType.STAKE_DEREGISTRATION_CONWAY:
 83 |     case CertificateType.VOTE_DELEGATION:
 84 |     case CertificateType.AUTHORIZE_COMMITTEE_HOT:
 85 |     case CertificateType.RESIGN_COMMITTEE_COLD:
 86 |     case CertificateType.DREP_REGISTRATION:
 87 |     case CertificateType.DREP_DEREGISTRATION:
 88 |     case CertificateType.DREP_UPDATE: {
 89 |       assert(false, 'Conway certificates in pre-multisig serialization')
 90 |       break
 91 |     }
 92 |     default:
 93 |       unreachable(certificate)
 94 |   }
 95 | }
 96 | 
 97 | export function serializeTxCertificate(
 98 |   certificate: ParsedCertificate,
 99 |   version: Version,
100 | ) {
101 |   if (!getCompatibility(version).supportsMultisigTransaction) {
102 |     return serializeTxCertificatePreMultisig(certificate)
103 |   }
104 | 
105 |   switch (certificate.type) {
106 |     case CertificateType.STAKE_REGISTRATION:
107 |     case CertificateType.STAKE_DEREGISTRATION: {
108 |       return Buffer.concat([
109 |         uint8_to_buf(certificate.type as Uint8_t),
110 |         serializeCredential(certificate.stakeCredential),
111 |       ])
112 |     }
113 |     case CertificateType.STAKE_REGISTRATION_CONWAY:
114 |     case CertificateType.STAKE_DEREGISTRATION_CONWAY: {
115 |       return Buffer.concat([
116 |         uint8_to_buf(certificate.type as Uint8_t),
117 |         serializeCredential(certificate.stakeCredential),
118 |         serializeCoin(certificate.deposit),
119 |       ])
120 |     }
121 |     case CertificateType.STAKE_DELEGATION: {
122 |       return Buffer.concat([
123 |         uint8_to_buf(certificate.type as Uint8_t),
124 |         serializeCredential(certificate.stakeCredential),
125 |         hex_to_buf(certificate.poolKeyHashHex),
126 |       ])
127 |     }
128 |     case CertificateType.VOTE_DELEGATION: {
129 |       return Buffer.concat([
130 |         uint8_to_buf(certificate.type as Uint8_t),
131 |         serializeCredential(certificate.stakeCredential),
132 |         serializeDRep(certificate.dRep),
133 |       ])
134 |     }
135 |     case CertificateType.AUTHORIZE_COMMITTEE_HOT: {
136 |       return Buffer.concat([
137 |         uint8_to_buf(certificate.type as Uint8_t),
138 |         serializeCredential(certificate.coldCredential),
139 |         serializeCredential(certificate.hotCredential),
140 |       ])
141 |     }
142 |     case CertificateType.RESIGN_COMMITTEE_COLD: {
143 |       return Buffer.concat([
144 |         uint8_to_buf(certificate.type as Uint8_t),
145 |         serializeCredential(certificate.coldCredential),
146 |         serializeAnchor(certificate.anchor),
147 |       ])
148 |     }
149 |     case CertificateType.DREP_REGISTRATION: {
150 |       return Buffer.concat([
151 |         uint8_to_buf(certificate.type as Uint8_t),
152 |         serializeCredential(certificate.dRepCredential),
153 |         serializeCoin(certificate.deposit),
154 |         serializeAnchor(certificate.anchor),
155 |       ])
156 |     }
157 |     case CertificateType.DREP_DEREGISTRATION: {
158 |       return Buffer.concat([
159 |         uint8_to_buf(certificate.type as Uint8_t),
160 |         serializeCredential(certificate.dRepCredential),
161 |         serializeCoin(certificate.deposit),
162 |       ])
163 |     }
164 |     case CertificateType.DREP_UPDATE: {
165 |       return Buffer.concat([
166 |         uint8_to_buf(certificate.type as Uint8_t),
167 |         serializeCredential(certificate.dRepCredential),
168 |         serializeAnchor(certificate.anchor),
169 |       ])
170 |     }
171 |     case CertificateType.STAKE_POOL_REGISTRATION: {
172 |       return Buffer.concat([uint8_to_buf(certificate.type as Uint8_t)])
173 |     }
174 |     case CertificateType.STAKE_POOL_RETIREMENT: {
175 |       return Buffer.concat([
176 |         uint8_to_buf(certificate.type as Uint8_t),
177 |         path_to_buf(certificate.path),
178 |         uint64_to_buf(certificate.retirementEpoch),
179 |       ])
180 |     }
181 |     default:
182 |       unreachable(certificate)
183 |   }
184 | }
185 | 


--------------------------------------------------------------------------------
/src/interactions/serialization/txInit.ts:
--------------------------------------------------------------------------------
  1 | import type {
  2 |   ParsedTransaction,
  3 |   Uint8_t,
  4 |   Uint32_t,
  5 |   Version,
  6 |   ParsedTransactionOptions,
  7 |   Uint64_str,
  8 | } from '../../types/internal'
  9 | import {TransactionSigningMode} from '../../types/internal'
 10 | import {assert} from '../../utils/assert'
 11 | import {
 12 |   serializeOptionFlag,
 13 |   uint8_to_buf,
 14 |   uint32_to_buf,
 15 |   uint64_to_buf,
 16 | } from '../../utils/serialize'
 17 | import {getCompatibility} from '../getVersion'
 18 | 
 19 | const _serializeSigningMode = (mode: TransactionSigningMode): Buffer => {
 20 |   const value = {
 21 |     [TransactionSigningMode.ORDINARY_TRANSACTION]: 3 as Uint8_t,
 22 |     [TransactionSigningMode.POOL_REGISTRATION_AS_OWNER]: 4 as Uint8_t,
 23 |     [TransactionSigningMode.POOL_REGISTRATION_AS_OPERATOR]: 5 as Uint8_t,
 24 |     [TransactionSigningMode.MULTISIG_TRANSACTION]: 6 as Uint8_t,
 25 |     [TransactionSigningMode.PLUTUS_TRANSACTION]: 7 as Uint8_t,
 26 |   }[mode]
 27 | 
 28 |   assert(value !== undefined, 'Invalid signing mode')
 29 | 
 30 |   return uint8_to_buf(value)
 31 | }
 32 | 
 33 | const enum OptionFlags {
 34 |   TAG_CBOR_SETS = 1,
 35 | }
 36 | 
 37 | function serializeTxOptions(options: ParsedTransactionOptions): Buffer {
 38 |   // we reserve 64 bits for options in the APDU for future use
 39 |   // the code below would need to be changed if a typescript number
 40 |   // was not enough to fit all the future flags
 41 |   let optionFlags = 0
 42 |   if (options.tagCborSets) {
 43 |     optionFlags += OptionFlags.TAG_CBOR_SETS
 44 |   }
 45 |   return uint64_to_buf(optionFlags.toString() as Uint64_str)
 46 | }
 47 | 
 48 | export function serializeTxInit(
 49 |   tx: ParsedTransaction,
 50 |   signingMode: TransactionSigningMode,
 51 |   numWitnesses: number,
 52 |   options: ParsedTransactionOptions,
 53 |   version: Version,
 54 | ) {
 55 |   const optionsBuffer = getCompatibility(version).supportsConway
 56 |     ? serializeTxOptions(options)
 57 |     : Buffer.from([])
 58 | 
 59 |   const appAwareOfMint =
 60 |     getCompatibility(version).supportsMint || version.flags.isAppXS
 61 |   // even if XS app doesn't support minting, it does expect the flag value
 62 |   // (we want to keep the APDU serialization uniform)
 63 |   const mintBuffer = appAwareOfMint
 64 |     ? serializeOptionFlag(tx.mint != null)
 65 |     : Buffer.from([])
 66 | 
 67 |   const scriptDataHashBuffer = getCompatibility(version).supportsAlonzo
 68 |     ? serializeOptionFlag(tx.scriptDataHashHex != null)
 69 |     : Buffer.from([])
 70 |   const collateralInputsBuffer = getCompatibility(version).supportsAlonzo
 71 |     ? uint32_to_buf(tx.collateralInputs.length as Uint32_t)
 72 |     : Buffer.from([])
 73 |   const requiredSignersBuffer = getCompatibility(version).supportsAlonzo
 74 |     ? uint32_to_buf(tx.requiredSigners.length as Uint32_t)
 75 |     : Buffer.from([])
 76 |   const includeNetworkIdBuffer = getCompatibility(version).supportsAlonzo
 77 |     ? serializeOptionFlag(tx.includeNetworkId)
 78 |     : Buffer.from([])
 79 |   const includeCollateralOutputBuffer = getCompatibility(version)
 80 |     .supportsBabbage
 81 |     ? serializeOptionFlag(tx.collateralOutput != null)
 82 |     : Buffer.from([])
 83 |   const includeTotalCollateralBuffer = getCompatibility(version).supportsBabbage
 84 |     ? serializeOptionFlag(tx.totalCollateral != null)
 85 |     : Buffer.from([])
 86 |   const referenceInputsBuffer = getCompatibility(version).supportsBabbage
 87 |     ? uint32_to_buf(tx.referenceInputs.length as Uint32_t)
 88 |     : Buffer.from([])
 89 |   const votingProceduresBuffer = getCompatibility(version).supportsConway
 90 |     ? uint32_to_buf(tx.votingProcedures.length as Uint32_t)
 91 |     : Buffer.from([])
 92 |   const includeTreasuryBuffer = getCompatibility(version).supportsConway
 93 |     ? serializeOptionFlag(tx.treasury != null)
 94 |     : Buffer.from([])
 95 |   const includeDonationBuffer = getCompatibility(version).supportsConway
 96 |     ? serializeOptionFlag(tx.donation != null)
 97 |     : Buffer.from([])
 98 | 
 99 |   //  we have re-ordered numWitnesses in wireDataBuffer since Babbage
100 |   const witnessBufferLegacy = getCompatibility(version).supportsBabbage
101 |     ? Buffer.from([])
102 |     : uint32_to_buf(numWitnesses as Uint32_t)
103 |   const witnessBufferBabbage = getCompatibility(version).supportsBabbage
104 |     ? uint32_to_buf(numWitnesses as Uint32_t)
105 |     : Buffer.from([])
106 | 
107 |   return Buffer.concat([
108 |     optionsBuffer,
109 |     uint8_to_buf(tx.network.networkId),
110 |     uint32_to_buf(tx.network.protocolMagic),
111 |     serializeOptionFlag(tx.ttl != null),
112 |     serializeOptionFlag(tx.auxiliaryData != null),
113 |     serializeOptionFlag(tx.validityIntervalStart != null),
114 |     mintBuffer,
115 |     scriptDataHashBuffer,
116 |     includeNetworkIdBuffer,
117 |     includeCollateralOutputBuffer,
118 |     includeTotalCollateralBuffer,
119 |     includeTreasuryBuffer,
120 |     includeDonationBuffer,
121 |     _serializeSigningMode(signingMode),
122 |     uint32_to_buf(tx.inputs.length as Uint32_t),
123 |     uint32_to_buf(tx.outputs.length as Uint32_t),
124 |     uint32_to_buf(tx.certificates.length as Uint32_t),
125 |     uint32_to_buf(tx.withdrawals.length as Uint32_t),
126 |     witnessBufferLegacy,
127 |     collateralInputsBuffer,
128 |     requiredSignersBuffer,
129 |     referenceInputsBuffer,
130 |     votingProceduresBuffer,
131 |     witnessBufferBabbage,
132 |   ])
133 | }
134 | 


--------------------------------------------------------------------------------
/src/interactions/serialization/txOther.ts:
--------------------------------------------------------------------------------
  1 | import {VoterType} from '../../types/public'
  2 | import {InvalidDataReason} from '../../errors/invalidDataReason'
  3 | import type {
  4 |   Int64_str,
  5 |   ParsedAssetGroup,
  6 |   ParsedInput,
  7 |   ParsedRequiredSigner,
  8 |   ParsedToken,
  9 |   ParsedWithdrawal,
 10 |   Uint8_t,
 11 |   Uint32_t,
 12 |   Uint64_str,
 13 |   ValidBIP32Path,
 14 |   Version,
 15 |   ParsedVoterVotes,
 16 |   ParsedVoter,
 17 | } from '../../types/internal'
 18 | import {RequiredSignerType, CredentialType} from '../../types/internal'
 19 | import {assert, unreachable} from '../../utils/assert'
 20 | import {
 21 |   hex_to_buf,
 22 |   path_to_buf,
 23 |   serializeCredential,
 24 |   uint8_to_buf,
 25 |   uint32_to_buf,
 26 |   uint64_to_buf,
 27 |   serializeCoin,
 28 |   serializeAnchor,
 29 | } from '../../utils/serialize'
 30 | import {getCompatibility} from '../getVersion'
 31 | import type {SerializeTokenAmountFn} from '../signTx'
 32 | 
 33 | export function serializeTxInput(input: ParsedInput): Buffer {
 34 |   return Buffer.concat([
 35 |     hex_to_buf(input.txHashHex),
 36 |     uint32_to_buf(input.outputIndex),
 37 |   ])
 38 | }
 39 | 
 40 | export function serializeTxWithdrawal(
 41 |   withdrawal: ParsedWithdrawal,
 42 |   version: Version,
 43 | ): Buffer {
 44 |   if (getCompatibility(version).supportsMultisigTransaction) {
 45 |     return Buffer.concat([
 46 |       serializeCoin(withdrawal.amount),
 47 |       serializeCredential(withdrawal.stakeCredential),
 48 |     ])
 49 |   } else {
 50 |     // pre-multisig
 51 |     assert(
 52 |       withdrawal.stakeCredential.type === CredentialType.KEY_PATH,
 53 |       InvalidDataReason.WITHDRAWAL_INVALID_STAKE_CREDENTIAL,
 54 |     )
 55 |     return Buffer.concat([
 56 |       serializeCoin(withdrawal.amount),
 57 |       path_to_buf(withdrawal.stakeCredential.path),
 58 |     ])
 59 |   }
 60 | }
 61 | 
 62 | export function serializeTxTtl(ttl: Uint64_str): Buffer {
 63 |   return Buffer.concat([uint64_to_buf(ttl)])
 64 | }
 65 | 
 66 | export function serializeTxValidityStart(
 67 |   validityIntervalStart: Uint64_str,
 68 | ): Buffer {
 69 |   return Buffer.concat([uint64_to_buf(validityIntervalStart)])
 70 | }
 71 | 
 72 | export function serializeTxWitnessRequest(path: ValidBIP32Path): Buffer {
 73 |   return Buffer.concat([path_to_buf(path)])
 74 | }
 75 | 
 76 | export function serializeAssetGroup<T>(
 77 |   assetGroup: ParsedAssetGroup<T>,
 78 | ): Buffer {
 79 |   return Buffer.concat([
 80 |     hex_to_buf(assetGroup.policyIdHex),
 81 |     uint32_to_buf(assetGroup.tokens.length as Uint32_t),
 82 |   ])
 83 | }
 84 | 
 85 | export function serializeToken<T>(
 86 |   token: ParsedToken<T>,
 87 |   serializeTokenAmountFn: SerializeTokenAmountFn<T>,
 88 | ): Buffer {
 89 |   return Buffer.concat([
 90 |     uint32_to_buf((token.assetNameHex.length / 2) as Uint32_t),
 91 |     hex_to_buf(token.assetNameHex),
 92 |     serializeTokenAmountFn(token.amount),
 93 |   ])
 94 | }
 95 | 
 96 | export function serializeMintBasicParams(
 97 |   mint: Array<ParsedAssetGroup<Int64_str>>,
 98 | ): Buffer {
 99 |   return Buffer.concat([uint32_to_buf(mint.length as Uint32_t)])
100 | }
101 | 
102 | export function serializeRequiredSigner(
103 |   requiredSigner: ParsedRequiredSigner,
104 | ): Buffer {
105 |   switch (requiredSigner.type) {
106 |     case RequiredSignerType.PATH:
107 |       return Buffer.concat([
108 |         uint8_to_buf(requiredSigner.type as Uint8_t),
109 |         path_to_buf(requiredSigner.path),
110 |       ])
111 |     case RequiredSignerType.HASH:
112 |       return Buffer.concat([
113 |         uint8_to_buf(requiredSigner.type as Uint8_t),
114 |         hex_to_buf(requiredSigner.hashHex),
115 |       ])
116 |     default:
117 |       unreachable(requiredSigner)
118 |   }
119 | }
120 | 
121 | function serializeVoter(voter: ParsedVoter): Buffer {
122 |   switch (voter.type) {
123 |     case VoterType.COMMITTEE_KEY_HASH:
124 |     case VoterType.DREP_KEY_HASH:
125 |     case VoterType.STAKE_POOL_KEY_HASH:
126 |       return Buffer.concat([
127 |         uint8_to_buf(voter.type as Uint8_t),
128 |         hex_to_buf(voter.keyHashHex),
129 |       ])
130 |     case VoterType.COMMITTEE_KEY_PATH:
131 |     case VoterType.DREP_KEY_PATH:
132 |     case VoterType.STAKE_POOL_KEY_PATH:
133 |       return Buffer.concat([
134 |         uint8_to_buf(voter.type as Uint8_t),
135 |         path_to_buf(voter.keyPath),
136 |       ])
137 |     case VoterType.COMMITTEE_SCRIPT_HASH:
138 |     case VoterType.DREP_SCRIPT_HASH:
139 |       return Buffer.concat([
140 |         uint8_to_buf(voter.type as Uint8_t),
141 |         hex_to_buf(voter.scriptHashHex),
142 |       ])
143 |     default:
144 |       unreachable(voter)
145 |   }
146 | }
147 | 
148 | export function serializeVoterVotes(voterVotes: ParsedVoterVotes): Buffer {
149 |   assert(voterVotes.votes.length === 1, 'too few / too many votes')
150 |   const vote = voterVotes.votes[0]
151 |   return Buffer.concat([
152 |     serializeVoter(voterVotes.voter),
153 |     Buffer.concat([
154 |       hex_to_buf(vote.govActionId.txHashHex),
155 |       uint32_to_buf(vote.govActionId.govActionIndex),
156 |     ]),
157 |     Buffer.concat([
158 |       uint8_to_buf(vote.votingProcedure.vote as Uint8_t),
159 |       serializeAnchor(vote.votingProcedure.anchor),
160 |     ]),
161 |   ])
162 | }
163 | 


--------------------------------------------------------------------------------
/src/interactions/serialization/txOutput.ts:
--------------------------------------------------------------------------------
  1 | import type {
  2 |   HexString,
  3 |   ParsedDatum,
  4 |   ParsedOutput,
  5 |   ParsedOutputDestination,
  6 |   Uint8_t,
  7 |   Uint32_t,
  8 | } from '../../types/internal'
  9 | import {TxOutputDestinationType} from '../../types/internal'
 10 | import type {Version} from '../../types/public'
 11 | import {DatumType} from '../../types/public'
 12 | import {unreachable} from '../../utils/assert'
 13 | import {
 14 |   hex_to_buf,
 15 |   serializeOptionFlag,
 16 |   uint8_to_buf,
 17 |   uint32_to_buf,
 18 |   serializeCoin,
 19 | } from '../../utils/serialize'
 20 | import {getCompatibility} from '../getVersion'
 21 | import {serializeAddressParams} from './addressParams'
 22 | 
 23 | // should be the same as in the Ledger app
 24 | export const MAX_CHUNK_SIZE = 240
 25 | 
 26 | export function serializeTxOutputDestination(
 27 |   destination: ParsedOutputDestination,
 28 |   version: Version,
 29 | ) {
 30 |   const typeEncoding = {
 31 |     [TxOutputDestinationType.THIRD_PARTY]: 1 as Uint8_t,
 32 |     [TxOutputDestinationType.DEVICE_OWNED]: 2 as Uint8_t,
 33 |   }
 34 | 
 35 |   switch (destination.type) {
 36 |     case TxOutputDestinationType.THIRD_PARTY:
 37 |       return Buffer.concat([
 38 |         uint8_to_buf(typeEncoding[destination.type]),
 39 |         uint32_to_buf((destination.addressHex.length / 2) as Uint32_t),
 40 |         hex_to_buf(destination.addressHex),
 41 |       ])
 42 |     case TxOutputDestinationType.DEVICE_OWNED:
 43 |       return Buffer.concat([
 44 |         uint8_to_buf(typeEncoding[destination.type]),
 45 |         serializeAddressParams(destination.addressParams, version),
 46 |       ])
 47 |     default:
 48 |       unreachable(destination)
 49 |   }
 50 | }
 51 | 
 52 | export function serializeTxOutputBasicParams(
 53 |   output: ParsedOutput,
 54 |   version: Version,
 55 | ): Buffer {
 56 |   const serializationFormatBuffer = getCompatibility(version).supportsBabbage
 57 |     ? uint8_to_buf(output.format as Uint8_t)
 58 |     : Buffer.from([])
 59 | 
 60 |   const includeDatumBuffer = getCompatibility(version).supportsAlonzo
 61 |     ? serializeOptionFlag(output.datum != null)
 62 |     : Buffer.from([])
 63 | 
 64 |   const includeScriptBuffer = getCompatibility(version).supportsBabbage
 65 |     ? serializeOptionFlag(output.referenceScriptHex != null)
 66 |     : Buffer.from([])
 67 | 
 68 |   return Buffer.concat([
 69 |     serializationFormatBuffer,
 70 |     serializeTxOutputDestination(output.destination, version),
 71 |     serializeCoin(output.amount),
 72 |     uint32_to_buf(output.tokenBundle.length as Uint32_t),
 73 |     includeDatumBuffer,
 74 |     includeScriptBuffer,
 75 |   ])
 76 | }
 77 | 
 78 | export function serializeTxOutputDatum(
 79 |   datum: ParsedDatum,
 80 |   version: Version,
 81 | ): Buffer {
 82 |   switch (datum.type) {
 83 |     case DatumType.HASH: {
 84 |       // Do not include datum option for legacy version
 85 |       const datumHashBuffer = getCompatibility(version).supportsBabbage
 86 |         ? uint8_to_buf(DatumType.HASH as Uint8_t)
 87 |         : Buffer.concat([])
 88 | 
 89 |       return Buffer.concat([datumHashBuffer, hex_to_buf(datum.datumHashHex)])
 90 |     }
 91 | 
 92 |     case DatumType.INLINE: {
 93 |       const totalDatumSize = datum.datumHex.length / 2
 94 |       let chunkHex: HexString
 95 | 
 96 |       if (totalDatumSize > MAX_CHUNK_SIZE) {
 97 |         chunkHex = datum.datumHex.substring(0, MAX_CHUNK_SIZE * 2) as HexString
 98 |       } else {
 99 |         chunkHex = datum.datumHex
100 |       }
101 |       const chunkSize = chunkHex.length / 2
102 | 
103 |       return Buffer.concat([
104 |         uint8_to_buf(DatumType.INLINE as Uint8_t),
105 |         uint32_to_buf(totalDatumSize as Uint32_t),
106 |         uint32_to_buf(chunkSize as Uint32_t), // first chunk
107 |         hex_to_buf(chunkHex),
108 |       ])
109 |     }
110 | 
111 |     default:
112 |       return unreachable(datum)
113 |   }
114 | }
115 | 
116 | export function serializeTxOutputRefScript(
117 |   referenceScriptHex: HexString,
118 | ): Buffer {
119 |   const totalScriptSize = referenceScriptHex.length / 2
120 |   let chunkHex: HexString
121 | 
122 |   if (totalScriptSize > MAX_CHUNK_SIZE) {
123 |     chunkHex = referenceScriptHex.substring(0, MAX_CHUNK_SIZE * 2) as HexString
124 |   } else {
125 |     chunkHex = referenceScriptHex
126 |   }
127 |   const chunkSize = chunkHex.length / 2
128 | 
129 |   return Buffer.concat([
130 |     uint32_to_buf(totalScriptSize as Uint32_t),
131 |     uint32_to_buf(chunkSize as Uint32_t), // first chunk
132 |     hex_to_buf(chunkHex),
133 |   ])
134 | }
135 | 


--------------------------------------------------------------------------------
/src/interactions/showAddress.ts:
--------------------------------------------------------------------------------
 1 | import type {ParsedAddressParams, Version} from '../types/internal'
 2 | import {INS} from './common/ins'
 3 | import type {Interaction, SendParams} from './common/types'
 4 | import {serializeAddressParams} from './serialization/addressParams'
 5 | import {ensureAddressDerivationSupportedByAppVersion} from './deriveAddress'
 6 | 
 7 | const send = (params: {
 8 |   p1: number
 9 |   p2: number
10 |   data: Buffer
11 |   expectedResponseLength?: number
12 | }): SendParams => ({ins: INS.DERIVE_ADDRESS, ...params})
13 | 
14 | export function* showAddress(
15 |   version: Version,
16 |   addressParams: ParsedAddressParams,
17 | ): Interaction<void> {
18 |   ensureAddressDerivationSupportedByAppVersion(version, addressParams)
19 | 
20 |   const P1_DISPLAY = 0x02
21 |   const P2_UNUSED = 0x00
22 | 
23 |   yield send({
24 |     p1: P1_DISPLAY,
25 |     p2: P2_UNUSED,
26 |     data: serializeAddressParams(addressParams, version),
27 |     expectedResponseLength: 0,
28 |   })
29 | }
30 | 


--------------------------------------------------------------------------------
/src/interactions/signCVote.ts:
--------------------------------------------------------------------------------
 1 | import {DeviceVersionUnsupported} from '../errors'
 2 | import type {ParsedCVote, Uint32_t, Version} from '../types/internal'
 3 | import {ED25519_SIGNATURE_LENGTH} from '../types/internal'
 4 | import type {SignedCIP36VoteData} from '../types/public'
 5 | import {getVersionString} from '../utils'
 6 | import {hex_to_buf, path_to_buf, uint32_to_buf} from '../utils/serialize'
 7 | import {INS} from './common/ins'
 8 | import type {Interaction, SendParams} from './common/types'
 9 | import {getCompatibility} from './getVersion'
10 | 
11 | const send = (params: {
12 |   p1: number
13 |   p2: number
14 |   data: Buffer
15 |   expectedResponseLength?: number
16 | }): SendParams => ({ins: INS.SIGN_CIP36_VOTE, ...params})
17 | 
18 | export function* signCVote(
19 |   version: Version,
20 |   cVote: ParsedCVote,
21 | ): Interaction<SignedCIP36VoteData> {
22 |   if (!getCompatibility(version).supportsCIP36Vote) {
23 |     throw new DeviceVersionUnsupported(
24 |       `CIP36 voting not supported by Ledger app version ${getVersionString(
25 |         version,
26 |       )}.`,
27 |     )
28 |   }
29 | 
30 |   const enum P1 {
31 |     STAGE_INIT = 0x01,
32 |     STAGE_CHUNK = 0x02,
33 |     STAGE_CONFIRM = 0x03,
34 |     STAGE_WITNESS = 0x04,
35 |   }
36 |   const enum P2 {
37 |     UNUSED = 0x00,
38 |   }
39 |   const MAX_VOTECAST_CHUNK_SIZE = 240
40 | 
41 |   const votecastBytes = hex_to_buf(cVote.voteCastDataHex)
42 |   let start = 0
43 |   let end = Math.min(votecastBytes.length, start + MAX_VOTECAST_CHUNK_SIZE)
44 | 
45 |   // INIT
46 |   const initDataBuffer = Buffer.concat([
47 |     uint32_to_buf(votecastBytes.length as Uint32_t),
48 |     votecastBytes.slice(start, end),
49 |   ])
50 |   yield send({
51 |     p1: P1.STAGE_INIT,
52 |     p2: P2.UNUSED,
53 |     data: initDataBuffer,
54 |     expectedResponseLength: 0,
55 |   })
56 |   start = end
57 | 
58 |   // CHUNK
59 |   while (start < votecastBytes.length) {
60 |     end = Math.min(votecastBytes.length, start + MAX_VOTECAST_CHUNK_SIZE)
61 | 
62 |     yield send({
63 |       p1: P1.STAGE_CHUNK,
64 |       p2: P2.UNUSED,
65 |       data: votecastBytes.slice(start, end),
66 |       expectedResponseLength: 0,
67 |     })
68 |     start = end
69 |   }
70 | 
71 |   // CONFIRM
72 |   const VOTECAST_HASH_LENGTH = 32
73 |   const confirmResponse = yield send({
74 |     p1: P1.STAGE_CONFIRM,
75 |     p2: P2.UNUSED,
76 |     data: Buffer.concat([]),
77 |     expectedResponseLength: VOTECAST_HASH_LENGTH,
78 |   })
79 | 
80 |   // WITNESS
81 |   const witnessResponse = yield send({
82 |     p1: P1.STAGE_WITNESS,
83 |     p2: P2.UNUSED,
84 |     data: path_to_buf(cVote.witnessPath),
85 |     expectedResponseLength: ED25519_SIGNATURE_LENGTH,
86 |   })
87 | 
88 |   return {
89 |     dataHashHex: confirmResponse.toString('hex'),
90 |     witnessPath: cVote.witnessPath,
91 |     witnessSignatureHex: witnessResponse.toString('hex'),
92 |   }
93 | }
94 | 


--------------------------------------------------------------------------------
/src/interactions/signMessage.ts:
--------------------------------------------------------------------------------
  1 | import {buf_to_uint32, hex_to_buf, uint32_to_buf} from '../utils/serialize'
  2 | import {DeviceVersionUnsupported, InvalidDataReason} from '../errors'
  3 | import type {ParsedMessageData} from '../types/internal'
  4 | import {
  5 |   ED25519_SIGNATURE_LENGTH,
  6 |   PUBLIC_KEY_LENGTH,
  7 |   Uint32_t,
  8 | } from '../types/internal'
  9 | import type {SignedMessageData, Version} from '../types/public'
 10 | import {getVersionString} from '../utils'
 11 | import {INS} from './common/ins'
 12 | import type {Interaction, SendParams} from './common/types'
 13 | import {getCompatibility} from './getVersion'
 14 | import {serializeMessageDataInit} from './serialization/messageData'
 15 | import {validate} from '../utils/parse'
 16 | 
 17 | const send = (params: {
 18 |   p1: number
 19 |   p2: number
 20 |   data: Buffer
 21 |   expectedResponseLength?: number
 22 | }): SendParams => ({ins: INS.SIGN_MESSAGE, ...params})
 23 | 
 24 | export function* signMessage(
 25 |   version: Version,
 26 |   msgData: ParsedMessageData,
 27 | ): Interaction<SignedMessageData> {
 28 |   if (!getCompatibility(version).supportsMessageSigning) {
 29 |     throw new DeviceVersionUnsupported(
 30 |       `CIP-8 message signing not supported by Ledger app version ${getVersionString(
 31 |         version,
 32 |       )}.`,
 33 |     )
 34 |   }
 35 | 
 36 |   const enum P1 {
 37 |     STAGE_INIT = 0x01,
 38 |     STAGE_CHUNK = 0x02,
 39 |     STAGE_CONFIRM = 0x03,
 40 |   }
 41 |   const enum P2 {
 42 |     UNUSED = 0x00,
 43 |   }
 44 | 
 45 |   // INIT
 46 |   yield send({
 47 |     p1: P1.STAGE_INIT,
 48 |     p2: P2.UNUSED,
 49 |     data: serializeMessageDataInit(version, msgData),
 50 |     expectedResponseLength: 0,
 51 |   })
 52 | 
 53 |   // CHUNK
 54 |   const MAX_CIP8_MSG_FIRST_CHUNK_ASCII_SIZE = 198
 55 |   const MAX_CIP8_MSG_FIRST_CHUNK_HEX_SIZE = 99
 56 |   const MAX_CIP8_MSG_HIDDEN_CHUNK_SIZE = 250
 57 | 
 58 |   const msgBytes = hex_to_buf(msgData.messageHex)
 59 | 
 60 |   const getChunkData = (start: number, end: number) => {
 61 |     const chunk = msgBytes.slice(start, end)
 62 |     return Buffer.concat([uint32_to_buf(chunk.length as Uint32_t), chunk])
 63 |   }
 64 | 
 65 |   const firstChunkSize = msgData.isAscii
 66 |     ? MAX_CIP8_MSG_FIRST_CHUNK_ASCII_SIZE
 67 |     : MAX_CIP8_MSG_FIRST_CHUNK_HEX_SIZE
 68 | 
 69 |   let start = 0
 70 |   let end = Math.min(msgBytes.length, firstChunkSize)
 71 | 
 72 |   yield send({
 73 |     p1: P1.STAGE_CHUNK,
 74 |     p2: P2.UNUSED,
 75 |     data: getChunkData(start, end),
 76 |     expectedResponseLength: 0,
 77 |   })
 78 |   start = end
 79 | 
 80 |   if (start < msgBytes.length) {
 81 |     // non-hashed messages must be processed in a single APDU
 82 |     validate(
 83 |       msgData.hashPayload,
 84 |       InvalidDataReason.MESSAGE_DATA_LONG_NON_HASHED_MSG,
 85 |     )
 86 |   }
 87 |   while (start < msgBytes.length) {
 88 |     end = Math.min(msgBytes.length, start + MAX_CIP8_MSG_HIDDEN_CHUNK_SIZE)
 89 | 
 90 |     yield send({
 91 |       p1: P1.STAGE_CHUNK,
 92 |       p2: P2.UNUSED,
 93 |       data: getChunkData(start, end),
 94 |       expectedResponseLength: 0,
 95 |     })
 96 | 
 97 |     start = end
 98 |   }
 99 | 
100 |   // CONFIRM
101 |   const MAX_ADDRESS_SIZE = 128
102 | 
103 |   const confirmResponse = yield send({
104 |     p1: P1.STAGE_CONFIRM,
105 |     p2: P2.UNUSED,
106 |     data: Buffer.concat([]),
107 |     expectedResponseLength:
108 |       ED25519_SIGNATURE_LENGTH + PUBLIC_KEY_LENGTH + 4 + MAX_ADDRESS_SIZE,
109 |   })
110 | 
111 |   let s = 0
112 |   const signatureHex = confirmResponse
113 |     .slice(s, s + ED25519_SIGNATURE_LENGTH)
114 |     .toString('hex')
115 |   s += ED25519_SIGNATURE_LENGTH
116 | 
117 |   const signingPublicKeyHex = confirmResponse
118 |     .slice(s, s + PUBLIC_KEY_LENGTH)
119 |     .toString('hex')
120 |   s += PUBLIC_KEY_LENGTH
121 | 
122 |   const addressFieldSizeBuf = confirmResponse.slice(s, s + 4)
123 |   s += 4
124 |   const addressFieldSize = buf_to_uint32(addressFieldSizeBuf)
125 |   const addressFieldHex = confirmResponse
126 |     .slice(s, s + addressFieldSize)
127 |     .toString('hex')
128 | 
129 |   return {
130 |     signatureHex,
131 |     signingPublicKeyHex,
132 |     addressFieldHex,
133 |   }
134 | }
135 | 


--------------------------------------------------------------------------------
/src/interactions/signOperationalCertificate.ts:
--------------------------------------------------------------------------------
 1 | import {DeviceVersionUnsupported} from '../errors'
 2 | import type {ParsedOperationalCertificate, Version} from '../types/internal'
 3 | import {ED25519_SIGNATURE_LENGTH} from '../types/internal'
 4 | import type {OperationalCertificateSignature} from '../types/public'
 5 | import {getVersionString} from '../utils'
 6 | import {INS} from './common/ins'
 7 | import type {Interaction, SendParams} from './common/types'
 8 | import {getCompatibility} from './getVersion'
 9 | import {serializeOperationalCertificate} from './serialization/operationalCertificate'
10 | 
11 | const send = (params: {
12 |   p1: number
13 |   p2: number
14 |   data: Buffer
15 |   expectedResponseLength?: number
16 | }): SendParams => ({ins: INS.SIGN_OPERATIONAL_CERTIFICATE, ...params})
17 | 
18 | export function* signOperationalCertificate(
19 |   version: Version,
20 |   operationalCertificate: ParsedOperationalCertificate,
21 | ): Interaction<OperationalCertificateSignature> {
22 |   if (!getCompatibility(version).supportsPoolRegistrationAsOperator) {
23 |     throw new DeviceVersionUnsupported(
24 |       `Operational certificate signing not supported by Ledger app version ${getVersionString(
25 |         version,
26 |       )}.`,
27 |     )
28 |   }
29 | 
30 |   const P1_UNUSED = 0x00
31 |   const P2_UNUSED = 0x00
32 | 
33 |   const response = yield send({
34 |     p1: P1_UNUSED,
35 |     p2: P2_UNUSED,
36 |     data: serializeOperationalCertificate(operationalCertificate),
37 |     expectedResponseLength: ED25519_SIGNATURE_LENGTH,
38 |   })
39 | 
40 |   return {
41 |     signatureHex: response.toString('hex'),
42 |   }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/parsing/cVote.ts:
--------------------------------------------------------------------------------
 1 | import {InvalidDataReason} from '../errors/invalidDataReason'
 2 | import type {ParsedCVote} from '../types/internal'
 3 | import type {CIP36Vote} from '../types/public'
 4 | import {parseBIP32Path, parseHexString, validate} from '../utils/parse'
 5 | 
 6 | export function parseCVote(cVote: CIP36Vote): ParsedCVote {
 7 |   const voteCastDataHex = parseHexString(
 8 |     cVote.voteCastDataHex,
 9 |     InvalidDataReason.CVOTE_INVALID_VOTECAST_DATA,
10 |   )
11 | 
12 |   // we don't know what is the true minimal length
13 |   // this just assures that the Cardano ledger app will be happy
14 |   const MIN_VOTECAST_LENGTH = 32 + 1 + 1 + 1
15 |   validate(
16 |     voteCastDataHex.length >= 2 * MIN_VOTECAST_LENGTH,
17 |     InvalidDataReason.CVOTE_INVALID_VOTECAST_DATA,
18 |   )
19 | 
20 |   const witnessPath = parseBIP32Path(
21 |     cVote.witnessPath,
22 |     InvalidDataReason.CVOTE_INVALID_WITNESS,
23 |   )
24 | 
25 |   return {
26 |     voteCastDataHex,
27 |     witnessPath,
28 |   }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/parsing/certificate.ts:
--------------------------------------------------------------------------------
  1 | import {unreachable} from '../utils/assert'
  2 | import {InvalidData} from '../errors'
  3 | import {InvalidDataReason} from '../errors/invalidDataReason'
  4 | import {
  5 |   DRepType,
  6 |   ParsedDRep,
  7 |   SCRIPT_HASH_LENGTH,
  8 |   CertificateType,
  9 |   KEY_HASH_LENGTH,
 10 |   Uint64_str,
 11 | } from '../types/internal'
 12 | import type {ParsedCertificate} from '../types/internal'
 13 | import {bigint_like, DRepParams, DRepParamsType} from '../types/public'
 14 | import type {Certificate} from '../types/public'
 15 | import {
 16 |   parseBIP32Path,
 17 |   parseHexStringOfLength,
 18 |   parseCredential,
 19 |   parseUint64_str,
 20 |   parseAnchor,
 21 |   parseCoin,
 22 | } from '../utils/parse'
 23 | import {parsePoolParams} from './poolRegistration'
 24 | 
 25 | function parseDRep(dRep: DRepParams, errMsg: InvalidDataReason): ParsedDRep {
 26 |   switch (dRep.type) {
 27 |     case DRepParamsType.KEY_PATH:
 28 |       return {
 29 |         type: DRepType.KEY_PATH,
 30 |         path: parseBIP32Path(dRep.keyPath, errMsg),
 31 |       }
 32 |     case DRepParamsType.KEY_HASH:
 33 |       return {
 34 |         type: DRepType.KEY_HASH,
 35 |         keyHashHex: parseHexStringOfLength(
 36 |           dRep.keyHashHex,
 37 |           KEY_HASH_LENGTH,
 38 |           errMsg,
 39 |         ),
 40 |       }
 41 |     case DRepParamsType.SCRIPT_HASH:
 42 |       return {
 43 |         type: DRepType.SCRIPT_HASH,
 44 |         scriptHashHex: parseHexStringOfLength(
 45 |           dRep.scriptHashHex,
 46 |           SCRIPT_HASH_LENGTH,
 47 |           errMsg,
 48 |         ),
 49 |       }
 50 |     case DRepParamsType.ABSTAIN:
 51 |       return {
 52 |         type: DRepType.ABSTAIN,
 53 |       }
 54 |     case DRepParamsType.NO_CONFIDENCE:
 55 |       return {
 56 |         type: DRepType.NO_CONFIDENCE,
 57 |       }
 58 |     default:
 59 |       unreachable(dRep)
 60 |   }
 61 | }
 62 | 
 63 | function parseDeposit(deposit: bigint_like): Uint64_str {
 64 |   return parseCoin(deposit, InvalidDataReason.CERTIFICATE_INVALID_DEPOSIT)
 65 | }
 66 | 
 67 | export function parseCertificate(cert: Certificate): ParsedCertificate {
 68 |   switch (cert.type) {
 69 |     case CertificateType.STAKE_REGISTRATION:
 70 |     case CertificateType.STAKE_DEREGISTRATION: {
 71 |       return {
 72 |         type: cert.type,
 73 |         stakeCredential: parseCredential(
 74 |           cert.params.stakeCredential,
 75 |           InvalidDataReason.CERTIFICATE_INVALID_STAKE_CREDENTIAL,
 76 |         ),
 77 |       }
 78 |     }
 79 |     case CertificateType.STAKE_REGISTRATION_CONWAY:
 80 |     case CertificateType.STAKE_DEREGISTRATION_CONWAY: {
 81 |       return {
 82 |         type: cert.type,
 83 |         stakeCredential: parseCredential(
 84 |           cert.params.stakeCredential,
 85 |           InvalidDataReason.CERTIFICATE_INVALID_STAKE_CREDENTIAL,
 86 |         ),
 87 |         deposit: parseDeposit(cert.params.deposit),
 88 |       }
 89 |     }
 90 |     case CertificateType.STAKE_DELEGATION: {
 91 |       return {
 92 |         type: cert.type,
 93 |         stakeCredential: parseCredential(
 94 |           cert.params.stakeCredential,
 95 |           InvalidDataReason.CERTIFICATE_INVALID_STAKE_CREDENTIAL,
 96 |         ),
 97 |         poolKeyHashHex: parseHexStringOfLength(
 98 |           cert.params.poolKeyHashHex,
 99 |           KEY_HASH_LENGTH,
100 |           InvalidDataReason.CERTIFICATE_INVALID_POOL_KEY_HASH,
101 |         ),
102 |       }
103 |     }
104 |     case CertificateType.VOTE_DELEGATION: {
105 |       return {
106 |         type: cert.type,
107 |         stakeCredential: parseCredential(
108 |           cert.params.stakeCredential,
109 |           InvalidDataReason.CERTIFICATE_INVALID_STAKE_CREDENTIAL,
110 |         ),
111 |         dRep: parseDRep(
112 |           cert.params.dRep,
113 |           InvalidDataReason.CERTIFICATE_INVALID_DREP,
114 |         ),
115 |       }
116 |     }
117 |     case CertificateType.AUTHORIZE_COMMITTEE_HOT: {
118 |       return {
119 |         type: cert.type,
120 |         coldCredential: parseCredential(
121 |           cert.params.coldCredential,
122 |           InvalidDataReason.CERTIFICATE_INVALID_COMMITTEE_CREDENTIAL,
123 |         ),
124 |         hotCredential: parseCredential(
125 |           cert.params.hotCredential,
126 |           InvalidDataReason.CERTIFICATE_INVALID_COMMITTEE_CREDENTIAL,
127 |         ),
128 |       }
129 |     }
130 |     case CertificateType.RESIGN_COMMITTEE_COLD: {
131 |       return {
132 |         type: cert.type,
133 |         coldCredential: parseCredential(
134 |           cert.params.coldCredential,
135 |           InvalidDataReason.CERTIFICATE_INVALID_COMMITTEE_CREDENTIAL,
136 |         ),
137 |         anchor:
138 |           cert.params.anchor == null ? null : parseAnchor(cert.params.anchor),
139 |       }
140 |     }
141 |     case CertificateType.DREP_REGISTRATION: {
142 |       return {
143 |         type: cert.type,
144 |         dRepCredential: parseCredential(
145 |           cert.params.dRepCredential,
146 |           InvalidDataReason.CERTIFICATE_INVALID_DREP_CREDENTIAL,
147 |         ),
148 |         deposit: parseDeposit(cert.params.deposit),
149 |         anchor:
150 |           cert.params.anchor == null ? null : parseAnchor(cert.params.anchor),
151 |       }
152 |     }
153 |     case CertificateType.DREP_DEREGISTRATION: {
154 |       return {
155 |         type: cert.type,
156 |         dRepCredential: parseCredential(
157 |           cert.params.dRepCredential,
158 |           InvalidDataReason.CERTIFICATE_INVALID_DREP_CREDENTIAL,
159 |         ),
160 |         deposit: parseDeposit(cert.params.deposit),
161 |       }
162 |     }
163 |     case CertificateType.DREP_UPDATE: {
164 |       return {
165 |         type: cert.type,
166 |         dRepCredential: parseCredential(
167 |           cert.params.dRepCredential,
168 |           InvalidDataReason.CERTIFICATE_INVALID_DREP_CREDENTIAL,
169 |         ),
170 |         anchor:
171 |           cert.params.anchor == null ? null : parseAnchor(cert.params.anchor),
172 |       }
173 |     }
174 |     case CertificateType.STAKE_POOL_REGISTRATION: {
175 |       return {
176 |         type: cert.type,
177 |         pool: parsePoolParams(cert.params),
178 |       }
179 |     }
180 |     case CertificateType.STAKE_POOL_RETIREMENT: {
181 |       return {
182 |         type: cert.type,
183 |         path: parseBIP32Path(
184 |           cert.params.poolKeyPath,
185 |           InvalidDataReason.CERTIFICATE_INVALID_PATH,
186 |         ),
187 |         retirementEpoch: parseUint64_str(
188 |           cert.params.retirementEpoch,
189 |           {},
190 |           InvalidDataReason.POOL_RETIREMENT_INVALID_RETIREMENT_EPOCH,
191 |         ),
192 |       }
193 |     }
194 | 
195 |     default:
196 |       throw new InvalidData(InvalidDataReason.CERTIFICATE_INVALID_TYPE)
197 |   }
198 | }
199 | 


--------------------------------------------------------------------------------
/src/parsing/constants.ts:
--------------------------------------------------------------------------------
1 | export const MAX_LOVELACE_SUPPLY_STR = '45 000 000 000.000000'.replace(
2 |   /[ .]/,
3 |   '',
4 | )
5 | export const POOL_REGISTRATION_OWNERS_MAX = 1000
6 | export const POOL_REGISTRATION_RELAYS_MAX = 1000
7 | export const ASSET_GROUPS_MAX = 1000
8 | export const TOKENS_IN_GROUP_MAX = 1000
9 | 


--------------------------------------------------------------------------------
/src/parsing/messageData.ts:
--------------------------------------------------------------------------------
 1 | import {unreachable} from '../utils/assert'
 2 | import {InvalidDataReason} from '../errors/invalidDataReason'
 3 | import type {ParsedMessageData} from '../types/internal'
 4 | import type {MessageData} from '../types/public'
 5 | import {MessageAddressFieldType} from '../types/public'
 6 | import {parseBIP32Path, parseHexString} from '../utils/parse'
 7 | import {parseAddress} from './address'
 8 | 
 9 | // check if a non-null-terminated buffer contains printable ASCII between 32 and 126 (inclusive)
10 | // copied from Ledger app
11 | function isPrintableAscii(buffer: Buffer): boolean {
12 |   for (let i = 0; i < buffer.length; i++) {
13 |     if (buffer[i] > 126) return false
14 |     if (buffer[i] < 32) return false
15 |   }
16 | 
17 |   return true
18 | }
19 | 
20 | // check if the string can be unambiguously displayed to the user
21 | // copied from Ledger app
22 | function isAscii(msg: string): boolean {
23 |   const buffer = Buffer.from(msg, 'hex')
24 | 
25 |   // must not be empty
26 |   if (buffer.length === 0) return false
27 | 
28 |   // no non-printable characters except spaces
29 |   if (!isPrintableAscii(buffer)) return false
30 | 
31 |   const space = ' '.charCodeAt(0)
32 | 
33 |   // no leading spaces
34 |   if (buffer[0] === space) return false
35 | 
36 |   // no trailing spaces
37 |   if (buffer[buffer.length - 1] === space) return false
38 | 
39 |   // only single spaces
40 |   for (let i = 0; i + 1 < buffer.length; i++) {
41 |     if (buffer[i] === space && buffer[i + 1] === space) return false
42 |   }
43 | 
44 |   return true
45 | }
46 | 
47 | export function parseMessageData(data: MessageData): ParsedMessageData {
48 |   const preferHexDisplay = data.preferHexDisplay || false
49 |   const common = {
50 |     signingPath: parseBIP32Path(
51 |       data.signingPath,
52 |       InvalidDataReason.MESSAGE_DATA_INVALID_WITNESS_PATH,
53 |     ),
54 |     isAscii: isAscii(data.messageHex) && !preferHexDisplay,
55 |     hashPayload: data.hashPayload,
56 |     messageHex: parseHexString(
57 |       data.messageHex,
58 |       InvalidDataReason.MESSAGE_DATA_INVALID_MESSAGE_HEX,
59 |     ),
60 |   }
61 | 
62 |   switch (data.addressFieldType) {
63 |     case MessageAddressFieldType.ADDRESS:
64 |       return {
65 |         ...common,
66 |         addressFieldType: MessageAddressFieldType.ADDRESS,
67 |         address: parseAddress(data.network, data.address),
68 |       }
69 |     case MessageAddressFieldType.KEY_HASH:
70 |       return {
71 |         ...common,
72 |         addressFieldType: MessageAddressFieldType.KEY_HASH,
73 |       }
74 |     default:
75 |       unreachable(data)
76 |   }
77 | }
78 | 


--------------------------------------------------------------------------------
/src/parsing/nativeScript.ts:
--------------------------------------------------------------------------------
  1 | import {InvalidData, InvalidDataReason} from '../errors'
  2 | import type {ParsedNativeScript} from '../types/internal'
  3 | import {KEY_HASH_LENGTH} from '../types/internal'
  4 | import type {bigint_like, BIP32Path, NativeScript} from '../types/public'
  5 | import {NativeScriptHashDisplayFormat, NativeScriptType} from '../types/public'
  6 | import {
  7 |   isArray,
  8 |   parseBIP32Path,
  9 |   parseHexStringOfLength,
 10 |   parseUint32_t,
 11 |   parseUint64_str,
 12 |   validate,
 13 | } from '../utils/parse'
 14 | 
 15 | export function parseNativeScript(script: NativeScript): ParsedNativeScript {
 16 |   // union of all param fields
 17 |   const params = script.params as {
 18 |     path?: BIP32Path
 19 |     keyHashHex?: string
 20 |     requiredCount?: number
 21 |     slot?: bigint_like
 22 |     scripts?: NativeScript[]
 23 |   }
 24 | 
 25 |   switch (script.type) {
 26 |     case NativeScriptType.PUBKEY_DEVICE_OWNED: {
 27 |       validate(
 28 |         params.keyHashHex == null,
 29 |         InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_INVALID_DATA,
 30 |       )
 31 |       validate(
 32 |         params.requiredCount == null,
 33 |         InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_INVALID_DATA,
 34 |       )
 35 |       validate(
 36 |         params.slot == null,
 37 |         InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_INVALID_DATA,
 38 |       )
 39 |       validate(
 40 |         params.scripts == null,
 41 |         InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_INVALID_DATA,
 42 |       )
 43 | 
 44 |       return {
 45 |         type: script.type,
 46 |         params: {
 47 |           path: parseBIP32Path(
 48 |             params.path,
 49 |             InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_INVALID_KEY_PATH,
 50 |           ),
 51 |         },
 52 |       }
 53 |     }
 54 |     case NativeScriptType.PUBKEY_THIRD_PARTY: {
 55 |       validate(
 56 |         params.path == null,
 57 |         InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_INVALID_DATA,
 58 |       )
 59 |       validate(
 60 |         params.requiredCount == null,
 61 |         InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_INVALID_DATA,
 62 |       )
 63 |       validate(
 64 |         params.slot == null,
 65 |         InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_INVALID_DATA,
 66 |       )
 67 |       validate(
 68 |         params.scripts == null,
 69 |         InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_INVALID_DATA,
 70 |       )
 71 | 
 72 |       return {
 73 |         type: script.type,
 74 |         params: {
 75 |           keyHashHex: parseHexStringOfLength(
 76 |             params.keyHashHex,
 77 |             KEY_HASH_LENGTH,
 78 |             InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_INVALID_KEY_HASH,
 79 |           ),
 80 |         },
 81 |       }
 82 |     }
 83 |     case NativeScriptType.ALL:
 84 |     case NativeScriptType.ANY: {
 85 |       validate(
 86 |         params.path == null,
 87 |         InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_INVALID_DATA,
 88 |       )
 89 |       validate(
 90 |         params.keyHashHex == null,
 91 |         InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_INVALID_DATA,
 92 |       )
 93 |       validate(
 94 |         params.requiredCount == null,
 95 |         InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_INVALID_DATA,
 96 |       )
 97 |       validate(
 98 |         params.slot == null,
 99 |         InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_INVALID_DATA,
100 |       )
101 |       validate(
102 |         isArray(params.scripts),
103 |         InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_SCRIPTS_NOT_AN_ARRAY,
104 |       )
105 | 
106 |       return {
107 |         type: script.type,
108 |         params: {
109 |           scripts: params.scripts.map(parseNativeScript),
110 |         },
111 |       }
112 |     }
113 |     case NativeScriptType.N_OF_K: {
114 |       validate(
115 |         params.path == null,
116 |         InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_INVALID_DATA,
117 |       )
118 |       validate(
119 |         params.keyHashHex == null,
120 |         InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_INVALID_DATA,
121 |       )
122 |       validate(
123 |         params.slot == null,
124 |         InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_INVALID_DATA,
125 |       )
126 |       validate(
127 |         isArray(params.scripts),
128 |         InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_SCRIPTS_NOT_AN_ARRAY,
129 |       )
130 | 
131 |       const requiredCount = parseUint32_t(
132 |         params.requiredCount,
133 |         InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_INVALID_REQUIRED_COUNT,
134 |       )
135 |       validate(
136 |         requiredCount <= params.scripts.length,
137 |         InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_REQUIRED_COUNT_HIGHER_THAN_NUMBER_OF_SCRIPTS,
138 |       )
139 | 
140 |       return {
141 |         type: script.type,
142 |         params: {
143 |           requiredCount,
144 |           scripts: params.scripts.map(parseNativeScript),
145 |         },
146 |       }
147 |     }
148 |     case NativeScriptType.INVALID_BEFORE:
149 |     case NativeScriptType.INVALID_HEREAFTER: {
150 |       validate(
151 |         params.path == null,
152 |         InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_INVALID_DATA,
153 |       )
154 |       validate(
155 |         params.keyHashHex == null,
156 |         InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_INVALID_DATA,
157 |       )
158 |       validate(
159 |         params.requiredCount == null,
160 |         InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_INVALID_DATA,
161 |       )
162 |       validate(
163 |         params.scripts == null,
164 |         InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_INVALID_DATA,
165 |       )
166 | 
167 |       return {
168 |         type: script.type,
169 |         params: {
170 |           slot: parseUint64_str(
171 |             params.slot,
172 |             {},
173 |             InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_INVALID_TOKEN_LOCKING_SLOT,
174 |           ),
175 |         },
176 |       }
177 |     }
178 |     default:
179 |       throw new InvalidData(
180 |         InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_UNKNOWN_TYPE,
181 |       )
182 |   }
183 | }
184 | 
185 | export function parseNativeScriptHashDisplayFormat(
186 |   displayFormat: NativeScriptHashDisplayFormat,
187 | ): NativeScriptHashDisplayFormat {
188 |   // Validate whether the passed format is present in the enum
189 |   switch (displayFormat) {
190 |     case NativeScriptHashDisplayFormat.BECH32:
191 |     case NativeScriptHashDisplayFormat.POLICY_ID:
192 |       break
193 |     default:
194 |       throw new InvalidData(
195 |         InvalidDataReason.DERIVE_NATIVE_SCRIPT_HASH_INVALID_DISPLAY_FORMAT,
196 |       )
197 |   }
198 | 
199 |   return displayFormat
200 | }
201 | 


--------------------------------------------------------------------------------
/src/parsing/network.ts:
--------------------------------------------------------------------------------
 1 | import {InvalidDataReason} from '../errors/invalidDataReason'
 2 | import type {ParsedNetwork} from '../types/internal'
 3 | import type {Network} from '../types/public'
 4 | import {validate, parseUint8_t, parseUint32_t} from '../utils/parse'
 5 | 
 6 | export function parseNetwork(network: Network): ParsedNetwork {
 7 |   const parsed = {
 8 |     protocolMagic: parseUint32_t(
 9 |       network.protocolMagic,
10 |       InvalidDataReason.NETWORK_INVALID_PROTOCOL_MAGIC,
11 |     ),
12 |     networkId: parseUint8_t(
13 |       network.networkId,
14 |       InvalidDataReason.NETWORK_INVALID_NETWORK_ID,
15 |     ),
16 |   }
17 |   validate(
18 |     parsed.networkId <= 0b00001111,
19 |     InvalidDataReason.NETWORK_INVALID_NETWORK_ID,
20 |   )
21 |   return parsed
22 | }
23 | 


--------------------------------------------------------------------------------
/src/parsing/operationalCertificate.ts:
--------------------------------------------------------------------------------
 1 | import {InvalidDataReason} from '../errors/invalidDataReason'
 2 | import type {ParsedOperationalCertificate} from '../types/internal'
 3 | import {KES_PUBLIC_KEY_LENGTH} from '../types/internal'
 4 | import type {OperationalCertificate} from '../types/public'
 5 | import {
 6 |   parseBIP32Path,
 7 |   parseHexStringOfLength,
 8 |   parseUint64_str,
 9 | } from '../utils/parse'
10 | 
11 | export function parseOperationalCertificate(
12 |   operationalCertificate: OperationalCertificate,
13 | ): ParsedOperationalCertificate {
14 |   return {
15 |     kesPublicKeyHex: parseHexStringOfLength(
16 |       operationalCertificate.kesPublicKeyHex,
17 |       KES_PUBLIC_KEY_LENGTH,
18 |       InvalidDataReason.OPERATIONAL_CERTIFICATE_INVALID_KES_KEY,
19 |     ),
20 |     kesPeriod: parseUint64_str(
21 |       operationalCertificate.kesPeriod,
22 |       {},
23 |       InvalidDataReason.OPERATIONAL_CERTIFICATE_INVALID_KES_PERIOD,
24 |     ),
25 |     issueCounter: parseUint64_str(
26 |       operationalCertificate.issueCounter,
27 |       {},
28 |       InvalidDataReason.OPERATIONAL_CERTIFICATE_INVALID_ISSUE_COUNTER,
29 |     ),
30 |     coldKeyPath: parseBIP32Path(
31 |       operationalCertificate.coldKeyPath,
32 |       InvalidDataReason.OPERATIONAL_CERTIFICATE_INVALID_COLD_KEY_PATH,
33 |     ),
34 |   }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/parsing/output.ts:
--------------------------------------------------------------------------------
  1 | import {InvalidData} from '../errors'
  2 | import {InvalidDataReason} from '../errors/invalidDataReason'
  3 | import type {
  4 |   ParsedAssetGroup,
  5 |   ParsedDatum,
  6 |   ParsedOutput,
  7 |   ParsedOutputDestination,
  8 |   ParsedToken,
  9 | } from '../types/internal'
 10 | import {
 11 |   ASSET_NAME_LENGTH_MAX,
 12 |   DATUM_HASH_LENGTH,
 13 |   SpendingDataSourceType,
 14 |   TOKEN_POLICY_LENGTH,
 15 | } from '../types/internal'
 16 | import type {
 17 |   AssetGroup,
 18 |   Network,
 19 |   Token,
 20 |   TxOutput,
 21 |   TxOutputDestination,
 22 | } from '../types/public'
 23 | import {
 24 |   DatumType,
 25 |   TxOutputDestinationType,
 26 |   TxOutputFormat,
 27 | } from '../types/public'
 28 | import {
 29 |   isArray,
 30 |   parseCoin,
 31 |   parseHexString,
 32 |   parseHexStringOfLength,
 33 |   parseUint64_str,
 34 |   validate,
 35 | } from '../utils/parse'
 36 | import {parseAddress} from './address'
 37 | import {ASSET_GROUPS_MAX, TOKENS_IN_GROUP_MAX} from './constants'
 38 | 
 39 | type ParseTokenAmountFn<T> = (
 40 |   val: unknown,
 41 |   constraints: {min?: string; max?: string},
 42 |   errMsg: InvalidDataReason,
 43 | ) => T
 44 | 
 45 | function parseToken<T>(
 46 |   token: Token,
 47 |   parseTokenAmountFn: ParseTokenAmountFn<T>,
 48 | ): ParsedToken<T> {
 49 |   const assetNameHex = parseHexString(
 50 |     token.assetNameHex,
 51 |     InvalidDataReason.MULTIASSET_INVALID_ASSET_NAME,
 52 |   )
 53 |   validate(
 54 |     token.assetNameHex.length <= ASSET_NAME_LENGTH_MAX * 2,
 55 |     InvalidDataReason.MULTIASSET_INVALID_ASSET_NAME,
 56 |   )
 57 | 
 58 |   const amount = parseTokenAmountFn(
 59 |     token.amount,
 60 |     {},
 61 |     InvalidDataReason.MULTIASSET_INVALID_TOKEN_AMOUNT,
 62 |   )
 63 |   return {
 64 |     assetNameHex,
 65 |     amount,
 66 |   }
 67 | }
 68 | 
 69 | function parseAssetGroup<T>(
 70 |   assetGroup: AssetGroup,
 71 |   parseTokenAmountFn: ParseTokenAmountFn<T>,
 72 | ): ParsedAssetGroup<T> {
 73 |   validate(
 74 |     isArray(assetGroup.tokens),
 75 |     InvalidDataReason.MULTIASSET_INVALID_ASSET_GROUP_NOT_ARRAY,
 76 |   )
 77 |   validate(
 78 |     assetGroup.tokens.length <= TOKENS_IN_GROUP_MAX,
 79 |     InvalidDataReason.MULTIASSET_INVALID_ASSET_GROUP_TOO_LARGE,
 80 |   )
 81 |   validate(
 82 |     assetGroup.tokens.length > 0,
 83 |     InvalidDataReason.MULTIASSET_INVALID_ASSET_GROUP_EMPTY,
 84 |   )
 85 | 
 86 |   const parsedAssetGroup = {
 87 |     policyIdHex: parseHexStringOfLength(
 88 |       assetGroup.policyIdHex,
 89 |       TOKEN_POLICY_LENGTH,
 90 |       InvalidDataReason.MULTIASSET_INVALID_POLICY_NAME,
 91 |     ),
 92 |     tokens: assetGroup.tokens.map((t) => parseToken(t, parseTokenAmountFn)),
 93 |   }
 94 | 
 95 |   const assetNamesHex = parsedAssetGroup.tokens.map((t) => t.assetNameHex)
 96 |   validate(
 97 |     assetNamesHex.length === new Set(assetNamesHex).size,
 98 |     InvalidDataReason.MULTIASSET_INVALID_ASSET_GROUP_NOT_UNIQUE,
 99 |   )
100 | 
101 |   const sortedAssetNames = [...assetNamesHex].sort((n1, n2) => {
102 |     if (n1.length === n2.length) return n1.localeCompare(n2)
103 |     else return n1.length - n2.length
104 |   })
105 |   validate(
106 |     JSON.stringify(assetNamesHex) === JSON.stringify(sortedAssetNames),
107 |     InvalidDataReason.MULTIASSET_INVALID_ASSET_GROUP_ORDERING,
108 |   )
109 | 
110 |   return parsedAssetGroup
111 | }
112 | 
113 | export function parseTokenBundle<T>(
114 |   tokenBundle: AssetGroup[],
115 |   emptyTokenBundleAllowed: boolean,
116 |   parseTokenAmountFn: ParseTokenAmountFn<T>,
117 | ): ParsedAssetGroup<T>[] {
118 |   validate(
119 |     isArray(tokenBundle),
120 |     InvalidDataReason.MULTIASSET_INVALID_TOKEN_BUNDLE_NOT_ARRAY,
121 |   )
122 |   validate(
123 |     tokenBundle.length <= ASSET_GROUPS_MAX,
124 |     InvalidDataReason.MULTIASSET_INVALID_TOKEN_BUNDLE_TOO_LARGE,
125 |   )
126 |   validate(
127 |     emptyTokenBundleAllowed || tokenBundle.length > 0,
128 |     InvalidDataReason.MULTIASSET_INVALID_TOKEN_BUNDLE_EMPTY,
129 |   )
130 |   const parsedTokenBundle = tokenBundle.map((ag) =>
131 |     parseAssetGroup(ag, parseTokenAmountFn),
132 |   )
133 | 
134 |   const policyIds = parsedTokenBundle.map((ag) => ag.policyIdHex)
135 |   validate(
136 |     policyIds.length === new Set(policyIds).size,
137 |     InvalidDataReason.MULTIASSET_INVALID_TOKEN_BUNDLE_NOT_UNIQUE,
138 |   )
139 | 
140 |   const sortedPolicyIds = [...policyIds].sort()
141 |   validate(
142 |     JSON.stringify(policyIds) === JSON.stringify(sortedPolicyIds),
143 |     InvalidDataReason.MULTIASSET_INVALID_TOKEN_BUNDLE_ORDERING,
144 |   )
145 | 
146 |   return parsedTokenBundle
147 | }
148 | 
149 | function parseDatumHash(datumHashHex: string): ParsedDatum | null {
150 |   return {
151 |     type: DatumType.HASH,
152 |     datumHashHex: parseHexStringOfLength(
153 |       datumHashHex,
154 |       DATUM_HASH_LENGTH,
155 |       InvalidDataReason.OUTPUT_INVALID_DATUM_HASH,
156 |     ),
157 |   }
158 | }
159 | 
160 | function parseDatum(output: TxOutput): ParsedDatum | null {
161 |   if (output.format === TxOutputFormat.MAP_BABBAGE) {
162 |     switch (output.datum?.type) {
163 |       case DatumType.HASH:
164 |         return parseDatumHash(output.datum?.datumHashHex)
165 | 
166 |       case DatumType.INLINE:
167 |         return {
168 |           type: DatumType.INLINE,
169 |           datumHex: parseHexString(
170 |             output.datum.datumHex,
171 |             InvalidDataReason.OUTPUT_INVALID_INLINE_DATUM,
172 |           ),
173 |         }
174 | 
175 |       default:
176 |         return null
177 |     }
178 |   } else {
179 |     // Alonzo
180 |     return output.datumHashHex == null
181 |       ? null
182 |       : parseDatumHash(output.datumHashHex)
183 |   }
184 | }
185 | 
186 | /*
187 |  * Typically, destination is used in output, where we forbid reward addresses.
188 |  * In some other places, we allow them. The parameter 'validateAsTxOutput'
189 |  * is used to control this validation.
190 |  */
191 | export function parseTxDestination(
192 |   network: Network,
193 |   destination: TxOutputDestination,
194 |   validateAsTxOutput: boolean,
195 | ): ParsedOutputDestination {
196 |   switch (destination.type) {
197 |     case TxOutputDestinationType.THIRD_PARTY: {
198 |       const params = destination.params
199 |       const addressHex = parseHexString(
200 |         params.addressHex,
201 |         InvalidDataReason.OUTPUT_INVALID_ADDRESS,
202 |       )
203 |       validate(
204 |         params.addressHex.length <= 128 * 2,
205 |         InvalidDataReason.OUTPUT_INVALID_ADDRESS,
206 |       )
207 |       return {
208 |         type: TxOutputDestinationType.THIRD_PARTY,
209 |         addressHex,
210 |       }
211 |     }
212 |     case TxOutputDestinationType.DEVICE_OWNED: {
213 |       const params = destination.params
214 |       const addressParams = parseAddress(network, params)
215 |       if (validateAsTxOutput) {
216 |         validate(
217 |           // a reward address cannot be used in tx output
218 |           addressParams.spendingDataSource.type === SpendingDataSourceType.PATH,
219 |           InvalidDataReason.OUTPUT_INVALID_ADDRESS_PARAMS,
220 |         )
221 |       }
222 |       return {
223 |         type: TxOutputDestinationType.DEVICE_OWNED,
224 |         addressParams,
225 |       }
226 |     }
227 |     default:
228 |       throw new InvalidData(InvalidDataReason.ADDRESS_UNKNOWN_TYPE)
229 |   }
230 | }
231 | 
232 | export function parseTxOutput(
233 |   output: TxOutput,
234 |   network: Network,
235 | ): ParsedOutput {
236 |   const format =
237 |     output.format === TxOutputFormat.MAP_BABBAGE
238 |       ? TxOutputFormat.MAP_BABBAGE
239 |       : TxOutputFormat.ARRAY_LEGACY
240 | 
241 |   const amount = parseCoin(
242 |     output.amount,
243 |     InvalidDataReason.OUTPUT_INVALID_AMOUNT,
244 |   )
245 | 
246 |   const tokenBundle = parseTokenBundle(
247 |     output.tokenBundle ?? [],
248 |     true,
249 |     parseUint64_str,
250 |   )
251 | 
252 |   const destination = parseTxDestination(network, output.destination, true)
253 | 
254 |   const datum = parseDatum(output)
255 |   if (datum?.type === DatumType.INLINE) {
256 |     validate(
257 |       output.format === TxOutputFormat.MAP_BABBAGE,
258 |       InvalidDataReason.OUTPUT_INCONSISTENT_DATUM,
259 |     )
260 |   }
261 | 
262 |   const referenceScriptHex =
263 |     output.format === TxOutputFormat.MAP_BABBAGE && output.referenceScriptHex
264 |       ? parseHexString(
265 |           output.referenceScriptHex,
266 |           InvalidDataReason.OUTPUT_INVALID_REFERENCE_SCRIPT_HEX,
267 |         )
268 |       : null
269 |   if (referenceScriptHex != null) {
270 |     validate(
271 |       output.format === TxOutputFormat.MAP_BABBAGE,
272 |       InvalidDataReason.OUTPUT_INCONSISTENT_REFERENCE_SCRIPT,
273 |     )
274 |   }
275 | 
276 |   return {
277 |     format,
278 |     amount,
279 |     tokenBundle,
280 |     destination,
281 |     datum,
282 |     referenceScriptHex,
283 |   }
284 | }
285 | 


--------------------------------------------------------------------------------
/src/parsing/txAuxiliaryData.ts:
--------------------------------------------------------------------------------
  1 | import {InvalidData} from '../errors'
  2 | import {InvalidDataReason} from '../errors/invalidDataReason'
  3 | import type {
  4 |   ParsedCVoteDelegation,
  5 |   ParsedCVoteRegistrationParams,
  6 |   ParsedTxAuxiliaryData,
  7 | } from '../types/internal'
  8 | import {
  9 |   CVOTE_PUBLIC_KEY_LENGTH,
 10 |   AUXILIARY_DATA_HASH_LENGTH,
 11 | } from '../types/internal'
 12 | import type {
 13 |   CIP36VoteDelegation,
 14 |   CIP36VoteRegistrationParams,
 15 |   Network,
 16 |   TxAuxiliaryData,
 17 | } from '../types/public'
 18 | import {
 19 |   CIP36VoteDelegationType,
 20 |   CIP36VoteRegistrationFormat,
 21 |   TxAuxiliaryDataType,
 22 | } from '../types/public'
 23 | import {
 24 |   isArray,
 25 |   parseBIP32Path,
 26 |   parseHexStringOfLength,
 27 |   parseUint32_t,
 28 |   parseUint64_str,
 29 |   validate,
 30 | } from '../utils/parse'
 31 | import {parseTxDestination} from './output'
 32 | 
 33 | export const CVOTE_VKEY_LENGTH = 32
 34 | 
 35 | function parseCVoteDelegation(
 36 |   delegation: CIP36VoteDelegation,
 37 | ): ParsedCVoteDelegation {
 38 |   const weight = parseUint32_t(
 39 |     delegation.weight,
 40 |     InvalidDataReason.CVOTE_DELEGATION_INVALID_WEIGHT,
 41 |   )
 42 | 
 43 |   switch (delegation.type) {
 44 |     case CIP36VoteDelegationType.KEY:
 45 |       return {
 46 |         type: delegation.type,
 47 |         voteKey: parseHexStringOfLength(
 48 |           delegation.voteKeyHex,
 49 |           CVOTE_PUBLIC_KEY_LENGTH,
 50 |           InvalidDataReason.CVOTE_DELEGATION_INVALID_KEY,
 51 |         ),
 52 |         weight,
 53 |       }
 54 |     case CIP36VoteDelegationType.PATH:
 55 |       return {
 56 |         type: delegation.type,
 57 |         voteKeyPath: parseBIP32Path(
 58 |           delegation.voteKeyPath,
 59 |           InvalidDataReason.CVOTE_DELEGATION_INVALID_PATH,
 60 |         ),
 61 |         weight,
 62 |       }
 63 |     default:
 64 |       throw new InvalidData(
 65 |         InvalidDataReason.CVOTE_DELEGATION_UNKNOWN_DELEGATION_TYPE,
 66 |       )
 67 |   }
 68 | }
 69 | 
 70 | function parseCVoteDelegations(
 71 |   delegations: Array<CIP36VoteDelegation>,
 72 | ): Array<ParsedCVoteDelegation> {
 73 |   validate(
 74 |     isArray(delegations),
 75 |     InvalidDataReason.CVOTE_REGISTRATION_DELEGATIONS_NOT_ARRAY,
 76 |   )
 77 |   return delegations.map((d) => parseCVoteDelegation(d))
 78 | }
 79 | 
 80 | function parseCVoteRegistrationParams(
 81 |   network: Network,
 82 |   params: CIP36VoteRegistrationParams,
 83 | ): ParsedCVoteRegistrationParams {
 84 |   switch (params.format) {
 85 |     case CIP36VoteRegistrationFormat.CIP_15:
 86 |       validate(
 87 |         params.delegations == null,
 88 |         InvalidDataReason.CVOTE_REGISTRATION_INCONSISTENT_WITH_CIP15,
 89 |       )
 90 |       validate(
 91 |         params.voteKeyHex != null,
 92 |         InvalidDataReason.CVOTE_REGISTRATION_INCONSISTENT_WITH_CIP15,
 93 |       )
 94 |       validate(
 95 |         params.votingPurpose == null,
 96 |         InvalidDataReason.CVOTE_REGISTRATION_INCONSISTENT_WITH_CIP15,
 97 |       )
 98 |       break
 99 | 
100 |     case CIP36VoteRegistrationFormat.CIP_36:
101 |       // exactly one of delegations, voteKeyHex, voteKeyPath must be given
102 |       if (params.delegations != null) {
103 |         validate(
104 |           params.voteKeyHex == null && params.voteKeyPath == null,
105 |           InvalidDataReason.CVOTE_REGISTRATION_INCONSISTENT_WITH_CIP36,
106 |         )
107 |       } else {
108 |         validate(
109 |           params.delegations == null,
110 |           InvalidDataReason.CVOTE_REGISTRATION_INCONSISTENT_WITH_CIP36,
111 |         )
112 |         validate(
113 |           params.voteKeyHex == null || params.voteKeyPath == null,
114 |           InvalidDataReason.CVOTE_REGISTRATION_BOTH_KEY_AND_PATH,
115 |         )
116 |         validate(
117 |           params.voteKeyHex != null || params.voteKeyPath != null,
118 |           InvalidDataReason.CVOTE_REGISTRATION_MISSING_VOTE_KEY,
119 |         )
120 |       }
121 |       break
122 | 
123 |     default:
124 |       throw new InvalidData(InvalidDataReason.CVOTE_DELEGATION_UNKNOWN_FORMAT)
125 |   }
126 | 
127 |   const voteKey =
128 |     params.voteKeyHex == null
129 |       ? null
130 |       : parseHexStringOfLength(
131 |           params.voteKeyHex,
132 |           CVOTE_VKEY_LENGTH,
133 |           InvalidDataReason.CVOTE_REGISTRATION_INVALID_VOTE_KEY,
134 |         )
135 | 
136 |   const voteKeyPath =
137 |     params.voteKeyPath == null
138 |       ? null
139 |       : parseBIP32Path(
140 |           params.voteKeyPath,
141 |           InvalidDataReason.CVOTE_REGISTRATION_INVALID_VOTE_KEY_PATH,
142 |         )
143 | 
144 |   const delegations =
145 |     params.delegations == null
146 |       ? null
147 |       : parseCVoteDelegations(params.delegations)
148 | 
149 |   const votingPurpose =
150 |     params.votingPurpose == null
151 |       ? null
152 |       : parseUint64_str(
153 |           params.votingPurpose,
154 |           {},
155 |           InvalidDataReason.CVOTE_REGISTRATION_INVALID_VOTING_PURPOSE,
156 |         )
157 | 
158 |   return {
159 |     format: params.format,
160 |     votePublicKey: voteKey,
161 |     votePublicKeyPath: voteKeyPath,
162 |     delegations,
163 |     stakingPath: parseBIP32Path(
164 |       params.stakingPath,
165 |       InvalidDataReason.CVOTE_REGISTRATION_INVALID_STAKING_KEY_PATH,
166 |     ),
167 |     paymentDestination: parseTxDestination(
168 |       network,
169 |       params.paymentDestination,
170 |       false,
171 |     ),
172 |     nonce: parseUint64_str(
173 |       params.nonce,
174 |       {},
175 |       InvalidDataReason.CVOTE_REGISTRATION_INVALID_NONCE,
176 |     ),
177 |     votingPurpose,
178 |   }
179 | }
180 | 
181 | export function parseTxAuxiliaryData(
182 |   network: Network,
183 |   auxiliaryData: TxAuxiliaryData,
184 | ): ParsedTxAuxiliaryData {
185 |   switch (auxiliaryData.type) {
186 |     case TxAuxiliaryDataType.ARBITRARY_HASH: {
187 |       return {
188 |         type: TxAuxiliaryDataType.ARBITRARY_HASH,
189 |         hashHex: parseHexStringOfLength(
190 |           auxiliaryData.params.hashHex,
191 |           AUXILIARY_DATA_HASH_LENGTH,
192 |           InvalidDataReason.AUXILIARY_DATA_INVALID_HASH,
193 |         ),
194 |       }
195 |     }
196 |     case TxAuxiliaryDataType.CIP36_REGISTRATION: {
197 |       return {
198 |         type: TxAuxiliaryDataType.CIP36_REGISTRATION,
199 |         params: parseCVoteRegistrationParams(network, auxiliaryData.params),
200 |       }
201 |     }
202 |     default:
203 |       throw new InvalidData(InvalidDataReason.AUXILIARY_DATA_UNKNOWN_TYPE)
204 |   }
205 | }
206 | 


--------------------------------------------------------------------------------
/src/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 |   "extends": "../tsconfig.base",
3 |   "include": ["./**/*.ts"]
4 | }
5 | 


--------------------------------------------------------------------------------
/src/utils.ts:
--------------------------------------------------------------------------------
 1 | import {
 2 |   base58_encode,
 3 |   bech32_decodeAddress,
 4 |   bech32_encodeAddress,
 5 | } from './utils/address'
 6 | import type {Version} from './types/public'
 7 | import {assert} from './utils/assert'
 8 | import {isArray, isBuffer, isInteger} from './utils/parse'
 9 | import {buf_to_hex, buf_to_uint16, hex_to_buf} from './utils/serialize'
10 | 
11 | const sum = (arr: Array<number>) => arr.reduce((x, y) => x + y, 0)
12 | 
13 | export function chunkBy(data: Buffer, chunkLengths: Array<number>): Buffer[] {
14 |   assert(isBuffer(data), 'invalid buffer')
15 |   assert(isArray(chunkLengths), 'invalid chunks')
16 |   for (const len of chunkLengths) {
17 |     assert(isInteger(len), 'bad chunk length')
18 |     assert(len > 0, 'bad chunk length')
19 |   }
20 |   assert(data.length <= sum(chunkLengths), 'data too short')
21 | 
22 |   let offset = 0
23 |   const result = []
24 | 
25 |   const restLength = data.length - sum(chunkLengths)
26 | 
27 |   for (const c of [...chunkLengths, restLength]) {
28 |     result.push(data.slice(offset, offset + c))
29 | 
30 |     offset += c
31 |   }
32 | 
33 |   return result
34 | }
35 | 
36 | export function stripRetcodeFromResponse(response: Buffer): Buffer {
37 |   assert(isBuffer(response), 'invalid buffer')
38 |   assert(response.length >= 2, 'response too short')
39 | 
40 |   const L = response.length - 2
41 |   const retcode = buf_to_uint16(response.slice(L, L + 2))
42 |   assert(retcode === 0x9000, `Invalid retcode ${retcode}`)
43 |   return response.slice(0, L)
44 | }
45 | 
46 | export default {
47 |   // reexporting for tests
48 |   hex_to_buf,
49 |   buf_to_hex,
50 | 
51 |   assert,
52 | 
53 |   base58_encode,
54 | 
55 |   bech32_encodeAddress,
56 |   bech32_decodeAddress,
57 | 
58 |   chunkBy,
59 |   stripRetcodeFromResponse,
60 | }
61 | 
62 | export function getVersionString(version: Version): string {
63 |   const xs = version.flags.isAppXS ? '-NanoS' : ''
64 |   return `${version.major}.${version.minor}.${version.patch}${xs}`
65 | }
66 | 


--------------------------------------------------------------------------------
/src/utils/address.ts:
--------------------------------------------------------------------------------
 1 | import basex from 'base-x'
 2 | import bech32 from 'bech32'
 3 | 
 4 | import {InvalidDataReason} from '../errors'
 5 | import {AddressType, HARDENED} from '../types/public'
 6 | import {assert} from '../utils/assert'
 7 | import {isBuffer, isString, parseIntFromStr, validate} from './parse'
 8 | 
 9 | const BASE58_ALPHABET =
10 |   '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
11 | const bs58 = basex(BASE58_ALPHABET)
12 | 
13 | const TESTNET_NETWORK_ID = 0x00
14 | 
15 | function parseBIP32Index(str: string, errMsg: InvalidDataReason): number {
16 |   let base = 0
17 |   if (str.endsWith("'")) {
18 |     str = str.slice(0, -1)
19 |     base = HARDENED
20 |   }
21 |   const i = parseIntFromStr(str, errMsg)
22 |   validate(i >= 0, errMsg)
23 |   validate(i < HARDENED, errMsg)
24 |   return base + i
25 | }
26 | 
27 | export function str_to_path(data: string): Array<number> {
28 |   const errMsg = InvalidDataReason.INVALID_PATH
29 |   validate(isString(data), errMsg)
30 |   validate(data.length > 0, errMsg)
31 | 
32 |   return data.split('/').map((x: string): number => {
33 |     return parseBIP32Index(x, errMsg)
34 |   })
35 | }
36 | 
37 | export function base58_encode(data: Buffer): string {
38 |   assert(isBuffer(data), 'invalid buffer')
39 | 
40 |   return bs58.encode(data)
41 | }
42 | 
43 | const isValidBase58 = (data: unknown): data is string =>
44 |   isString(data) && [...data].every((c) => BASE58_ALPHABET.includes(c))
45 | 
46 | export function base58_decode(data: string): Buffer {
47 |   assert(isValidBase58(data), 'invalid base58 string')
48 | 
49 |   return bs58.decode(data)
50 | }
51 | 
52 | // based on https://github.com/cardano-foundation/CIPs/pull/6/files
53 | function getShelleyAddressPrefix(data: Buffer): string {
54 |   let result = ''
55 | 
56 |   // eslint-disable-next-line no-bitwise
57 |   const addressType = (data[0] & 0b11110000) >> 4
58 |   switch (addressType) {
59 |     case AddressType.REWARD_KEY:
60 |     case AddressType.REWARD_SCRIPT:
61 |       result = 'stake'
62 |       break
63 |     default:
64 |       result = 'addr'
65 |   }
66 | 
67 |   // eslint-disable-next-line no-bitwise
68 |   const networkId = data[0] & 0b00001111
69 |   if (networkId === TESTNET_NETWORK_ID) {
70 |     result += '_test'
71 |   }
72 | 
73 |   return result
74 | }
75 | 
76 | export function bech32_encodeAddress(data: Buffer): string {
77 |   assert(isBuffer(data), 'invalid buffer')
78 | 
79 |   const data5bit = bech32.toWords(data)
80 |   const MAX_HUMAN_ADDRESS_LENGTH = 150 // see cardano.h in https://github.com/vacuumlabs/ledger-app-cardano-shelley
81 |   return bech32.encode(
82 |     getShelleyAddressPrefix(data),
83 |     data5bit,
84 |     MAX_HUMAN_ADDRESS_LENGTH,
85 |   )
86 | }
87 | 
88 | export function bech32_decodeAddress(data: string): Buffer {
89 |   const {words} = bech32.decode(data, 1000)
90 |   return Buffer.from(bech32.fromWords(words))
91 | }
92 | 


--------------------------------------------------------------------------------
/src/utils/assert.ts:
--------------------------------------------------------------------------------
 1 | import {ErrorBase} from '../errors/errorBase'
 2 | 
 3 | export function assert(cond: boolean, errMsg: string): asserts cond {
 4 |   const msg = errMsg ? `: ${errMsg}` : ''
 5 |   if (!cond) throw new ErrorBase(`Assertion failed${msg}`)
 6 | }
 7 | 
 8 | export function unreachable(_val: never): never {
 9 |   assert(false, 'Unreachable code hit')
10 | }
11 | 


--------------------------------------------------------------------------------
/src/utils/serialize.ts:
--------------------------------------------------------------------------------
  1 | import {Int64BE, Uint64BE} from 'int64-buffer'
  2 | 
  3 | import type {
  4 |   FixLenHexString,
  5 |   HexString,
  6 |   Int64_str,
  7 |   ParsedCredential,
  8 |   Uint8_t,
  9 |   Uint16_t,
 10 |   Uint32_t,
 11 |   Uint64_str,
 12 |   ParsedAnchor,
 13 | } from '../types/internal'
 14 | import {CredentialType} from '../types/internal'
 15 | import {assert, unreachable} from './assert'
 16 | import {
 17 |   isHexString,
 18 |   isInt64str,
 19 |   isUint8,
 20 |   isUint16,
 21 |   isUint32,
 22 |   isUint64str,
 23 |   isValidPath,
 24 | } from './parse'
 25 | 
 26 | export function uint8_to_buf(value: Uint8_t): Buffer {
 27 |   assert(isUint8(value), 'invalid uint8')
 28 |   const data = Buffer.alloc(1)
 29 |   data.writeUInt8(value, 0)
 30 |   return data
 31 | }
 32 | 
 33 | export function uint16_to_buf(value: Uint16_t | Uint8_t): Buffer {
 34 |   assert(isUint16(value), 'invalid uint16')
 35 | 
 36 |   const data = Buffer.alloc(2)
 37 |   data.writeUInt16BE(value, 0)
 38 |   return data
 39 | }
 40 | 
 41 | export function buf_to_uint16(data: Buffer): Uint16_t {
 42 |   assert(data.length === 2, 'invalid uint16 buffer')
 43 | 
 44 |   return data.readUIntBE(0, 2) as Uint16_t
 45 | }
 46 | 
 47 | export function uint32_to_buf(value: Uint32_t | Uint16_t | Uint8_t): Buffer {
 48 |   assert(isUint32(value), 'invalid uint32')
 49 | 
 50 |   const data = Buffer.alloc(4)
 51 |   data.writeUInt32BE(value, 0)
 52 |   return data
 53 | }
 54 | 
 55 | export function buf_to_uint32(data: Buffer): Uint32_t {
 56 |   assert(data.length === 4, 'invalid uint32 buffer')
 57 | 
 58 |   return data.readUIntBE(0, 4) as Uint32_t
 59 | }
 60 | 
 61 | export function uint64_to_buf(value: Uint64_str): Buffer {
 62 |   assert(isUint64str(value), 'invalid uint64_str')
 63 | 
 64 |   const data = new Uint64BE(value, 10).toBuffer()
 65 |   assert(data.length === 8, 'invalid data length')
 66 | 
 67 |   return data
 68 | }
 69 | 
 70 | export function int64_to_buf(value: Int64_str): Buffer {
 71 |   assert(isInt64str(value), 'invalid int64_str')
 72 | 
 73 |   const data = new Int64BE(value, 10).toBuffer()
 74 |   assert(data.length === 8, 'invalid data length')
 75 | 
 76 |   return data
 77 | }
 78 | 
 79 | export function hex_to_buf(data: HexString | FixLenHexString<unknown>): Buffer {
 80 |   assert(isHexString(data), 'invalid hex string')
 81 |   return Buffer.from(data, 'hex')
 82 | }
 83 | 
 84 | export function buf_to_hex(data: Buffer): string {
 85 |   return data.toString('hex')
 86 | }
 87 | 
 88 | // no buf_to_uint8
 89 | 
 90 | export function path_to_buf(path: Array<number>): Buffer {
 91 |   assert(isValidPath(path), 'invalid bip32 path')
 92 | 
 93 |   const data = Buffer.alloc(1 + 4 * path.length)
 94 |   data.writeUInt8(path.length, 0)
 95 | 
 96 |   for (let i = 0; i < path.length; i++) {
 97 |     data.writeUInt32BE(path[i], 1 + i * 4)
 98 |   }
 99 |   return data
100 | }
101 | 
102 | export function serializeOptionFlag(included: boolean): Buffer {
103 |   const SignTxIncluded = {
104 |     NO: 1 as Uint8_t,
105 |     YES: 2 as Uint8_t,
106 |   }
107 | 
108 |   const value = included ? SignTxIncluded.YES : SignTxIncluded.NO
109 | 
110 |   return uint8_to_buf(value)
111 | }
112 | 
113 | export function serializeCoin(coin: Uint64_str): Buffer {
114 |   return Buffer.concat([uint64_to_buf(coin)])
115 | }
116 | 
117 | export function serializeCredential(credential: ParsedCredential): Buffer {
118 |   switch (credential.type) {
119 |     case CredentialType.KEY_PATH:
120 |       return Buffer.concat([
121 |         uint8_to_buf(credential.type as Uint8_t),
122 |         path_to_buf(credential.path),
123 |       ])
124 |     case CredentialType.KEY_HASH:
125 |       return Buffer.concat([
126 |         uint8_to_buf(credential.type as Uint8_t),
127 |         hex_to_buf(credential.keyHashHex),
128 |       ])
129 |     case CredentialType.SCRIPT_HASH:
130 |       return Buffer.concat([
131 |         uint8_to_buf(credential.type as Uint8_t),
132 |         hex_to_buf(credential.scriptHashHex),
133 |       ])
134 |     default:
135 |       unreachable(credential)
136 |   }
137 | }
138 | 
139 | export function serializeAnchor(anchor: ParsedAnchor | null): Buffer {
140 |   if (anchor == null) {
141 |     return Buffer.concat([serializeOptionFlag(false)])
142 |   } else {
143 |     return Buffer.concat([
144 |       serializeOptionFlag(true),
145 |       hex_to_buf(anchor.hashHex),
146 |       Buffer.from(anchor.url, 'ascii'),
147 |     ])
148 |   }
149 | }
150 | 


--------------------------------------------------------------------------------
/test/device-self-test/runTestsDevice.test.ts:
--------------------------------------------------------------------------------
 1 | import type Ada from '../../src/Ada'
 2 | import {getAda} from '../test_utils'
 3 | 
 4 | describe('runTestsDevice', () => {
 5 |   let ada: Ada = {} as Ada
 6 | 
 7 |   beforeEach(async () => {
 8 |     ada = await getAda()
 9 |   })
10 | 
11 |   afterEach(async () => {
12 |     // eslint-disable-next-line @typescript-eslint/no-explicit-any
13 |     await (ada as any).t.close()
14 |   })
15 | 
16 |   it('Should run device tests', async () => {
17 |     await ada.runTests()
18 |   })
19 | })
20 | 


--------------------------------------------------------------------------------
/test/integration/__fixtures__/getExtendedPublicKey.ts:
--------------------------------------------------------------------------------
  1 | export type TestCase = {
  2 |   path: string
  3 |   expected: {publicKey: string; chainCode: string; _privateKey?: string}
  4 | }
  5 | 
  6 | export const testsByron: TestCase[] = [
  7 |   // Byron
  8 |   {
  9 |     path: "44'/1815'/1'",
 10 |     expected: {
 11 |       publicKey:
 12 |         'eb6e933ce45516ac7b0e023de700efae5e212ccc6bf0fcb33ba9243b9d832827',
 13 |       chainCode:
 14 |         '0b161cb11babe1f56c3f9f1cbbb7b6d2d13eeb3efa67205198a69b8d81885354',
 15 |       _privateKey:
 16 |         '5878bdf06af259f1419324680c4d4ce05b4343895b697144d874749925e69d41648e7e50061809207f81dac36b73cd8fab2325d49d26bc65ebbb696ea59c45b8',
 17 |     },
 18 |   },
 19 |   {
 20 |     path: "44'/1815'/1'/0/55'",
 21 |     expected: {
 22 |       publicKey:
 23 |         '83220849a3ada3e95495e22b24aee95c3120d4c8a9faafed312914769e65b70d',
 24 |       chainCode:
 25 |         '69d1b1d5a95ba88b2851d6e1da2d2113f4eca6949f31ababf007deffaba6ae26',
 26 |       _privateKey:
 27 |         'b0af23faa61a4bddea371d1a406001bfe8cc7de606d6fc3f817003372fe69d412350b482eae6356f47dfe3cec7b114653a96c7fb94ee20f70499ee0c9f4c212c',
 28 |     },
 29 |   },
 30 |   {
 31 |     path: "44'/1815'/1'/0/12'",
 32 |     expected: {
 33 |       publicKey:
 34 |         '40711c6ebf9c0a4c73987687a09255d9cfa8591c9915162ba11054ec4ee77e09',
 35 |       chainCode:
 36 |         'b4fbd48d01d09c7cbcaed7a48ffac9d53ddf5564ad468bfef18fe7d9bc535a16',
 37 |       _privateKey:
 38 |         'd8081fe3f24b16a052db09badeb8bab0a40f94f0f41b2978f460efb02ae69d41c5ef9fb6fedd0a94f7d82afee6496aa965c70c1143425a356fc0bc296e17fdd8',
 39 |     },
 40 |   },
 41 | ]
 42 | 
 43 | export const testsShelleyUsual: TestCase[] = [
 44 |   // Shelley
 45 |   {
 46 |     path: "1852'/1815'/4'",
 47 |     expected: {
 48 |       publicKey:
 49 |         '4e4353d7cc6f49e8e7a281e08a7672d000d4abfdf07be299cbff95d6a05df224',
 50 |       chainCode:
 51 |         'cbc28c222a6c15c0cfe98434f97b3aef860b5ce6902e177820adbd70ed7dc2ec',
 52 |     },
 53 |   },
 54 |   {
 55 |     path: "1852'/1815'/0'/0/1",
 56 |     expected: {
 57 |       publicKey:
 58 |         'b3d5f4158f0c391ee2a28a2e285f218f3e895ff6ff59cb9369c64b03b5bab5eb',
 59 |       chainCode:
 60 |         '27e1d1f3a3d0fafc0884e02a2d972e7e5b1be8a385ecc1bc75a977b4073dbd08',
 61 |     },
 62 |   },
 63 |   {
 64 |     path: "1852'/1815'/0'/2/0",
 65 |     expected: {
 66 |       publicKey:
 67 |         '66610efd336e1137c525937b76511fbcf2a0e6bcf0d340a67bcb39bc870d85e8',
 68 |       chainCode:
 69 |         'e977e956d29810dbfbda9c8ea667585982454e401c68578623d4b86bc7eb7b58',
 70 |     },
 71 |   },
 72 |   {
 73 |     path: "1852'/1815'/0'/2/1001",
 74 |     expected: {
 75 |       publicKey:
 76 |         'dbc5fbbe47eabc036c6834ea62c011b15272ec85a17facd3670cd9304486ffe8',
 77 |       chainCode:
 78 |         'fb037474fc75e64745f7fd9f44b4bcbc58d81cae2209f2f5c1f77501e9bb43df',
 79 |     },
 80 |   },
 81 |   {
 82 |     path: "1852'/1815'/0'/3/0",
 83 |     expected: {
 84 |       publicKey:
 85 |         '7cc18df2fbd3ee1b16b76843b18446679ab95dbcd07b7833b66a9407c0709e37',
 86 |       chainCode:
 87 |         '01d881e1c04fed8defa9a3e8bd3cf85bd975f813ff8eb622d20a4375a07d6bc9',
 88 |     },
 89 |   },
 90 |   {
 91 |     path: "1852'/1815'/0'/4/0",
 92 |     expected: {
 93 |       publicKey:
 94 |         'bc8c8a37d6ab41339bb073e72ce2e776cefed98d1a6d070ea5fada80dc7d6737',
 95 |       chainCode:
 96 |         '6f58406a51d33bb35e98884cbadced9bc94f65a752001ad5f4788af07b2ec0fe',
 97 |     },
 98 |   },
 99 |   {
100 |     path: "1852'/1815'/1'/5/0",
101 |     expected: {
102 |       publicKey:
103 |         '624142a80217b95ca2fc5b0c1f8d74e26e5683621c430c7bc7eebca6ee541a58',
104 |       chainCode:
105 |         '92a8c64cfdf1af08e78c2ba59bef496eb34ddf24bdf0f91404a962415a7a0810',
106 |     },
107 |   },
108 | ]
109 | 
110 | export const testsShelleyUnusual: TestCase[] = [
111 |   {
112 |     path: "1852'/1815'/101'",
113 |     expected: {
114 |       publicKey:
115 |         '674af1cfe5919576714bb31f065ac93788a6a2fb5168362c0aa9509ac513bbbc',
116 |       chainCode:
117 |         '5d403248edff92b87433ae97942326cd1656a57301a03988fb36b9ae728d4d2c',
118 |     },
119 |   },
120 |   {
121 |     path: "1852'/1815'/100'/0/1000001'",
122 |     expected: {
123 |       publicKey:
124 |         'd06a7a9d87e95f475811e31b03564d272f1c2614e8b2cf0f37d6e973fd2aba9c',
125 |       chainCode:
126 |         '8aca949d791e4a4f26e05e55d39d17f565884b56882283cf7d97e338fa7ab9ee',
127 |     },
128 |   },
129 |   {
130 |     path: "1852'/1815'/0'/2/1000001",
131 |     expected: {
132 |       publicKey:
133 |         '1763dfbba10629d5e9ed8f8714889f82f0bdb4b62af22b19b607713919f93e4d',
134 |       chainCode:
135 |         'b46ecc1459e0ad4ae7fa1b9a7440584b6177472db300304a3191a91b7fb0e1e8',
136 |     },
137 |   },
138 |   {
139 |     path: "1852'/1815'/101'/3/0",
140 |     expected: {
141 |       publicKey:
142 |         'a4fecb8d8febd80d1f7eefe3d1705b03405e219df1f6aa4c2e227b5909df873e',
143 |       chainCode:
144 |         'a0aac4f3cfe62e20ad66c5f737979eecc4472c61c41d8d5f4e06cf13a2386648',
145 |     },
146 |   },
147 |   {
148 |     path: "1852'/1815'/101'/4/0",
149 |     expected: {
150 |       publicKey:
151 |         '6967cc28a4665b319405b5ce8dae9ae6c89967fb3068f7f84c66bf6abbab94f2',
152 |       chainCode:
153 |         '66381ec0b35d2805256f5d57ec47abf948a3206902868ed80b04a5b0e81cf1de',
154 |     },
155 |   },
156 |   {
157 |     path: "1852'/1815'/101'/5/0",
158 |     expected: {
159 |       publicKey:
160 |         '1b520336538452b69d5562e5d714bfe7aeeb7cf9afd1d8574af1823c5636f9eb',
161 |       chainCode:
162 |         '5e21bf9678c54b880d2f594f3b0cd1c000f8516f809fc0f6aaaa35e2d2030e40',
163 |     },
164 |   },
165 | ]
166 | 
167 | export const testsColdKeys: TestCase[] = [
168 |   {
169 |     path: "1853'/1815'/0'/0'",
170 |     expected: {
171 |       publicKey:
172 |         '3d7e84dca8b4bc322401a2cc814af7c84d2992a22f99554fe340d7df7910768d',
173 |       chainCode:
174 |         '1e2a47754207da3069f90241fbf3b8742c367e9028e5f3f85ae3660330b4f5b7',
175 |     },
176 |   },
177 | ]
178 | 
179 | export const testsCVoteKeys: TestCase[] = [
180 |   {
181 |     path: "1694'/1815'/0'/0/1",
182 |     expected: {
183 |       publicKey:
184 |         'aac861247bd24cae705bca1d1c9763f19c19188fb0faf257c50ed69b8157bced',
185 |       chainCode:
186 |         'f23595dd3207b7dde477347fa25d3fd6291c3363df43b54a9cf523d2c7683c10',
187 |     },
188 |   },
189 |   {
190 |     path: "1694'/1815'/100'",
191 |     expected: {
192 |       publicKey:
193 |         'ff451db773898b80488d892b248acdc634f6ec79d923f12aae9feb2563513b63',
194 |       chainCode:
195 |         '47478097ef56dcef686f8dcbd7d0c1d073740cde65a48e5615799096f67a144f',
196 |     },
197 |   },
198 |   {
199 |     path: "1694'/1815'/101'",
200 |     expected: {
201 |       publicKey:
202 |         'c7adc69b6dd29c48d29edb089c1aecbe218fdb9cfa59c325afcd2c5fa3844be1',
203 |       chainCode:
204 |         'ffa9953f6c77fccc15c000db494177d84e218f2740ddd44cfcbea0455cc6a6be',
205 |     },
206 |   },
207 | ]
208 | 


--------------------------------------------------------------------------------
/test/integration/__fixtures__/signCVote.ts:
--------------------------------------------------------------------------------
 1 | import {str_to_path} from '../../../src/utils/address'
 2 | import type {CIP36Vote, SignedCIP36VoteData} from '../../../src/Ada'
 3 | 
 4 | export type TestCase = {
 5 |   testName: string
 6 |   cVote: CIP36Vote
 7 |   expected: SignedCIP36VoteData
 8 | }
 9 | 
10 | export const tests: TestCase[] = [
11 |   {
12 |     testName: 'Should correctly sign a CIP36 vote-cast fragment',
13 |     cVote: {
14 |       voteCastDataHex:
15 |         '36ad42885189a0ac3438cdb57bc8ac7f6542e05a59d1f2e4d1d38194c9d4ac7b000203f6639bdbc9235103825a9f025eae5cff3bd9c9dcc0f5a4b286909744746c8b6fb0018773d3b4308344d2e90599cd03749658561787eab714b542a5ccaf078846f6639bdbc9235103825a9f025eae5cff3bd9c9dcc0f5a4b286909744746c8b6fc8f58976fc0e951ba284a24f3fc190d914ae53aebcc523e7a4a330c8655b4908f6639bdbc9235103825a9f025eae5cff3bd9c9dcc0f5a4b286909744746c8b6fb0018773d3b4308344d2e90599cd03749658561787eab714b542a5ccaf078846021c76d0a50054ef7205cb95c1fd3f928f224fab8a8d70feaf4f5db90630c3845a06df2f11c881e396318bd8f9e9f135c2477e923c3decfd6be5466d6166fb3c702edd0d1d0a201fb8c51a91d01328da257971ca78cc566d4b518cb2cd261f96644067a7359a745fe239db8e73059883aece4d506be71c1262b137e295ce5f8a0aac22c1d8d343e5c8b5be652573b85cba8f4dcb46cfa4aafd8d59974e2eb65f480cf85ab522e23203c4f2faa9f95ebc0cd75b04f04fef5d4001d349d1307bb5570af4a91d8af4a489297a3f5255c1e12948787271275c50386ab2ef3980d882228e5f3c82d386e6a4ccf7663df5f6bbd9cbbadd6b2fea2668a8bf5603be29546152902a35fc44aae80d9dcd85fad6cde5b47a6bdc6257c5937f8de877d5ca0356ee9f12a061e03b99ab9dfea56295485cb5ce38cd37f56c396949f58b0627f455d26e4c5ff0bc61ab0ff05ffa07880d0e5c540bc45b527e8e85bb1da469935e0d3ada75d7d41d785d67d1d0732d7d6cbb12b23bfc21dfb4bbe3d933eaa1e5190a85d6e028706ab18d262375dd22a7c1a0e7efa11851ea29b4c92739aaabfee40353453ece16bda2f4a2c2f86e6b37f6de92dc45dba2eb811413c4af2c89f5fc0859718d7cd9888cd8d813da2e93726484ea5ce5be8ecf1e1490b874bd897ccd0cbc33db0a1751f813683724b7f5cf750f2497953607d1e82fb5d1429cbfd7a40ccbdba04fb648203c91e0809e497e80e9fad7895b844ba6da6ac690c7ce49c10e00000000000000000100ff00000000000000036d2ac8ddbf6eaac95401f91baca7f068e3c237386d7c9a271f5187ed90915587',
16 |       witnessPath: str_to_path("1694'/1815'/0'/0/1"),
17 |     },
18 |     expected: {
19 |       dataHashHex:
20 |         'f51473df863be3e0383ce5a8da79c7ff51b3d98dadbbefbf9f042e8601901269',
21 |       witnessPath: str_to_path("1694'/1815'/0'/0/1"),
22 |       witnessSignatureHex:
23 |         'cbc615a8aa970cfffc6d122289f5379109cde5395cdc41c0c16b053283e3ac844e773ddca9c7df30e26910dcac54afc566126f42efc10150385f2639fcaa6102',
24 |     },
25 |   },
26 | ]
27 | 


--------------------------------------------------------------------------------
/test/integration/__fixtures__/signOperationalCertificate.ts:
--------------------------------------------------------------------------------
 1 | import {str_to_path} from '../../../src/utils/address'
 2 | import type {
 3 |   OperationalCertificate,
 4 |   OperationalCertificateSignature,
 5 | } from '../../../src/Ada'
 6 | 
 7 | export type TestCase = {
 8 |   testName: string
 9 |   operationalCertificate: OperationalCertificate
10 |   expected: OperationalCertificateSignature
11 | }
12 | 
13 | export const tests: TestCase[] = [
14 |   {
15 |     testName: 'Should correctly sign a basic operational certificate',
16 |     operationalCertificate: {
17 |       kesPublicKeyHex:
18 |         '3d24bc547388cf2403fd978fc3d3a93d1f39acf68a9c00e40512084dc05f2822',
19 |       kesPeriod: '47',
20 |       issueCounter: '42',
21 |       coldKeyPath: str_to_path("1853'/1815'/0'/0'"),
22 |     },
23 |     expected: {
24 |       signatureHex:
25 |         'ce8d7cab55217ed17f1cceb8cb487dcbe6172fdb5794cc26f78c2f1d2495598e72beb6209f113562f9488ef6e81e3e8f758ea072c3cf9c17095868f2e9213f0a',
26 |     },
27 |   },
28 | ]
29 | 


--------------------------------------------------------------------------------
/test/integration/deriveAddress.test.ts:
--------------------------------------------------------------------------------
  1 | import chai, {expect} from 'chai'
  2 | import chaiAsPromised from 'chai-as-promised'
  3 | import {HexString} from '../../src/types/internal'
  4 | 
  5 | import type {Ada} from '../../src/Ada'
  6 | import {DeviceVersionUnsupported, utils} from '../../src/Ada'
  7 | import {getAda} from '../test_utils'
  8 | import {
  9 |   byronTestCases,
 10 |   rejectTestCases,
 11 |   shelleyTestCases,
 12 | } from './__fixtures__/deriveAddress'
 13 | 
 14 | chai.use(chaiAsPromised)
 15 | 
 16 | const address_hex_to_base58 = (addressHex: string) =>
 17 |   utils.base58_encode(utils.hex_to_buf(addressHex as HexString))
 18 | 
 19 | describe('deriveAddress', () => {
 20 |   let ada: Ada = {} as Ada
 21 | 
 22 |   beforeEach(async () => {
 23 |     ada = await getAda()
 24 |   })
 25 | 
 26 |   afterEach(async () => {
 27 |     // eslint-disable-next-line @typescript-eslint/no-explicit-any
 28 |     await (ada as any).t.close()
 29 |   })
 30 | 
 31 |   describe('Should successfully derive Byron address', () => {
 32 |     for (const {
 33 |       testName,
 34 |       network,
 35 |       addressParams,
 36 |       result: expectedResult,
 37 |     } of byronTestCases) {
 38 |       it(testName, async () => {
 39 |         const isAppXS = (await ada.getVersion()).version.flags.isAppXS
 40 |         const promise = ada.deriveAddress({
 41 |           network,
 42 |           address: addressParams,
 43 |         })
 44 | 
 45 |         if (isAppXS) {
 46 |           await expect(promise).to.be.rejectedWith(DeviceVersionUnsupported)
 47 |         } else {
 48 |           expect(address_hex_to_base58((await promise).addressHex)).to.equal(
 49 |             expectedResult,
 50 |           )
 51 |         }
 52 |       })
 53 |     }
 54 |   })
 55 | 
 56 |   describe('Should successfully derive Shelley address', () => {
 57 |     for (const {
 58 |       testName,
 59 |       network,
 60 |       addressParams,
 61 |       result: expectedResult,
 62 |     } of shelleyTestCases) {
 63 |       it(testName, async () => {
 64 |         const {addressHex} = await ada.deriveAddress({
 65 |           network,
 66 |           address: addressParams,
 67 |         })
 68 | 
 69 |         expect(
 70 |           utils.bech32_encodeAddress(utils.hex_to_buf(addressHex as HexString)),
 71 |         ).to.equal(expectedResult)
 72 |       })
 73 |     }
 74 |   }).timeout(60000)
 75 | 
 76 |   describe('Should reject address derive', () => {
 77 |     for (const {
 78 |       testName,
 79 |       network,
 80 |       addressParams,
 81 |       errCls,
 82 |       errMsg,
 83 |       unsupportedInAppXS,
 84 |     } of rejectTestCases) {
 85 |       it(testName, async () => {
 86 |         const isAppXS = (await ada.getVersion()).version.flags.isAppXS
 87 | 
 88 |         const promise = ada.deriveAddress({
 89 |           network,
 90 |           address: addressParams,
 91 |         })
 92 | 
 93 |         if (isAppXS && unsupportedInAppXS) {
 94 |           await expect(promise).to.be.rejectedWith(DeviceVersionUnsupported)
 95 |         } else {
 96 |           await expect(promise).to.be.rejectedWith(errCls, errMsg)
 97 |         }
 98 |       })
 99 |     }
100 |   })
101 | 
102 |   describe('Should successfully show Byron address', () => {
103 |     for (const {testName, network, addressParams} of byronTestCases) {
104 |       it(testName, async () => {
105 |         const isAppXS = (await ada.getVersion()).version.flags.isAppXS
106 |         const promise = ada.showAddress({
107 |           network,
108 |           address: addressParams,
109 |         })
110 | 
111 |         if (isAppXS) {
112 |           await expect(promise).to.be.rejectedWith(DeviceVersionUnsupported)
113 |         } else {
114 |           expect(await promise).to.equal(undefined)
115 |         }
116 |       })
117 |     }
118 |   })
119 | 
120 |   describe('Should successfully show Shelley address', () => {
121 |     for (const {testName, network, addressParams} of shelleyTestCases) {
122 |       it(testName, async () => {
123 |         const result = await ada.showAddress({network, address: addressParams})
124 |         expect(result).to.equal(undefined)
125 |       })
126 |     }
127 |   }).timeout(60000)
128 | 
129 |   describe('Should reject address show', () => {
130 |     for (const {
131 |       testName,
132 |       network,
133 |       addressParams,
134 |       errCls,
135 |       errMsg,
136 |       unsupportedInAppXS,
137 |     } of rejectTestCases) {
138 |       it(testName, async () => {
139 |         const isAppXS = (await ada.getVersion()).version.flags.isAppXS
140 |         const promise = ada.showAddress({
141 |           network,
142 |           address: addressParams,
143 |         })
144 | 
145 |         if (isAppXS && unsupportedInAppXS) {
146 |           await expect(promise).to.be.rejectedWith(DeviceVersionUnsupported)
147 |         } else {
148 |           await expect(promise).to.be.rejectedWith(errCls, errMsg)
149 |         }
150 |       })
151 |     }
152 |   })
153 | })
154 | 


--------------------------------------------------------------------------------
/test/integration/deriveNativeScriptHash.test.ts:
--------------------------------------------------------------------------------
 1 | import chai, {expect} from 'chai'
 2 | import chaiAsPromised from 'chai-as-promised'
 3 | 
 4 | import type {Ada} from '../../src/Ada'
 5 | import {
 6 |   DeviceStatusError,
 7 |   DeviceVersionUnsupported,
 8 |   InvalidData,
 9 |   NativeScriptHashDisplayFormat,
10 | } from '../../src/Ada'
11 | import {describeWithoutValidation, getAda} from '../test_utils'
12 | import {
13 |   InvalidOnLedgerScriptTestCases,
14 |   InvalidScriptTestCases,
15 |   ValidNativeScriptTestCases,
16 | } from './__fixtures__/deriveNativeScriptHash'
17 | 
18 | chai.use(chaiAsPromised)
19 | 
20 | describe('deriveNativeScriptHash', () => {
21 |   let ada: Ada = {} as Ada
22 | 
23 |   beforeEach(async () => {
24 |     ada = await getAda()
25 |   })
26 | 
27 |   afterEach(async () => {
28 |     // eslint-disable-next-line @typescript-eslint/no-explicit-any
29 |     await (ada as any).t.close()
30 |   })
31 | 
32 |   describe('Valid native scripts', () => {
33 |     for (const {
34 |       testName,
35 |       script,
36 |       displayFormat,
37 |       hashHex: expectedHash,
38 |     } of ValidNativeScriptTestCases) {
39 |       it(testName, async () => {
40 |         const isAppXS = (await ada.getVersion()).version.flags.isAppXS
41 |         const promise = ada.deriveNativeScriptHash({
42 |           script,
43 |           displayFormat,
44 |         })
45 |         if (isAppXS) {
46 |           await expect(promise).to.be.rejectedWith(DeviceVersionUnsupported)
47 |         } else {
48 |           expect((await promise).scriptHashHex).to.equal(expectedHash)
49 |         }
50 |       })
51 |     }
52 |   })
53 | 
54 |   describeWithoutValidation('Ledger should not permit invalid scripts', () => {
55 |     for (const {testName, script} of InvalidOnLedgerScriptTestCases) {
56 |       it(testName, async () => {
57 |         const isAppXS = (await ada.getVersion()).version.flags.isAppXS
58 |         const promise = ada.deriveNativeScriptHash({
59 |           script,
60 |           displayFormat: NativeScriptHashDisplayFormat.BECH32,
61 |         })
62 |         if (isAppXS) {
63 |           await expect(promise).to.be.rejectedWith(DeviceVersionUnsupported)
64 |         } else {
65 |           await expect(promise).to.be.rejectedWith(DeviceStatusError)
66 |         }
67 |       })
68 |     }
69 |   })
70 | 
71 |   describe('Ledgerjs should not permit invalid scripts', () => {
72 |     for (const {
73 |       testName,
74 |       script,
75 |       invalidDataReason: expectedInvalidDataReason,
76 |     } of InvalidScriptTestCases) {
77 |       it(testName, async () => {
78 |         const promise = ada.deriveNativeScriptHash({
79 |           script,
80 |           displayFormat: NativeScriptHashDisplayFormat.BECH32,
81 |         })
82 |         await expect(promise).to.be.rejectedWith(
83 |           InvalidData,
84 |           expectedInvalidDataReason,
85 |         )
86 |       })
87 |     }
88 |   })
89 | })
90 | 


--------------------------------------------------------------------------------
/test/integration/getExtendedPublicKey.test.ts:
--------------------------------------------------------------------------------
  1 | import chai, {expect} from 'chai'
  2 | import chaiAsPromised from 'chai-as-promised'
  3 | 
  4 | import type Ada from '../../src/Ada'
  5 | import {DeviceStatusError} from '../../src/Ada'
  6 | import {str_to_path} from '../../src/utils/address'
  7 | import {getAda} from '../test_utils'
  8 | import type {TestCase} from './__fixtures__/getExtendedPublicKey'
  9 | import {
 10 |   testsCVoteKeys,
 11 |   testsByron,
 12 |   testsColdKeys,
 13 |   testsShelleyUnusual,
 14 |   testsShelleyUsual,
 15 | } from './__fixtures__/getExtendedPublicKey'
 16 | chai.use(chaiAsPromised)
 17 | 
 18 | describe('getExtendedPublicKey', () => {
 19 |   let ada: Ada = {} as Ada
 20 | 
 21 |   beforeEach(async () => {
 22 |     ada = await getAda()
 23 |   })
 24 | 
 25 |   afterEach(async () => {
 26 |     // eslint-disable-next-line @typescript-eslint/no-explicit-any
 27 |     await (ada as any).t.close()
 28 |   })
 29 | 
 30 |   describe('Should successfully get a single extended public key', () => {
 31 |     const test = async (tests: TestCase[]) => {
 32 |       for (const {path, expected} of tests) {
 33 |         const response = await ada.getExtendedPublicKey({
 34 |           path: str_to_path(path),
 35 |         })
 36 | 
 37 |         expect(response.publicKeyHex).to.equal(expected.publicKey)
 38 |         expect(response.chainCodeHex).to.equal(expected.chainCode)
 39 |       }
 40 |     }
 41 | 
 42 |     it('get a single extended public key --- byron', async () => {
 43 |       await test(testsByron)
 44 |     })
 45 |     it('get a single extended public key --- shelley usual', async () => {
 46 |       await test(testsShelleyUsual)
 47 |     })
 48 |     it('get a single extended public key --- shelley unusual', async () => {
 49 |       await test(testsShelleyUnusual)
 50 |     })
 51 |     it('get a single extended public key --- cold keys', async () => {
 52 |       await test(testsColdKeys)
 53 |     })
 54 |     it('get a single extended public key --- vote keys', async () => {
 55 |       await test(testsCVoteKeys)
 56 |     })
 57 |   })
 58 | 
 59 |   describe('Should successfully get several extended public keys', () => {
 60 |     const test = async (tests: TestCase[]) => {
 61 |       const results = await ada.getExtendedPublicKeys({
 62 |         paths: tests.map(({path}) => str_to_path(path)),
 63 |       })
 64 | 
 65 |       expect(results.length).to.equal(tests.length)
 66 |       for (let i = 0; i < tests.length; i++) {
 67 |         expect(results[i].publicKeyHex).to.equal(tests[i].expected.publicKey)
 68 |         expect(results[i].chainCodeHex).to.equal(tests[i].expected.chainCode)
 69 |       }
 70 |     }
 71 | 
 72 |     it('starting with a usual one', async () => {
 73 |       await test([
 74 |         ...testsByron,
 75 |         ...testsShelleyUsual,
 76 |         ...testsColdKeys,
 77 |         ...testsCVoteKeys,
 78 |       ])
 79 |     })
 80 | 
 81 |     it('starting with an unusual one', async () => {
 82 |       await test([
 83 |         ...testsShelleyUnusual,
 84 |         ...testsByron,
 85 |         ...testsColdKeys,
 86 |         ...testsShelleyUsual,
 87 |       ])
 88 |     })
 89 |   })
 90 | 
 91 |   describe('Should reject invalid paths', () => {
 92 |     it('path shorter than 3 indexes', async () => {
 93 |       const promise = ada.getExtendedPublicKey({path: str_to_path("44'/1815'")})
 94 |       await expect(promise).to.be.rejectedWith(
 95 |         DeviceStatusError,
 96 |         "Action rejected by Ledger's security policy",
 97 |       )
 98 |     })
 99 | 
100 |     it('path not matching cold key structure', async () => {
101 |       const promise = ada.getExtendedPublicKey({
102 |         path: str_to_path("1853'/1900'/0'/0/0"),
103 |       })
104 |       await expect(promise).to.be.rejectedWith(
105 |         DeviceStatusError,
106 |         "Action rejected by Ledger's security policy",
107 |       )
108 |     })
109 | 
110 |     // CIP36 voting
111 |     it('invalid vote key path 1', async () => {
112 |       const promise = ada.getExtendedPublicKey({
113 |         path: str_to_path("1694'/1815'/0'/1/0"),
114 |       })
115 |       await expect(promise).to.be.rejectedWith(
116 |         DeviceStatusError,
117 |         "Action rejected by Ledger's security policy",
118 |       )
119 |     })
120 |     it('invalid vote key path 2', async () => {
121 |       const promise = ada.getExtendedPublicKey({
122 |         path: str_to_path("1694'/1815'/17"),
123 |       })
124 |       await expect(promise).to.be.rejectedWith(
125 |         DeviceStatusError,
126 |         "Action rejected by Ledger's security policy",
127 |       )
128 |     })
129 |     it('invalid vote key path 3', async () => {
130 |       const promise = ada.getExtendedPublicKey({
131 |         path: str_to_path("1694'/1815'/0'/1"),
132 |       })
133 |       await expect(promise).to.be.rejectedWith(
134 |         DeviceStatusError,
135 |         "Action rejected by Ledger's security policy",
136 |       )
137 |     })
138 |   })
139 | })
140 | 


--------------------------------------------------------------------------------
/test/integration/getSerial.test.ts:
--------------------------------------------------------------------------------
 1 | import {expect} from 'chai'
 2 | 
 3 | import type Ada from '../../src/Ada'
 4 | import {getAda} from '../test_utils'
 5 | 
 6 | describe('getSerial', () => {
 7 |   let ada: Ada = {} as Ada
 8 | 
 9 |   beforeEach(async () => {
10 |     ada = await getAda()
11 |   })
12 | 
13 |   afterEach(async () => {
14 |     // eslint-disable-next-line @typescript-eslint/no-explicit-any
15 |     await (ada as any).t.close()
16 |   })
17 | 
18 |   it('Should correctly get the serial number of the device', async () => {
19 |     const response = await ada.getSerial()
20 |     expect(response.serialHex.length).to.equal(14)
21 |   })
22 | })
23 | 


--------------------------------------------------------------------------------
/test/integration/getVersion.test.ts:
--------------------------------------------------------------------------------
 1 | import {expect} from 'chai'
 2 | 
 3 | import type Ada from '../../src/Ada'
 4 | import {getAda} from '../test_utils'
 5 | 
 6 | describe('getVersion', () => {
 7 |   let ada: Ada = {} as Ada
 8 | 
 9 |   beforeEach(async () => {
10 |     ada = await getAda()
11 |   })
12 | 
13 |   afterEach(async () => {
14 |     // eslint-disable-next-line @typescript-eslint/no-explicit-any
15 |     await (ada as any).t.close()
16 |   })
17 | 
18 |   it('Should correctly get the semantic version of device', async () => {
19 |     const isAppXS = (await ada.getVersion()).version.flags.isAppXS
20 | 
21 |     const {version, compatibility} = await ada.getVersion()
22 | 
23 |     expect(version.major).to.equal(7)
24 |     expect(version.minor).to.equal(1)
25 | 
26 |     expect(version.flags.isDebug).to.equal(true)
27 | 
28 |     expect(compatibility).to.deep.equal({
29 |       isCompatible: true,
30 |       recommendedVersion: null,
31 |       supportsByronAddressDerivation: !isAppXS,
32 |       supportsMary: true,
33 |       supportsCatalystRegistration: true,
34 |       supportsCIP36: true,
35 |       supportsZeroTtl: true,
36 |       supportsPoolRegistrationAsOwner: !isAppXS,
37 |       supportsPoolRegistrationAsOperator: !isAppXS,
38 |       supportsPoolRetirement: !isAppXS,
39 |       supportsNativeScriptHashDerivation: !isAppXS,
40 |       supportsMultisigTransaction: true,
41 |       supportsMint: true,
42 |       supportsAlonzo: true,
43 |       supportsReqSignersInOrdinaryTx: true,
44 |       supportsBabbage: true,
45 |       supportsCIP36Vote: true,
46 |       supportsConway: true,
47 |       supportsMessageSigning: true,
48 |     })
49 |   })
50 | })
51 | 


--------------------------------------------------------------------------------
/test/integration/signCVote.test.ts:
--------------------------------------------------------------------------------
 1 | import chai, {expect} from 'chai'
 2 | import chaiAsPromised from 'chai-as-promised'
 3 | 
 4 | import type Ada from '../../src/Ada'
 5 | import {getAda} from '../test_utils'
 6 | import {tests} from './__fixtures__/signCVote'
 7 | chai.use(chaiAsPromised)
 8 | 
 9 | describe('signCIP36Vote', () => {
10 |   let ada: Ada = {} as Ada
11 | 
12 |   beforeEach(async () => {
13 |     ada = await getAda()
14 |   })
15 | 
16 |   afterEach(async () => {
17 |     // eslint-disable-next-line @typescript-eslint/no-explicit-any
18 |     await (ada as any).t.close()
19 |   })
20 | 
21 |   for (const {testName, cVote, expected} of tests) {
22 |     it(testName, async () => {
23 |       const response = await ada.signCIP36Vote(cVote)
24 | 
25 |       expect(response).to.deep.equal(expected)
26 |     })
27 |   }
28 | })
29 | 


--------------------------------------------------------------------------------
/test/integration/signMessage.test.ts:
--------------------------------------------------------------------------------
 1 | import chai, {expect} from 'chai'
 2 | import chaiAsPromised from 'chai-as-promised'
 3 | 
 4 | import type Ada from '../../src/Ada'
 5 | import {getAda} from '../test_utils'
 6 | import {tests} from './__fixtures__/signMessage'
 7 | chai.use(chaiAsPromised)
 8 | 
 9 | describe('signMessage', () => {
10 |   let ada: Ada = {} as Ada
11 | 
12 |   beforeEach(async () => {
13 |     ada = await getAda()
14 |   })
15 | 
16 |   afterEach(async () => {
17 |     // eslint-disable-next-line @typescript-eslint/no-explicit-any
18 |     await (ada as any).t.close()
19 |   })
20 | 
21 |   for (const {testName, signMessageData, expected} of tests) {
22 |     it(testName, async () => {
23 |       const promise = ada.signMessage(signMessageData)
24 | 
25 |       expect(await promise).to.deep.equal(expected)
26 |     })
27 |   }
28 | })
29 | 


--------------------------------------------------------------------------------
/test/integration/signOperationalCertificate.test.ts:
--------------------------------------------------------------------------------
 1 | import chai, {expect} from 'chai'
 2 | import chaiAsPromised from 'chai-as-promised'
 3 | 
 4 | import type Ada from '../../src/Ada'
 5 | import {getAda} from '../test_utils'
 6 | import {tests} from './__fixtures__/signOperationalCertificate'
 7 | import {DeviceVersionUnsupported} from '../../src/Ada'
 8 | chai.use(chaiAsPromised)
 9 | 
10 | describe('signOperationalCertificate', () => {
11 |   let ada: Ada = {} as Ada
12 | 
13 |   beforeEach(async () => {
14 |     ada = await getAda()
15 |   })
16 | 
17 |   afterEach(async () => {
18 |     // eslint-disable-next-line @typescript-eslint/no-explicit-any
19 |     await (ada as any).t.close()
20 |   })
21 | 
22 |   for (const {testName, operationalCertificate, expected} of tests) {
23 |     it(testName, async () => {
24 |       const isAppXS = (await ada.getVersion()).version.flags.isAppXS
25 |       const promise = ada.signOperationalCertificate(operationalCertificate)
26 | 
27 |       if (isAppXS) {
28 |         await expect(promise).to.be.rejectedWith(DeviceVersionUnsupported)
29 |       } else {
30 |         expect(await promise).to.deep.equal(expected)
31 |       }
32 |     })
33 |   }
34 | })
35 | 


--------------------------------------------------------------------------------
/test/integration/signTx.test.ts:
--------------------------------------------------------------------------------
 1 | import {describeSignTxPositiveTest, describeSignTxRejects} from '../test_utils'
 2 | import {
 3 |   testsAllegra,
 4 |   testsAlonzoTrezorComparison,
 5 |   testsBabbageTrezorComparison,
 6 |   testsByron,
 7 |   testsConwayVotingProcedures,
 8 |   testsConwayWithCertificates,
 9 |   testsConwayWithoutCertificates,
10 |   testsMary,
11 |   testsMultidelegation,
12 |   testsMultisig,
13 |   testsShelleyNoCertificates,
14 |   testsShelleyWithCertificates,
15 | } from './__fixtures__/signTx'
16 | import {testsAlonzo, testsBabbage} from './__fixtures__/signTxPlutus'
17 | import {
18 |   addressParamsRejectTestCases,
19 |   certificateRejectTestCases,
20 |   certificateStakePoolRetirementRejectTestCases,
21 |   certificateStakingRejectTestCases,
22 |   collateralOutputRejectTestCases,
23 |   singleAccountRejectTestCases,
24 |   testsInvalidTokenBundleOrdering,
25 |   transactionInitRejectTestCases,
26 |   withdrawalRejectTestCases,
27 |   witnessRejectTestCases,
28 | } from './__fixtures__/signTxRejects'
29 | 
30 | describeSignTxPositiveTest('signTxAlonzo', testsAlonzo)
31 | describeSignTxPositiveTest('signTxBabbage', testsBabbage)
32 | describeSignTxPositiveTest('signTxByron', testsByron)
33 | describeSignTxPositiveTest(
34 |   'signTxShelleyNoCertificates',
35 |   testsShelleyNoCertificates,
36 | )
37 | describeSignTxPositiveTest(
38 |   'signTxShelleyWithCertificates',
39 |   testsShelleyWithCertificates,
40 | )
41 | describeSignTxPositiveTest(
42 |   'signTxConwayWithoutCertificates',
43 |   testsConwayWithoutCertificates,
44 | )
45 | describeSignTxPositiveTest(
46 |   'signTxConwayWithCertificates',
47 |   testsConwayWithCertificates,
48 | )
49 | describeSignTxPositiveTest(
50 |   'signTxConwayVotingProcedures',
51 |   testsConwayVotingProcedures,
52 | )
53 | describeSignTxPositiveTest('signTxMultisig', testsMultisig)
54 | describeSignTxPositiveTest('signTxAllegra', testsAllegra)
55 | describeSignTxPositiveTest('signTxMary', testsMary)
56 | describeSignTxPositiveTest(
57 |   'signTxTrezorComparison',
58 |   testsAlonzoTrezorComparison,
59 | )
60 | describeSignTxPositiveTest(
61 |   'signTxBabbageTrezorComparison',
62 |   testsBabbageTrezorComparison,
63 | )
64 | describeSignTxPositiveTest('signTxMultidelegation', testsMultidelegation)
65 | 
66 | describeSignTxRejects('signTxInitPolicyRejects', transactionInitRejectTestCases)
67 | describeSignTxRejects(
68 |   'signTxAddressParamsPolicyRejects',
69 |   addressParamsRejectTestCases,
70 | )
71 | describeSignTxRejects(
72 |   'signTxCertificatePolicyRejects',
73 |   certificateRejectTestCases,
74 | )
75 | describeSignTxRejects(
76 |   'signTxCertificateStakingPolicyRejects',
77 |   certificateStakingRejectTestCases,
78 | )
79 | describeSignTxRejects(
80 |   'signTxCertificateStakePoolRetirementPolicyRejects',
81 |   certificateStakePoolRetirementRejectTestCases,
82 | )
83 | describeSignTxRejects('signTxWithdrawalRejects', withdrawalRejectTestCases)
84 | describeSignTxRejects('signTxWitnessRejects', witnessRejectTestCases)
85 | describeSignTxRejects(
86 |   'signTxInvalidMultiassetRejects',
87 |   testsInvalidTokenBundleOrdering,
88 | )
89 | describeSignTxRejects(
90 |   'signTxSingleAccountRejects',
91 |   singleAccountRejectTestCases,
92 | )
93 | describeSignTxRejects(
94 |   'signTxCollateralOutputRejects',
95 |   collateralOutputRejectTestCases,
96 | )
97 | 


--------------------------------------------------------------------------------
/test/integration/signTxCVote.test.ts:
--------------------------------------------------------------------------------
 1 | import {describeSignTxPositiveTest, describeSignTxRejects} from '../test_utils'
 2 | import {
 3 |   testsCatalystRegistration,
 4 |   testsCVoteRegistrationCIP36,
 5 |   testsCVoteRegistrationRejects,
 6 | } from './__fixtures__/signTxCVote'
 7 | 
 8 | describeSignTxPositiveTest('signTxCatalyst', testsCatalystRegistration)
 9 | describeSignTxPositiveTest(
10 |   'signTxCVoteRegistrationCIP36',
11 |   testsCVoteRegistrationCIP36,
12 | )
13 | 
14 | describeSignTxRejects(
15 |   'testsCVoteRegistrationRejects',
16 |   testsCVoteRegistrationRejects,
17 | )
18 | 


--------------------------------------------------------------------------------
/test/integration/signTxPoolRegistration.test.ts:
--------------------------------------------------------------------------------
 1 | import chai from 'chai'
 2 | import chaiAsPromised from 'chai-as-promised'
 3 | 
 4 | import {describeSignTxPositiveTest, describeSignTxRejects} from '../test_utils'
 5 | import {
 6 |   poolRegistrationOperatorTestCases,
 7 |   poolRegistrationOwnerTestCases,
 8 | } from './__fixtures__/signTxPoolRegistration'
 9 | import {
10 |   invalidCertificates,
11 |   invalidPoolMetadataTestCases,
12 |   invalidRelayTestCases,
13 |   outputRejectTestCases,
14 |   poolRegistrationOwnerRejectTestCases,
15 |   stakePoolRegistrationOwnerRejectTestCases,
16 |   stakePoolRegistrationPoolIdRejectTestCases,
17 | } from './__fixtures__/signTxPoolRegistrationRejects'
18 | chai.use(chaiAsPromised)
19 | 
20 | describeSignTxPositiveTest(
21 |   'signTxPoolRegistrationOK_Owner',
22 |   poolRegistrationOwnerTestCases,
23 | )
24 | describeSignTxPositiveTest(
25 |   'signTxPoolRegistrationOK_Operator',
26 |   poolRegistrationOperatorTestCases,
27 | )
28 | 
29 | describeSignTxRejects(
30 |   'signTxPoolRegistrationRejects_Owner_General',
31 |   poolRegistrationOwnerRejectTestCases,
32 | )
33 | describeSignTxRejects(
34 |   'signTxPoolRegistrationRejects_Outputs',
35 |   outputRejectTestCases,
36 | )
37 | describeSignTxRejects(
38 |   'signTxPoolRegistrationRejects_Owner_Certificates',
39 |   invalidCertificates,
40 | )
41 | describeSignTxRejects(
42 |   'signTxPoolRegistrationRejects_Owner_Metadata',
43 |   invalidPoolMetadataTestCases,
44 | )
45 | describeSignTxRejects(
46 |   'signTxPoolRegistrationRejects_Owner_Relay',
47 |   invalidRelayTestCases,
48 | )
49 | describeSignTxRejects(
50 |   'signTxPoolRegistrationRejects_PoolId',
51 |   stakePoolRegistrationPoolIdRejectTestCases,
52 | )
53 | describeSignTxRejects(
54 |   'signTxPoolRegistrationRejects_Owner_Security',
55 |   stakePoolRegistrationOwnerRejectTestCases,
56 | )
57 | 


--------------------------------------------------------------------------------
/test/test_utils.ts:
--------------------------------------------------------------------------------
  1 | import TransportNodeHid from '@ledgerhq/hw-transport-node-hid'
  2 | import SpeculosTransport from '@ledgerhq/hw-transport-node-speculos'
  3 | import * as blake2 from 'blake2'
  4 | import {expect} from 'chai'
  5 | import {ImportMock} from 'ts-mock-imports'
  6 | import type {FixLenHexString} from 'types/internal'
  7 | 
  8 | import {Ada, utils} from '../src/Ada'
  9 | import {DeviceVersionUnsupported, InvalidDataReason} from '../src/errors/index'
 10 | import * as parseModule from '../src/utils/parse'
 11 | 
 12 | export function shouldUseSpeculos(): boolean {
 13 |   return process.env.LEDGER_TRANSPORT === 'speculos'
 14 | }
 15 | 
 16 | export function getTransport() {
 17 |   return shouldUseSpeculos()
 18 |     ? SpeculosTransport.open({apduPort: 9999})
 19 |     : TransportNodeHid.create(1000)
 20 | }
 21 | 
 22 | export async function getAda() {
 23 |   const transport = await getTransport()
 24 | 
 25 |   const ada = new Ada(transport)
 26 |   // eslint-disable-next-line @typescript-eslint/no-explicit-any
 27 |   ;(ada as any).t = transport
 28 |   return Promise.resolve(ada)
 29 | }
 30 | 
 31 | export function turnOffValidation() {
 32 |   const validate_mock = ImportMock.mockFunction(parseModule, 'validate')
 33 | 
 34 |   const fns = [
 35 |     'isString',
 36 |     'isInteger',
 37 |     'isArray',
 38 |     'isBuffer',
 39 |     'isHexString',
 40 |     'isHexStringOfLength',
 41 |     'isValidPath',
 42 |   ]
 43 |   // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 44 |   /* @ts-ignore */
 45 |   const mocks = fns.map((fn) => ImportMock.mockFunction(parseModule, fn, true))
 46 | 
 47 |   return () => {
 48 |     validate_mock.restore()
 49 |     mocks.forEach((mock) => mock.restore())
 50 |   }
 51 | }
 52 | 
 53 | export function describeWithoutValidation(title: string, test: () => void) {
 54 |   describe(title, () => {
 55 |     let restoreValidation: () => void
 56 | 
 57 |     before(() => {
 58 |       restoreValidation = turnOffValidation()
 59 |     })
 60 | 
 61 |     after(() => {
 62 |       restoreValidation()
 63 |     })
 64 | 
 65 |     test()
 66 |   })
 67 | }
 68 | 
 69 | const ProtocolMagics = {
 70 |   MAINNET: 764824073,
 71 |   TESTNET: 42, // used in our integration tests
 72 |   TESTNET_LEGACY: 1097911063,
 73 |   TESTNET_PREPROD: 1,
 74 |   TESTNET_PREVIEW: 2,
 75 | }
 76 | 
 77 | const NetworkIds = {
 78 |   TESTNET: 0x00,
 79 |   MAINNET: 0x01,
 80 | }
 81 | 
 82 | export const Networks = {
 83 |   Mainnet: {
 84 |     networkId: NetworkIds.MAINNET,
 85 |     protocolMagic: ProtocolMagics.MAINNET,
 86 |   },
 87 |   Testnet: {
 88 |     networkId: NetworkIds.TESTNET,
 89 |     protocolMagic: ProtocolMagics.TESTNET,
 90 |   },
 91 |   Fake: {
 92 |     networkId: 0x03,
 93 |     protocolMagic: 47,
 94 |   },
 95 | }
 96 | 
 97 | type TxHash = FixLenHexString<32>
 98 | 
 99 | function hashTxBody(txBodyHex: string): TxHash {
100 |   const b2 = blake2.createHash('blake2b', {digestLength: 32})
101 |   b2.update(Buffer.from(txBodyHex, 'hex'))
102 |   return parseModule.parseHexStringOfLength(
103 |     b2.digest('hex'),
104 |     32,
105 |     InvalidDataReason.INVALID_B2_HASH,
106 |   )
107 | }
108 | 
109 | export function bech32_to_hex(str: string): string {
110 |   return utils.buf_to_hex(utils.bech32_decodeAddress(str))
111 | }
112 | 
113 | export const DoNotRunOnLedger = 'DO NOT RUN ON LEDGER'
114 | 
115 | // eslint-disable-next-line @typescript-eslint/no-explicit-any
116 | export function describeSignTxRejects(name: string, testList: any[]) {
117 |   describe(`${name}_JS`, () => {
118 |     let ada: Ada = {} as Ada
119 | 
120 |     beforeEach(async () => {
121 |       ada = await getAda()
122 |     })
123 | 
124 |     afterEach(async () => {
125 |       // eslint-disable-next-line @typescript-eslint/no-explicit-any
126 |       await (ada as any).t.close()
127 |     })
128 | 
129 |     for (const {
130 |       testName,
131 |       tx,
132 |       additionalWitnessPaths,
133 |       signingMode,
134 |       rejectReason,
135 |     } of testList) {
136 |       it(`${testName} [${signingMode}]`, async () => {
137 |         if (rejectReason === InvalidDataReason.LEDGER_POLICY) {
138 |           return
139 |         }
140 |         if (
141 |           rejectReason === InvalidDataReason.INVALID_DATA_SUPPLIED_TO_LEDGER
142 |         ) {
143 |           return
144 |         }
145 |         const response = ada.signTransaction({
146 |           tx,
147 |           signingMode,
148 |           additionalWitnessPaths: additionalWitnessPaths || [],
149 |         })
150 | 
151 |         await expect(response).to.be.rejectedWith(rejectReason)
152 |       })
153 |     }
154 |   })
155 | 
156 |   describeWithoutValidation(`${name}_Ledger`, () => {
157 |     let ada: Ada = {} as Ada
158 | 
159 |     beforeEach(async () => {
160 |       ada = await getAda()
161 |     })
162 | 
163 |     afterEach(async () => {
164 |       // eslint-disable-next-line @typescript-eslint/no-explicit-any
165 |       await (ada as any).t.close()
166 |     })
167 | 
168 |     for (const {
169 |       testName,
170 |       tx,
171 |       additionalWitnessPaths,
172 |       signingMode,
173 |       errCls,
174 |       errMsg,
175 |       unsupportedInAppXS,
176 |     } of testList) {
177 |       it(`${testName} [${signingMode}]`, async () => {
178 |         if (errMsg === DoNotRunOnLedger) {
179 |           return
180 |         }
181 |         const isAppXS = (await ada.getVersion()).version.flags.isAppXS
182 |         const response = ada.signTransaction({
183 |           tx,
184 |           signingMode,
185 |           additionalWitnessPaths: additionalWitnessPaths || [],
186 |         })
187 | 
188 |         // Certain tests contain test data that cannot be properly serialized,
189 |         // as manifested by `TypeError`s.
190 |         // We do not expect DeviceVersionUnsupported in that case for XS app.
191 |         const hasTypeError = errCls === TypeError
192 |         const correctlyDetectsUnsupportedInAppXS =
193 |           isAppXS && unsupportedInAppXS && !hasTypeError
194 | 
195 |         if (correctlyDetectsUnsupportedInAppXS) {
196 |           await expect(response).to.be.rejectedWith(DeviceVersionUnsupported)
197 |         } else {
198 |           await expect(response).to.be.rejectedWith(errCls, errMsg)
199 |         }
200 |       })
201 |     }
202 |   })
203 | }
204 | 
205 | // eslint-disable-next-line @typescript-eslint/no-explicit-any
206 | export function describeSignTxPositiveTest(name: string, tests: any[]) {
207 |   describe(name, () => {
208 |     let ada: Ada = {} as Ada
209 | 
210 |     beforeEach(async () => {
211 |       ada = await getAda()
212 |     })
213 | 
214 |     afterEach(async () => {
215 |       // eslint-disable-next-line @typescript-eslint/no-explicit-any
216 |       await (ada as any).t.close()
217 |     })
218 | 
219 |     for (const {
220 |       testName,
221 |       tx,
222 |       signingMode,
223 |       additionalWitnessPaths,
224 |       options,
225 |       txBody,
226 |       expectedResult,
227 |       unsupportedInAppXS,
228 |     } of tests) {
229 |       it(`${testName} [${signingMode}]`, async () => {
230 |         if (!txBody) {
231 |           // eslint-disable-next-line no-console
232 |           console.log(`WARNING --- No tx body given: ${testName}`)
233 |         } else if (hashTxBody(txBody) !== expectedResult.txHashHex) {
234 |           // eslint-disable-next-line no-console
235 |           console.log(`WARNING --- Tx body hash mismatch: ${testName}`)
236 |         }
237 |         const isAppXS = (await ada.getVersion()).version.flags.isAppXS
238 |         const response = ada.signTransaction({
239 |           tx,
240 |           signingMode,
241 |           additionalWitnessPaths,
242 |           options,
243 |         })
244 | 
245 |         if (isAppXS && unsupportedInAppXS) {
246 |           await expect(response).to.be.rejectedWith(DeviceVersionUnsupported)
247 |         } else {
248 |           expect(await response).to.deep.equal(expectedResult)
249 |         }
250 |       })
251 |     }
252 |   })
253 | }
254 | 


--------------------------------------------------------------------------------
/test/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 |   "extends": "../tsconfig.base",
3 |   "compilerOptions": {
4 |     "lib": ["es2019"],
5 |     "outDir": "lib"
6 |   },
7 |   "include": ["./**/*.ts", "../src/**/*.ts"]
8 | }
9 | 


--------------------------------------------------------------------------------
/test/unit/parse.test.ts:
--------------------------------------------------------------------------------
 1 | import {expect} from 'chai'
 2 | import {Int64BE, Uint64BE} from 'int64-buffer'
 3 | 
 4 | import {InvalidDataReason} from '../../src/errors'
 5 | import {assert} from '../../src/utils/assert'
 6 | import {parseInt64_str, parseUint64_str} from '../../src/utils/parse'
 7 | 
 8 | type BasicParseTest = {
 9 |   signed: boolean
10 |   numberString: string
11 | }
12 | 
13 | const basicParseTests: BasicParseTest[] = [
14 |   {
15 |     signed: true,
16 |     numberString: '-123456',
17 |   },
18 |   {
19 |     signed: true,
20 |     numberString: '9223372036854775807',
21 |   },
22 |   {
23 |     signed: true,
24 |     numberString: '0',
25 |   },
26 |   {
27 |     signed: true,
28 |     numberString: '-9223372036854775808',
29 |   },
30 |   {
31 |     signed: false,
32 |     numberString: '0',
33 |   },
34 |   {
35 |     signed: false,
36 |     numberString: '9223372036854775807',
37 |   },
38 |   {
39 |     signed: false,
40 |     numberString: '18446744073709551615',
41 |   },
42 | ]
43 | 
44 | describe('basicParseTest', () => {
45 |   for (const {signed, numberString} of basicParseTests) {
46 |     // eslint-disable-next-line no-console
47 |     console.log(`parsing ${numberString} (${signed ? 'signed' : 'unsigned'})`)
48 |     const objectRepresentation = signed
49 |       ? new Int64BE(numberString, 10)
50 |       : new Uint64BE(numberString, 10)
51 |     const bufferRep = objectRepresentation.toBuffer()
52 | 
53 |     assert(bufferRep.length === 8, 'invalid binary length')
54 | 
55 |     expect(objectRepresentation.toString()).to.equal(numberString)
56 |   }
57 | })
58 | 
59 | describe('advancedParseTest', () => {
60 |   it('parse int64 correctly', () => {
61 |     const nmb = '1235543'
62 |     const result = parseInt64_str(
63 |       nmb,
64 |       {},
65 |       InvalidDataReason.INPUT_INVALID_TX_HASH,
66 |     )
67 |     expect(result).to.equal('1235543')
68 |   })
69 | 
70 |   it('parse negative int64 correctly', () => {
71 |     const nmb = '-123456'
72 |     const result = parseInt64_str(
73 |       nmb,
74 |       {},
75 |       InvalidDataReason.INPUT_INVALID_TX_HASH,
76 |     )
77 |     expect(result).to.equal('-123456')
78 |   })
79 | 
80 |   it('throw error when trying to parse negative number as Uint', () => {
81 |     const nmb = '-123456'
82 |     // let result = parseUint64_str(nmb, {}, InvalidDataReason.INPUT_INVALID_TX_HASH)
83 |     expect(() =>
84 |       parseUint64_str(nmb, {}, InvalidDataReason.INPUT_INVALID_TX_HASH),
85 |     ).to.throw(InvalidDataReason.INPUT_INVALID_TX_HASH)
86 |   })
87 | })
88 | 


--------------------------------------------------------------------------------
/tsconfig.base.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "allowJs": false,
 4 |     "allowSyntheticDefaultImports": true,
 5 |     "alwaysStrict": true,
 6 |     "declaration": true,
 7 |     "declarationMap": true,
 8 |     "esModuleInterop": true,
 9 |     "experimentalDecorators": true,
10 |     "inlineSourceMap": true,
11 |     "lib": ["es2019"],
12 |     "module": "commonjs",
13 |     "noImplicitAny": true,
14 |     "noImplicitThis": true,
15 |     "noUnusedLocals": false,
16 |     "outDir": "dist",
17 |     "pretty": true,
18 |     "removeComments": false,
19 |     "resolveJsonModule": true,
20 |     "skipLibCheck": true,
21 |     "strict": true,
22 |     "strictFunctionTypes": true,
23 |     "strictNullChecks": true,
24 |     "target": "ES2016",
25 |     "typeRoots": ["./node_modules/@types", "./types"],
26 |     "noErrorTruncation": true,
27 |     "baseUrl": "src"
28 |   }
29 | }
30 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 |   "extends": "./tsconfig.base",
3 |   "include": ["./**/*.ts"]
4 | }
5 | 


--------------------------------------------------------------------------------
/typedoc.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "entryPoints": ["src/Ada.ts"],
 3 |   "out": "docs_generated",
 4 |   "categorizeByGroup": false,
 5 |   "categoryOrder": [
 6 |     "Main",
 7 |     "API request/response",
 8 |     "Basic types",
 9 |     "Addresses",
10 |     "Shelley",
11 |     "Mary",
12 |     "Pool registration",
13 |     "*"
14 |   ],
15 |   "sort": "source-order",
16 |   "readme": "none",
17 |   "includeVersion": "true"
18 | }
19 | 


--------------------------------------------------------------------------------
/workspace.code-workspace:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"folders": [
 3 | 		{
 4 | 			"path": "."
 5 | 		}
 6 | 	],
 7 | 	"settings": {
 8 | 		"editor.formatOnSave": true,
 9 | 		"typescript.tsdk": "node_modules/typescript/lib"
10 | 	}
11 | }


--------------------------------------------------------------------------------