.gitlab-ci.yml

@@ -119,6 +119,31 @@ wax_wasm_build_tests:
   tags:
     - public-runner-docker
 
+build_wax_extensions:
+  stage: build
+  extends: .npm_process_built_package_tarball
+  variables:
+    GIT_SUBMODULE_STRATEGY: recursive
+    SOURCE_DIR: "${CI_PROJECT_DIR}/ts"
+    DIST_DIR: "$CI_PROJECT_DIR/ts/wasm/dist"
+    PACKAGE_TGZ_PATH: "${BUILT_PACKAGE_PATH}"
+
+  script:
+    - cd "${SOURCE_DIR}/packages"
+    - pnpm install --frozen-lockfile
+    - pnpm run build
+
+  needs:
+    - job: wax_wasm_proto_tsc_generation
+      artifacts: true
+
+  artifacts:
+    paths:
+      - "${SOURCE_DIR}/packages/*/dist"
+
+    when: always
+    expire_in: 1 week
+
 generate_docs:
   stage: build
   extends: .npm_based_job_base
@@ -321,6 +346,33 @@ deploy_wax_wasm_dev_package:
   tags:
     - public-runner-docker
 
+deploy_wax_wasm_dev_extension_packages:
+  extends: .npm_process_built_package_tarball
+  stage: deploy
+  variables:
+    SOURCE_DIR: "${CI_PROJECT_DIR}/ts"
+    PACKAGE_TGZ_PATH: "${BUILT_PACKAGE_PATH}"
+    DIST_DIR: "${SOURCE_DIR}/dist"
+    GIT_SUBMODULE_STRATEGY: "normal"
+    NPM_PACKAGE_SCOPE: "@hiveio"
+    NPM_REGISTRY_URL: "gitlab.syncad.com/api/v4/projects/${CI_PROJECT_ID}/packages/npm/"
+    NPM_PUBLISH_TOKEN: "${CI_JOB_TOKEN}"
+
+  script:
+    - cd "${SOURCE_DIR}/packages"
+    - echo "//${NPM_REGISTRY_URL}:_authToken=\"${NPM_PUBLISH_TOKEN}\"" > "${SOURCE_DIR}/packages/.npmrc"
+    - echo "${NPM_PACKAGE_SCOPE}:registry=https://${NPM_REGISTRY_URL}" >> "${SOURCE_DIR}/packages/.npmrc"
+    - pnpm publish --no-git-checks --access public -r --tag $(jq -r '.publishConfig.tag' "${SOURCE_DIR}/package.json")
+
+  needs:
+    - job: deploy_wax_wasm_dev_package
+    - job: wax_wasm_proto_tsc_generation
+      artifacts: true
+    - job: build_wax_extensions
+      artifacts: true
+  tags:
+    - public-runner-docker
+
 deploy_wax_wasm_production_public_npm:
   extends: .registry_npmjs_org_deploy_package_template
   stage: deploy

core/binary_view_helper.cpp

@@ -288,7 +288,7 @@ uint32_t static_variant_visitor::operator()( const T& v ) const
   return binary_view_visitor< T >::get_size( v );
 }
 
-binary_data generate_binary_transaction_metadata( const hive::protocol::signed_transaction& tx, bool use_hf26_serialization )
+binary_data generate_binary_transaction_metadata( const hive::protocol::signed_transaction& tx, bool use_hf26_serialization /*=true*/, bool strip_to_unsigned_transaction /*= false*/ )
 {
   const auto serialization_type = use_hf26_serialization ? hive::protocol::transaction_serialization_type::hf26 : hive::protocol::transaction_serialization_type::legacy;
 
@@ -296,7 +296,7 @@ binary_data generate_binary_transaction_metadata( const hive::protocol::signed_t
   hive::protocol::serialization_mode_controller::set_pack( serialization_type );
 
   binary_data result;
-  result.binary = serialize_transaction( tx, use_hf26_serialization );
+  result.binary = serialize_transaction( tx, use_hf26_serialization, strip_to_unsigned_transaction );
 
   std::vector< binary_data_node > nodes;
 
@@ -332,13 +332,19 @@ binary_data generate_binary_operation_metadata( const hive::protocol::operation&
   return result;
 }
 
-std::string serialize_transaction( const hive::protocol::signed_transaction& tx, bool use_hf26_serialization )
+std::string serialize_transaction( const hive::protocol::signed_transaction& tx, bool use_hf26_serialization /*=true*/, bool strip_to_unsigned_transaction /*=false*/ )
 {
   const auto serialization_type = use_hf26_serialization ? hive::protocol::transaction_serialization_type::hf26 : hive::protocol::transaction_serialization_type::legacy;
 
   hive::protocol::serialization_mode_controller::mode_guard guard( serialization_type );
   hive::protocol::serialization_mode_controller::set_pack( serialization_type );
 
-  return fc::to_hex( fc::raw::pack_to_vector( tx ) );
+  std::vector<char> binForm;
+  if(strip_to_unsigned_transaction)
+    binForm = fc::raw::pack_to_vector( static_cast<const hive::protocol::transaction&>(tx) );
+  else
+    binForm = fc::raw::pack_to_vector( tx );
+
+  return fc::to_hex( binForm );
 }
 } // namespace cpp

core/binary_view_helper.hpp

@@ -6,8 +6,8 @@
 #include <string>
 
 namespace cpp {
-binary_data generate_binary_transaction_metadata( const hive::protocol::signed_transaction& tx, bool use_hf26_serialization = true );
+binary_data generate_binary_transaction_metadata( const hive::protocol::signed_transaction& tx, bool use_hf26_serialization = true, bool strip_to_unsigned_transaction = false );
 binary_data generate_binary_operation_metadata( const hive::protocol::operation& op, bool use_hf26_serialization = true );
 
-std::string serialize_transaction( const hive::protocol::signed_transaction& tx, bool use_hf26_serialization = true );
+std::string serialize_transaction( const hive::protocol::signed_transaction& tx, bool use_hf26_serialization = true, bool strip_to_unsigned_transaction = false );
 } // namespace cpp

core/foundation.cpp

@@ -269,6 +269,38 @@ private_key_data foundation::cpp_generate_private_key(const std::string& account
   );
 }
 
+std::string foundation::cpp_convert_raw_private_key_to_wif(const std::string& hexData)
+{
+  FC_ASSERT(hexData.size() == 64 && "Expected hex string pointing 32 byte buffer");
+
+  fc::sha256 sharedSecret(hexData);
+
+  return fc::ecc::private_key::regenerate(sharedSecret).key_to_wif();
+}
+
+std::string foundation::cpp_convert_raw_public_key_to_wif(const std::string& hexData)
+{
+  if(hexData.size() == 2 * sizeof(fc::ecc::public_key_data))
+  {
+    /// compressed form
+    fc::ecc::public_key_data keyData;
+    detail::convert_from_hex(hexData, keyData);
+
+    return fc::ecc::public_key::to_base58_with_prefix(keyData, HIVE_ADDRESS_PREFIX);
+
+  }
+  else
+  {
+    FC_ASSERT(hexData.size() == 2 * sizeof(fc::ecc::public_key_point_data), "Invalid size of raw public key buffer: ${s}", ("s", (hexData.size())));
+    /// uncompressed form
+    fc::ecc::public_key_point_data keyData;
+    detail::convert_from_hex(hexData, keyData);
+
+    fc::ecc::public_key key(keyData);
+    return key.to_base58_with_prefix(HIVE_ADDRESS_PREFIX);
+  }
+}
+
 brain_key_data foundation::cpp_suggest_brain_key()
 {
   return cpp::safe_exception_wrapper(

core/foundation.hpp

@@ -15,8 +15,16 @@ public:
 
   result cpp_calculate_public_key(const std::string& wif);
   result cpp_generate_private_key();
-
   private_key_data cpp_generate_private_key(const std::string& account, const std::string& role, const std::string& password);
+  /** Allows to convert 32 bytes data buffer expressed as hex string (pointing private key secret) into private key encoded as WIF format.
+  */
+  std::string cpp_convert_raw_private_key_to_wif(const std::string& hexData);
+
+  /** Allows to convert raw public key form (expressed as hex string) into Hive WIF format (with prefix).
+  *   \param hexData - depending on length compressed or uncompressed key format is chosen
+  */
+  std::string cpp_convert_raw_public_key_to_wif(const std::string& hexData);
+
   brain_key_data cpp_suggest_brain_key();
 
   /** Returns map of hive::protocol constants in form:

core/protobuf_protocol_impl.hpp

@@ -19,7 +19,7 @@ public:
   std::vector<std::string> cpp_operation_get_impacted_accounts(const std::string& operation) const;
   std::vector<std::string> cpp_transaction_get_impacted_accounts(const std::string& transaction) const;
 
-  binary_data cpp_generate_binary_transaction_metadata(const std::string& transaction, bool use_hf26_serialization)const;
+  binary_data cpp_generate_binary_transaction_metadata(const std::string& transaction, bool use_hf26_serialization, bool strip_to_unsigned_transaction)const;
   binary_data cpp_generate_binary_operation_metadata(const std::string& operation, bool use_hf26_serialization)const;
 
   result cpp_validate_operation(const std::string& operation);
@@ -28,7 +28,7 @@ public:
   result cpp_calculate_legacy_transaction_id(const std::string& transaction);
   result cpp_calculate_sig_digest(const std::string& transaction, const std::string& chain_id);
   result cpp_calculate_legacy_sig_digest(const std::string& transaction, const std::string& chain_id);
-  result cpp_serialize_transaction(const std::string& transaction);
+  result cpp_serialize_transaction(const std::string& transaction, bool strip_to_unsigned_transaction);
   result cpp_deserialize_transaction(const std::string& transaction);
   required_authority_collection_t cpp_collect_transaction_required_authorities(const std::string& transaction);
 

core/protobuf_protocol_impl.inl

@@ -480,13 +480,14 @@ std::vector<std::string> proto_protocol_impl<FoundationProvider>::cpp_transactio
 }
 
 template <class FoundationProvider>
-binary_data proto_protocol_impl<FoundationProvider>::cpp_generate_binary_transaction_metadata(const std::string& transaction, bool use_hf26_serialization) const
+binary_data proto_protocol_impl<FoundationProvider>::cpp_generate_binary_transaction_metadata(const std::string& transaction, bool use_hf26_serialization, bool strip_to_unsigned_transaction) const
 {
   protocol_impl<FoundationProvider> provider;
 
   return provider.cpp_generate_binary_transaction_metadata(
     cpp_proto_to_api_impl(transaction),
-    use_hf26_serialization
+    use_hf26_serialization,
+    strip_to_unsigned_transaction
   );
 }
 
@@ -585,13 +586,14 @@ typename proto_protocol_impl<FoundationProvider>::required_authority_collection_
 }
 
 template <class FoundationProvider>
-result proto_protocol_impl<FoundationProvider>::cpp_serialize_transaction(const std::string& transaction)
+result proto_protocol_impl<FoundationProvider>::cpp_serialize_transaction(const std::string& transaction, bool strip_to_unsigned_transaction)
 {
   return method_wrapper([&](result& _result)
     {
       protocol_impl<FoundationProvider> provider;
       _result = provider.cpp_serialize_transaction(
-        cpp_proto_to_api_impl(transaction)
+        cpp_proto_to_api_impl(transaction),
+        strip_to_unsigned_transaction
       );
     });
 }

core/protocol_impl.hpp

@@ -38,7 +38,7 @@ public:
   std::vector<std::string> cpp_operation_get_impacted_accounts(const std::string& operation) const;
   std::vector<std::string> cpp_transaction_get_impacted_accounts(const std::string& transaction) const;
 
-  binary_data cpp_generate_binary_transaction_metadata(const std::string& transaction, bool use_hf26_serialization)const;
+  binary_data cpp_generate_binary_transaction_metadata(const std::string& transaction, bool use_hf26_serialization, bool strip_to_unsigned_transaction)const;
   binary_data cpp_generate_binary_operation_metadata(const std::string& operation, bool use_hf26_serialization)const;
 
   result cpp_validate_operation(const std::string& operation);
@@ -59,8 +59,11 @@ public:
 
   /** Allows to perform binary serialization of specified transaction.
   *   Uses HF26 serialization form.
+  *
+  *  @param transaction - JSON form of transaction to serialize
+  *  @param strip_to_unsigned_transaction - if true, then only unsigned part of transaction will be serialized (signature container is always stripped)
   */
-  result cpp_serialize_transaction(const std::string& transaction);
+  result cpp_serialize_transaction(const std::string& transaction, bool strip_to_unsigned_transaction);
 
   /** Allows to restore a transaction object from HF26 binary serialization form.
   *   Returns a JSON form of deserialized transaction.

core/protocol_impl.inl

@@ -71,13 +71,13 @@ std::vector<std::string> protocol_impl<FoundationProvider>::cpp_transaction_get_
 
 template <class FoundationProvider>
 inline
-binary_data protocol_impl<FoundationProvider>::cpp_generate_binary_transaction_metadata(const std::string& transaction, bool use_hf26_serialization) const
+binary_data protocol_impl<FoundationProvider>::cpp_generate_binary_transaction_metadata(const std::string& transaction, bool use_hf26_serialization, bool strip_to_unsigned_transaction) const
 {
   fc::variant _v = fc::json::from_string(transaction, fc::json::format_validation_mode::full);
 
   hive::protocol::signed_transaction _transaction = _v.as<hive::protocol::signed_transaction>();
 
-  return cpp::generate_binary_transaction_metadata(_transaction, use_hf26_serialization);
+  return cpp::generate_binary_transaction_metadata(_transaction, use_hf26_serialization, strip_to_unsigned_transaction);
 }
 
 template <class FoundationProvider>
@@ -120,7 +120,8 @@ result protocol_impl<FoundationProvider>::cpp_calculate_transaction_id(const std
 {
   return method_wrapper([&](result& _result)
     {
-      _result.content = get_transaction(transaction).id(hive::protocol::transaction_serialization_type::hf26).str();
+      const auto txId = get_transaction(transaction).id(hive::protocol::transaction_serialization_type::hf26);
+      _result.content = txId.str();
     });
 }
 
@@ -162,13 +163,13 @@ result protocol_impl<FoundationProvider>::cpp_calculate_legacy_sig_digest(const
 
 template <class FoundationProvider>
 inline
-result protocol_impl<FoundationProvider>::cpp_serialize_transaction(const std::string& transaction)
+result protocol_impl<FoundationProvider>::cpp_serialize_transaction(const std::string& transaction, bool strip_to_unsigned_transaction)
 {
   return method_wrapper([&](result& _result)
     {
       const auto _transaction = get_transaction(transaction);
 
-      _result.content = serialize_transaction(_transaction);
+      _result.content = serialize_transaction(_transaction, true, strip_to_unsigned_transaction);
     });
 }
 

examples/ts/signature-extension/.npmrc

+# https://gitlab.syncad.com/hive group specification, offering aggregated package view: https://gitlab.syncad.com/groups/hive/-/packages
+@hiveio:registry=https://gitlab.syncad.com/api/v4/groups/136/-/packages/npm/

examples/ts/signature-extension/.parcelrc

+{
+  "extends": "@parcel/config-default",
+  "transformers": {
+    "*.{ts,tsx}": ["@parcel/transformer-typescript-tsc"]
+  }
+}
\ No newline at end of file

examples/ts/signature-extension/README.md

+# signature-extension
+
+> [!WARNING]
+> This example will not be ran automatically on the CI as it requires direct user action, e.g. OAuth 3rd party app Hive blockchain user authorization
+
+This example presents different ways of implementing 3rd party apps authorization using wax
+
+To test this example:
+
+1. Install keychain extension
+2. Import `guest4test` posting key to your wallet
+3. Install dependencies: `pnpm install`
+4. Run parcel: `pnpm test`
+5. Goto [http://localhost:1234](http://localhost:1234), sign the transaction and check logs

examples/ts/signature-extension/common-data.ts

+export const accountName = "guest4test";
+export const publicKey = "STM8XQJiRBND7q6Cu1kxyRgLVLU3y1B5iGFU5VAqSpaAK38YFGZP8";
+export const privateKey = process.env.PRIVATE_KEY as string;
+
+export const voteData = {
+  voter: accountName,
+  author: "c0ff33a",
+  permlink: "ewxhnjbj",
+  weight: 2200
+};

examples/ts/signature-extension/package.json

+{
+  "name": "signature-extension",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "test": "parcel test/index.html"
+  },
+  "dependencies": {
+    "@hiveio/wax": "file:../../../ts",
+    "@hiveio/wax-signers-keychain": "file:../../../ts/packages/signers-keychain",
+    "@hiveio/wax-signers-peakvault": "file:../../../ts/packages/signers-peakvault"
+  },
+  "devDependencies": {
+    "@parcel/config-default": "^2.13.3",
+    "@parcel/transformer-typescript-tsc": "^2.13.3",
+    "buffer": "^5.5.0||^6.0.0",
+    "parcel": "^2.13.3",
+    "process": "^0.11.10"
+  }
+}

examples/ts/signature-extension/test/index.html

+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+</head>
+<body>
+  <h1>Signing example</h1>
+  <h3>Remember to unlock Peak Vault before using it</h3>
+  <button onclick="useKeychain()">Use Keychain</button>
+  <button onclick="usePeakVault()">Use Peak Vault</button>
+  <pre><code id="tx-result"></code></pre>
+  <script type="module">
+    import { createHiveChain } from "@hiveio/wax";
+    import { accountName, publicKey, voteData } from "../common-data";
+    import KeychainProvider from "@hiveio/wax-signers-keychain";
+    import PeakVaultProvider from "@hiveio/wax-signers-peakvault";
+
+    const txResult = document.getElementById('tx-result');
+
+    (async()=> {
+      const keychainProvider = KeychainProvider.for(accountName, "posting");
+      const peakVaultProvider = PeakVaultProvider.for(accountName, "posting");
+
+      const chain = await createHiveChain();
+
+      const createTransaction = async () => {
+        txResult.textContent = 'Signing...';
+        const tx = await chain.createTransaction();
+        tx.pushOperation({
+          vote: voteData
+        });
+        console.log(tx.transaction);
+        console.log(`Sig digest: ${tx.sigDigest}`);
+        return tx;
+      };
+
+      const sign = async (provider) => {
+        try {
+          const tx = await createTransaction();
+          await tx.sign(provider);
+          const apiJson = tx.toApiJson();
+          console.log('Transaction:', apiJson);
+          console.log(`Keys match: ${tx.signatureKeys[0] === publicKey}`);
+          txResult.textContent = JSON.stringify(apiJson, null, 2);
+        } catch (error) {
+          console.error(error);
+          txResult.textContent = `Error: ${error.message}`;
+        }
+      };
+
+      window.useKeychain = () => void sign(keychainProvider);
+      window.usePeakVault = () => void sign(peakVaultProvider);
+    })();
+  </script>
+</body>
+</html>

examples/ts/signature-extension/tsconfig.json

+{
+  "extends": "../../../ts/tsconfig.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "baseUrl": ".",
+    "outDir": "dist"
+  },
+  "include": [
+    "."
+  ]
+}
\ No newline at end of file

python/cpp_python_bridge.pxd

@@ -144,7 +144,7 @@ cdef extern from "cpython_interface.hpp" namespace "cpp":
         result cpp_calculate_legacy_transaction_id( string transaction )
         result cpp_calculate_sig_digest( string transaction, string chain_id )
         result cpp_calculate_legacy_sig_digest( string transaction, string chain_id )
-        result cpp_serialize_transaction( string transaction )
+        result cpp_serialize_transaction( string transaction, bool strip_to_unsigned_transaction )
         result cpp_deserialize_transaction( string transaction )
         result cpp_calculate_public_key( string wif )
         result cpp_generate_private_key()
@@ -189,7 +189,7 @@ cdef extern from "cpython_interface.hpp" namespace "cpp":
         result cpp_calculate_legacy_transaction_id( string transaction )
         result cpp_calculate_sig_digest( string transaction, string chain_id )
         result cpp_calculate_legacy_sig_digest( string transaction, string chain_id )
-        result cpp_serialize_transaction( string transaction )
+        result cpp_serialize_transaction( string transaction, bool strip_to_unsigned_transaction )
         result cpp_deserialize_transaction( string transaction )
         result cpp_proto_to_api( string operation_or_tx )
         result cpp_proto_to_legacy_api( string operation_or_tx )

python/cpp_python_bridge.pyx

@@ -28,6 +28,7 @@ from .wax_result import (
     python_price,
     python_authority,
     python_authorities,
+    python_minimize_required_signatures_data,
 )
 
 def return_python_result(foo):
@@ -116,7 +117,7 @@ def get_public_key_from_signature(digest: bytes, signature: bytes) -> python_res
 @return_python_result
 def serialize_transaction(transaction: bytes) -> python_result:
     cdef protocol obj
-    response = obj.cpp_serialize_transaction(transaction)
+    response = obj.cpp_serialize_transaction(transaction, False)
     return response.value, response.content, response.exception_message
 
 @return_python_result
@@ -326,7 +327,7 @@ def calculate_proto_legacy_sig_digest(transaction: bytes, chain_id: bytes) -> py
 @return_python_result
 def serialize_proto_transaction(transaction: bytes) -> python_result:
   cdef proto_protocol obj
-  response = obj.cpp_serialize_transaction( transaction )
+  response = obj.cpp_serialize_transaction( transaction, False )
   return response.value, response.content, response.exception_message
 
 @return_python_result

python/tests/proto-protocol/test_proto_to_legacy_api.py

@@ -44,5 +44,5 @@ def test_op_proto_to_legacy_api():
         b'var.is_object()\n'
         b'cpp_proto_to_legacy_api requires JSON object as an argument\n'
         b'    {}\n'
-        b'    protobuf_protocol_impl.inl:625 operator()'
+        b'    protobuf_protocol_impl.inl:627 operator()'
     )

ts/README.md

@@ -187,54 +187,6 @@ const manaTime = await chain.calculateManabarFullRegenerationTimeForAccount("ini
 console.info(manaTime); // Date
 ```
 
-#### Extend API interface and call custom endpoints
-
-In this example we will extend the base Wax endpoints and create our classes with validators
-in order to use the [transaction_status_api.find_transaction](https://developers.hive.io/apidefinitions/#transaction_status_api.find_transaction) API:
-
-```ts
-import { IsHexadecimal, IsDateString, IsString } from 'class-validator';
-import { createHiveChain, TWaxExtended } from '@hiveio/wax';
-const chain = await createHiveChain();
-
-// https://developers.hive.io/apidefinitions/#transaction_status_api.find_transaction-parameter_json
-// Create a request class with validators that will require a valid input from the end user
-class FindTransactionRequest {
-  @IsHexadecimal()
-  public transaction_id!: string;
-
-  @IsDateString()
-  public expiration!: string;
-}
-
-// https://developers.hive.io/apidefinitions/#transaction_status_api.find_transaction-expected_response_json
-// Create a response class with validators that will require a valid output from the remote API
-class FindTransactionResponse {
-  @IsString()
-  public status!: 'unknown' | string;
-}
-
-// Create the proper API structure
-const ExtendedApi = {
-  transaction_status_api: { // API
-    find_transaction: { // Method
-      params: FindTransactionRequest, // params is our request
-      result: FindTransactionResponse // result is out response
-    }
-  }
-};
-
-const extended: TWaxExtended<typeof ExtendedApi> = chain.extend(ExtendedApi);
-
-// Call the transaction_status_api API using our extended interface
-const result = await extended.api.transaction_status_api.find_transaction({
-  transaction_id: "0000000000000000000000000000000000000000",
-  expiration: "2016-03-24T18:00:21"
-});
-
-console.info(result); // { status: 'unknown' }
-```
-
 #### Extend API interface using interfaces only and call custom endpoints
 
 In this example we will extend the base Wax endpoints without creating any validators.
@@ -275,42 +227,6 @@ const result = await extended.api.transaction_status_api.find_transaction({
 console.info(result); // { status: 'unknown' }
 ```
 
-#### Extend REST API interface and call custom endpoints
-
-In this example we will extend REST API Wax endpoints and create our classes with validators
-in order to use the [hafah_endpoints.get_transaction](https://api.syncad.com/?urls.primaryName=HAfAH#/Transactions/hafah_endpoints.get_transaction) API:
-
-```ts
-import { IsHexadecimal } from 'class-validator';
-import { createHiveChain, TWaxRestExtended } from '@hiveio/wax';
-const chain = await createHiveChain();
-
-class TransactionByIdRequest {
-  @IsHexadecimal()
-  public transactionId!: string;
-}
-
-// Create the proper API structure
-const ExtendedRestApi = {
-  'hafah-api': { // API type - structure-like - pushed to the query path during call
-    transactions: { // method name - also pushed to the query path during call
-      byId: { // next query path to be added. It will be replaced though due to the urlPath property defined
-        params: TransactionByIdRequest, // params is our request
-        result: Number, // result is our response (Number is a NumberConstructor - we cannot use number as a type in this context, so we pass NumberConstructor as a value)
-        urlPath: "{transactionId}" // url that will replace `byId`. We have `{}` format syntax here, so it means data from `params` matching given property names will be replaced in braces
-      }
-    }
-  }
-};
-
-const extended: TWaxRestExtended<typeof ExtendedRestApi> = chain.extendRest(ExtendedRestApi);
-
-// Call the REST API using our extended interface
-const result = await await extended.restApi['hafah-api'].transactions.byId({ transactionId: "954f6de36e6715d128fa8eb5a053fc254b05ded0" });
-
-console.info(result); // URL response from "https://api.syncad.com/hafah-api/transactions/954f6de36e6715d128fa8eb5a053fc254b05ded0"
-```
-
 #### Extend REST API interface using interfaces only and call custom endpoints
 
 In this example we will extend the REST API Wax endpoints without creating any validators.