@cardano-sdk/key-management 0.2.0-nightly.9 → 0.2.1-nightly.0

package/dist/esm/util/mapHardwareSigningData.js

@@ -1,10 +1,10 @@
 import * as ledger from '@cardano-foundation/ledgerjs-hw-app-cardano';
 import * as trezor from 'trezor-connect';
 import { CardanoKeyConst } from '../types';
-import { CSL, cslToCore } from '@cardano-sdk/core';
+import { CML, cmlToCore } from '@cardano-sdk/core';
 import { HwMappingError } from '../errors';
+import { ManagedFreeableScope, isNotNil, usingAutoFree } from '@cardano-sdk/util';
 import { STAKE_KEY_DERIVATION_PATH, harden } from './key';
-import { isNotNil } from '@cardano-sdk/util';
 import concat from 'lodash/concat';
 import uniq from 'lodash/uniq';
 const sortTokensCanonically = (tokens) => {
@@ -19,10 +19,13 @@ const sortTokensCanonically = (tokens) => {
         return -1;
     });
 };
-const getRewardAccountKeyHash = (rewardAccount) => Buffer.from(CSL.RewardAddress.from_address(CSL.Address.from_bech32(rewardAccount.toString()))
-    .payment_cred()
-    .to_keyhash()
-    .to_bytes()).toString('hex');
+const getRewardAccountKeyHash = (rewardAccount) => usingAutoFree((scope) => {
+    const address = scope.manage(CML.Address.from_bech32(rewardAccount.toString()));
+    const rewardAddress = scope.manage(CML.RewardAddress.from_address(address));
+    const paymentCred = scope.manage(rewardAddress.payment_cred());
+    const keyHash = scope.manage(paymentCred.to_keyhash());
+    return Buffer.from(keyHash.to_bytes()).toString('hex');
+});
 const bytesToIp = (bytes) => {
     if (!bytes)
         return null;
@@ -44,14 +47,16 @@ const matchGroupedAddress = (knownAddresses, outputAddress) => {
     return knownAddresses.find(({ address }) => address.toString() === outputAddressBech32);
 };
 const prepareTrezorInputs = async (inputs, inputResolver, knownAddresses) => {
+    const scope = new ManagedFreeableScope();
     const trezorInputs = [];
     for (let i = 0; i < inputs.len(); i++) {
-        const input = inputs.get(i);
-        const coreInput = cslToCore.txIn(input);
+        const input = scope.manage(inputs.get(i));
+        const inputTxId = scope.manage(input.transaction_id());
+        const coreInput = cmlToCore.txIn(input);
         const paymentAddress = await inputResolver.resolveInputAddress(coreInput);
         let trezorInput = {
-            prev_hash: Buffer.from(input.transaction_id().to_bytes()).toString('hex'),
-            prev_index: input.index()
+            prev_hash: Buffer.from(inputTxId.to_bytes()).toString('hex'),
+            prev_index: Number(scope.manage(input.index()).to_str())
         };
         let paymentKeyPath = null;
         if (paymentAddress) {
@@ -72,23 +77,28 @@ const prepareTrezorInputs = async (inputs, inputResolver, knownAddresses) => {
         }
         trezorInputs.push(trezorInput);
     }
+    scope.dispose();
     return trezorInputs;
 };
-const prepareTrezorOutputs = (outputs, knownAddresses) => {
+const prepareTrezorOutputs = (outputs, knownAddresses) => usingAutoFree((scope) => {
     const trezorOutputs = [];
     for (let i = 0; i < outputs.len(); i++) {
-        const output = outputs.get(i);
-        const multiAsset = output.amount().multiasset();
+        const output = scope.manage(outputs.get(i));
+        const outputAmount = scope.manage(output.amount());
+        const outputAddress = scope.manage(output.address());
+        const multiAsset = scope.manage(outputAmount.multiasset());
         const tokenBundle = [];
         if (multiAsset) {
-            for (let j = 0; j < multiAsset.keys().len(); j++) {
-                const policy = multiAsset.keys().get(j);
-                const assets = multiAsset.get(policy);
+            const multiAssetKeys = scope.manage(multiAsset.keys());
+            for (let j = 0; j < multiAssetKeys.len(); j++) {
+                const policy = scope.manage(multiAssetKeys.get(j));
+                const assets = scope.manage(multiAsset.get(policy));
                 const tokens = [];
                 if (assets) {
-                    for (let k = 0; k < assets.keys().len(); k++) {
-                        const assetName = assets.keys().get(k);
-                        const amount = assets.get(assetName);
+                    const assetsKeys = scope.manage(assets.keys());
+                    for (let k = 0; k < assetsKeys.len(); k++) {
+                        const assetName = scope.manage(assetsKeys.get(k));
+                        const amount = scope.manage(assets.get(assetName));
                         if (assetName && amount) {
                             tokens.push({
                                 amount: amount.to_str(),
@@ -104,8 +114,8 @@ const prepareTrezorOutputs = (outputs, knownAddresses) => {
                 });
             }
         }
-        const outputAddress = Buffer.from(output.address().to_bytes());
-        const ownAddress = matchGroupedAddress(knownAddresses, outputAddress);
+        const outputAddressBytes = Buffer.from(outputAddress.to_bytes());
+        const ownAddress = matchGroupedAddress(knownAddresses, outputAddressBytes);
         const destination = ownAddress
             ? {
                 addressParameters: {
@@ -115,26 +125,27 @@ const prepareTrezorOutputs = (outputs, knownAddresses) => {
                 }
             }
             : {
-                address: output.address().to_bech32()
+                address: outputAddress.to_bech32()
             };
         const outputRes = {
             ...destination,
-            amount: output.amount().coin().to_str(),
+            amount: scope.manage(outputAmount.coin()).to_str(),
             tokenBundle
         };
         trezorOutputs.push(outputRes);
     }
     return trezorOutputs;
-};
-const prepareTrezorCertificates = (certificates, rewardAccountKeyPath, rewardAccountKeyHash) => {
+});
+const prepareTrezorCertificates = (certificates, rewardAccountKeyPath, rewardAccountKeyHash) => usingAutoFree((scope) => {
     let signingMode;
     const certs = [];
     for (let i = 0; i < certificates.len(); i++) {
-        const cert = certificates.get(i);
+        const cert = scope.manage(certificates.get(i));
         const certificate = {};
         if (cert.kind() === 0) {
-            const credential = cert.as_stake_registration()?.stake_credential();
-            const credentialScriptHash = credential?.to_scripthash();
+            const stakeRegistration = scope.manage(cert.as_stake_registration());
+            const credential = scope.manage(stakeRegistration?.stake_credential());
+            const credentialScriptHash = scope.manage(credential?.to_scripthash());
             certificate.type = trezor.CardanoCertificateType.STAKE_REGISTRATION;
             if (credential?.kind() === 0) {
                 certificate.path = rewardAccountKeyPath;
@@ -144,8 +155,9 @@ const prepareTrezorCertificates = (certificates, rewardAccountKeyPath, rewardAcc
             }
         }
         else if (cert.kind() === 1) {
-            const credential = cert.as_stake_deregistration()?.stake_credential();
-            const credentialScriptHash = credential?.to_scripthash();
+            const stakeDeregistration = scope.manage(cert.as_stake_deregistration());
+            const credential = scope.manage(stakeDeregistration?.stake_credential());
+            const credentialScriptHash = scope.manage(credential?.to_scripthash());
             certificate.type = trezor.CardanoCertificateType.STAKE_DEREGISTRATION;
             if (credential?.kind() === 0) {
                 certificate.path = rewardAccountKeyPath;
@@ -155,10 +167,10 @@ const prepareTrezorCertificates = (certificates, rewardAccountKeyPath, rewardAcc
             }
         }
         else if (cert.kind() === 2) {
-            const delegation = cert.as_stake_delegation();
-            const delegationPoolKeyHash = delegation?.pool_keyhash();
-            const credential = delegation?.stake_credential();
-            const credentialScriptHash = credential?.to_scripthash();
+            const delegation = scope.manage(cert.as_stake_delegation());
+            const delegationPoolKeyHash = scope.manage(delegation?.pool_keyhash());
+            const credential = scope.manage(delegation?.stake_credential());
+            const credentialScriptHash = scope.manage(credential?.to_scripthash());
             certificate.type = trezor.CardanoCertificateType.STAKE_DELEGATION;
             if (credential?.kind() === 0) {
                 certificate.path = rewardAccountKeyPath;
@@ -171,16 +183,18 @@ const prepareTrezorCertificates = (certificates, rewardAccountKeyPath, rewardAcc
             }
         }
         else if (cert.kind() === 3) {
-            const params = cert.as_pool_registration()?.pool_params();
+            const poolRegistration = scope.manage(cert.as_pool_registration());
+            const params = scope.manage(poolRegistration?.pool_params());
             if (!params) {
                 throw new HwMappingError('Missing pool registration pool parameters.');
             }
             certificate.type = trezor.CardanoCertificateType.STAKE_POOL_REGISTRATION;
-            const owners = params?.pool_owners();
+            const owners = scope.manage(params?.pool_owners());
             const poolOwners = [];
             if (owners) {
                 for (let j = 0; j < owners.len(); j++) {
-                    const keyHash = Buffer.from(owners.get(j).to_bytes()).toString('hex');
+                    const owner = scope.manage(owners.get(j));
+                    const keyHash = Buffer.from(owner.to_bytes()).toString('hex');
                     if (keyHash === rewardAccountKeyHash) {
                         signingMode = trezor.CardanoTxSigningMode.POOL_REGISTRATION_AS_OWNER;
                         poolOwners.push({
@@ -194,17 +208,19 @@ const prepareTrezorCertificates = (certificates, rewardAccountKeyPath, rewardAcc
                     }
                 }
             }
-            const relays = params?.relays();
+            const relays = scope.manage(params?.relays());
             const trezorRelays = [];
             if (relays) {
                 for (let k = 0; k < relays.len(); k++) {
-                    const relay = relays.get(k);
+                    const relay = scope.manage(relays.get(k));
                     if (relay.kind() === 0) {
-                        const singleHostAddr = relay.as_single_host_addr();
+                        const singleHostAddr = scope.manage(relay.as_single_host_addr());
                         const type = trezor.CardanoPoolRelayType.SINGLE_HOST_IP;
                         const port = singleHostAddr?.port();
-                        const ipv4Address = singleHostAddr?.ipv4() ? bytesToIp(singleHostAddr.ipv4()?.ip()) : null;
-                        const ipv6Address = singleHostAddr?.ipv6() ? bytesToIp(singleHostAddr.ipv6()?.ip()) : null;
+                        const ipv4 = scope.manage(singleHostAddr?.ipv4());
+                        const ipv4Address = ipv4 ? bytesToIp(ipv4?.ip()) : null;
+                        const ipv6 = scope.manage(singleHostAddr?.ipv6());
+                        const ipv6Address = ipv6 ? bytesToIp(ipv6?.ip()) : null;
                         trezorRelays.push({
                             ipv4Address: ipv4Address || undefined,
                             ipv6Address: ipv6Address || undefined,
@@ -214,10 +230,10 @@ const prepareTrezorCertificates = (certificates, rewardAccountKeyPath, rewardAcc
                     }
                     else if (relay.kind() === 1) {
                         const type = trezor.CardanoPoolRelayType.SINGLE_HOST_NAME;
-                        const singleHostName = relay.as_single_host_name();
+                        const singleHostName = scope.manage(relay.as_single_host_name());
                         if (singleHostName) {
                             const port = singleHostName.port();
-                            const hostName = singleHostName.dns_name().record();
+                            const hostName = scope.manage(singleHostName.dns_name()).record();
                             trezorRelays.push({
                                 hostName,
                                 port,
@@ -227,8 +243,8 @@ const prepareTrezorCertificates = (certificates, rewardAccountKeyPath, rewardAcc
                     }
                     else if (relay.kind() === 2) {
                         const type = trezor.CardanoPoolRelayType.MULTIPLE_HOST_NAME;
-                        const multiHostName = relay.as_multi_host_name();
-                        const hostName = multiHostName?.dns_name().record();
+                        const multiHostName = scope.manage(relay.as_multi_host_name());
+                        const hostName = scope.manage(multiHostName?.dns_name())?.record();
                         if (hostName) {
                             trezorRelays.push({
                                 hostName,
@@ -238,20 +254,21 @@ const prepareTrezorCertificates = (certificates, rewardAccountKeyPath, rewardAcc
                     }
                 }
             }
-            const cost = params?.cost().to_str();
-            const margin = params?.margin();
-            const pledge = params?.pledge().to_str();
-            const poolId = Buffer.from(params.operator().to_bytes()).toString('hex');
-            const poolMetadata = params.pool_metadata();
+            const cost = scope.manage(params?.cost()).to_str();
+            const margin = scope.manage(params?.margin());
+            const pledge = scope.manage(params?.pledge()).to_str();
+            const poolId = Buffer.from(scope.manage(params.operator()).to_bytes()).toString('hex');
+            const poolMetadata = scope.manage(params.pool_metadata());
             if (!poolMetadata) {
                 throw new HwMappingError('Missing pool metadata.');
             }
             const metadata = {
-                hash: Buffer.from(poolMetadata.pool_metadata_hash().to_bytes()).toString('hex'),
-                url: poolMetadata.url().url()
+                hash: Buffer.from(scope.manage(poolMetadata.pool_metadata_hash()).to_bytes()).toString('hex'),
+                url: scope.manage(poolMetadata.url()).url()
             };
-            const rewardAccount = params.reward_account().to_address().to_bech32();
-            const vrfKeyHash = Buffer.from(params.vrf_keyhash().to_bytes()).toString('hex');
+            const rewardAccount = scope.manage(params.reward_account());
+            const rewardAccountBech32 = scope.manage(rewardAccount.to_address()).to_bech32();
+            const vrfKeyHash = Buffer.from(scope.manage(params.vrf_keyhash()).to_bytes()).toString('hex');
             certificate.poolParameters = {
                 cost,
                 margin: {
@@ -263,7 +280,7 @@ const prepareTrezorCertificates = (certificates, rewardAccountKeyPath, rewardAcc
                 pledge,
                 poolId,
                 relays: trezorRelays,
-                rewardAccount,
+                rewardAccount: rewardAccountBech32,
                 vrfKeyHash
             };
         }
@@ -273,21 +290,22 @@ const prepareTrezorCertificates = (certificates, rewardAccountKeyPath, rewardAcc
         certs,
         signingMode
     };
-};
-const prepareTrezorWithdrawals = (withdrawals, rewardAccountKeyPath) => {
+});
+const prepareTrezorWithdrawals = (withdrawals, rewardAccountKeyPath) => usingAutoFree((scope) => {
     const trezorWithdrawals = [];
-    for (let i = 0; i < withdrawals.keys().len(); i++) {
+    const withdrawalsKeys = scope.manage(withdrawals.keys());
+    for (let i = 0; i < withdrawalsKeys.len(); i++) {
         const withdrawal = {};
-        const rewardAddress = withdrawals.keys().get(i);
-        const paymentCredentials = rewardAddress.payment_cred();
-        const paymentCredentialsScriptHash = paymentCredentials.to_scripthash();
-        if (rewardAddress.payment_cred().kind() === 0) {
+        const rewardAddress = scope.manage(withdrawalsKeys.get(i));
+        const paymentCredentials = scope.manage(rewardAddress.payment_cred());
+        const paymentCredentialsScriptHash = scope.manage(paymentCredentials.to_scripthash());
+        if (paymentCredentials.kind() === 0) {
             withdrawal.path = rewardAccountKeyPath;
         }
         else if (paymentCredentialsScriptHash) {
             withdrawal.scriptHash = Buffer.from(paymentCredentialsScriptHash.to_bytes()).toString('hex');
         }
-        const withdrawalAmount = withdrawals.get(rewardAddress);
+        const withdrawalAmount = scope.manage(withdrawals.get(rewardAddress));
         if (!withdrawalAmount) {
             throw new HwMappingError('Withdrawal amount is not defined.');
         }
@@ -295,20 +313,22 @@ const prepareTrezorWithdrawals = (withdrawals, rewardAccountKeyPath) => {
         trezorWithdrawals.push(withdrawal);
     }
     return trezorWithdrawals;
-};
-const prepareTrezorMintBundle = (mint, paymentKeyPaths, rewardAccountKeyPath) => {
+});
+const prepareTrezorMintBundle = (mint, paymentKeyPaths, rewardAccountKeyPath) => usingAutoFree((scope) => {
     const additionalWitnessPaths = [];
     const mintAssetsGroup = [];
-    for (let j = 0; j < mint.keys().len(); j++) {
-        const policy = mint.keys().get(j);
-        const assets = mint.get(policy);
+    const mintKeys = scope.manage(mint.keys());
+    for (let j = 0; j < mintKeys.len(); j++) {
+        const policy = scope.manage(mintKeys.get(j));
+        const assets = scope.manage(mint.get(policy));
         const tokens = [];
         if (assets) {
-            for (let k = 0; k < assets.keys().len(); k++) {
-                const assetName = assets.keys().get(k);
-                const amount = assets.get(assetName);
-                const positiveAmount = amount?.as_positive()?.to_str();
-                const negativeAmount = amount?.as_negative()?.to_str();
+            const assetsKeys = scope.manage(assets.keys());
+            for (let k = 0; k < assetsKeys.len(); k++) {
+                const assetName = scope.manage(assetsKeys.get(k));
+                const amount = scope.manage(assets.get(assetName));
+                const positiveAmount = scope.manage(amount?.as_positive())?.to_str();
+                const negativeAmount = scope.manage(amount?.as_negative())?.to_str();
                 if (!amount || !positiveAmount || !negativeAmount) {
                     throw new HwMappingError('Missing token amount.');
                 }
@@ -332,12 +352,13 @@ const prepareTrezorMintBundle = (mint, paymentKeyPaths, rewardAccountKeyPath) =>
         additionalWitnessPaths,
         mintAssetsGroup
     };
-};
+});
 const prepareLedgerInputs = async (inputs, inputResolver, knownAddresses) => {
+    const scope = new ManagedFreeableScope();
     const ledgerInputs = [];
     for (let i = 0; i < inputs.len(); i++) {
-        const input = inputs.get(i);
-        const coreInput = cslToCore.txIn(input);
+        const input = scope.manage(inputs.get(i));
+        const coreInput = cmlToCore.txIn(input);
         const paymentAddress = await inputResolver.resolveInputAddress(coreInput);
         let paymentKeyPath = null;
         if (paymentAddress) {
@@ -353,28 +374,32 @@ const prepareLedgerInputs = async (inputs, inputResolver, knownAddresses) => {
             }
         }
         ledgerInputs.push({
-            outputIndex: input.index(),
+            outputIndex: Number(scope.manage(input.index()).to_str()),
             path: paymentKeyPath,
-            txHashHex: Buffer.from(input.transaction_id().to_bytes()).toString('hex')
+            txHashHex: Buffer.from(scope.manage(input.transaction_id()).to_bytes()).toString('hex')
         });
     }
+    scope.dispose();
     return ledgerInputs;
 };
-const prepareLedgerOutputs = (outputs, knownAddresses) => {
+const prepareLedgerOutputs = (outputs, knownAddresses) => usingAutoFree((scope) => {
     const ledgerOutputs = [];
     for (let i = 0; i < outputs.len(); i++) {
-        const output = outputs.get(i);
-        const multiAsset = output.amount().multiasset();
+        const output = scope.manage(outputs.get(i));
+        const outputAmount = scope.manage(output.amount());
+        const multiAsset = scope.manage(outputAmount.multiasset());
         const tokenBundle = [];
         if (multiAsset) {
-            for (let j = 0; j < multiAsset.keys().len(); j++) {
-                const policy = multiAsset.keys().get(j);
-                const assets = multiAsset.get(policy);
+            const multiAssetKeys = scope.manage(multiAsset.keys());
+            for (let j = 0; j < multiAssetKeys.len(); j++) {
+                const policy = scope.manage(multiAssetKeys.get(j));
+                const assets = scope.manage(multiAsset.get(policy));
                 const tokens = [];
                 if (assets) {
-                    for (let k = 0; k < assets.keys().len(); k++) {
-                        const assetName = assets.keys().get(k);
-                        const amount = assets.get(assetName);
+                    const assetsKeys = scope.manage(assets.keys());
+                    for (let k = 0; k < assetsKeys.len(); k++) {
+                        const assetName = scope.manage(assetsKeys.get(k));
+                        const amount = scope.manage(assets.get(assetName));
                         if (assetName && amount) {
                             tokens.push({
                                 amount: amount.to_str(),
@@ -390,7 +415,7 @@ const prepareLedgerOutputs = (outputs, knownAddresses) => {
                 });
             }
         }
-        const outputAddress = Buffer.from(output.address().to_bytes());
+        const outputAddress = Buffer.from(scope.manage(output.address()).to_bytes());
         const ownAddress = matchGroupedAddress(knownAddresses, outputAddress);
         const destination = ownAddress
             ? {
@@ -421,10 +446,10 @@ const prepareLedgerOutputs = (outputs, knownAddresses) => {
                 },
                 type: ledger.TxOutputDestinationType.THIRD_PARTY
             };
-        const outputDataHash = output.data_hash();
+        const outputDataHash = scope.manage(scope.manage(output.datum())?.as_data_hash());
         const datumHashHex = outputDataHash ? Buffer.from(outputDataHash.to_bytes()).toString('hex') : null;
         const outputRes = {
-            amount: output.amount().coin().to_str(),
+            amount: scope.manage(outputAmount.coin()).to_str(),
             datumHashHex,
             destination,
             tokenBundle
@@ -432,16 +457,17 @@ const prepareLedgerOutputs = (outputs, knownAddresses) => {
         ledgerOutputs.push(outputRes);
     }
     return ledgerOutputs;
-};
-const prepareLedgerCertificates = (certificates, knownAddresses, rewardAccountKeyPath, rewardAccountKeyHash) => {
+});
+const prepareLedgerCertificates = (certificates, knownAddresses, rewardAccountKeyPath, rewardAccountKeyHash) => usingAutoFree((scope) => {
     let signingMode;
     const certs = [];
     for (let i = 0; i < certificates.len(); i++) {
-        const cert = certificates.get(i);
+        const cert = scope.manage(certificates.get(i));
         const certificate = {};
         if (cert.kind() === 0) {
-            const credential = cert.as_stake_registration()?.stake_credential();
-            const credentialScriptHash = credential?.to_scripthash();
+            const stakeRegistration = scope.manage(cert.as_stake_registration());
+            const credential = scope.manage(stakeRegistration?.stake_credential());
+            const credentialScriptHash = scope.manage(credential?.to_scripthash());
             certificate.type = ledger.CertificateType.STAKE_REGISTRATION;
             if (credential?.kind() === 0) {
                 certificate.params = {
@@ -462,8 +488,9 @@ const prepareLedgerCertificates = (certificates, knownAddresses, rewardAccountKe
             }
         }
         else if (cert.kind() === 1) {
-            const credential = cert.as_stake_deregistration()?.stake_credential();
-            const credentialScriptHash = credential?.to_scripthash();
+            const stakeDeregistration = scope.manage(cert.as_stake_deregistration());
+            const credential = scope.manage(stakeDeregistration?.stake_credential());
+            const credentialScriptHash = scope.manage(credential?.to_scripthash());
             certificate.type = ledger.CertificateType.STAKE_DEREGISTRATION;
             if (credential?.kind() === 0) {
                 certificate.params = {
@@ -484,10 +511,10 @@ const prepareLedgerCertificates = (certificates, knownAddresses, rewardAccountKe
             }
         }
         else if (cert.kind() === 2) {
-            const delegation = cert.as_stake_delegation();
-            const delegationPoolKeyHash = delegation?.pool_keyhash();
-            const credential = delegation?.stake_credential();
-            const credentialScriptHash = credential?.to_scripthash();
+            const delegation = scope.manage(cert.as_stake_delegation());
+            const delegationPoolKeyHash = scope.manage(delegation?.pool_keyhash());
+            const credential = scope.manage(delegation?.stake_credential());
+            const credentialScriptHash = scope.manage(credential?.to_scripthash());
             certificate.type = ledger.CertificateType.STAKE_DELEGATION;
             if (credential?.kind() === 0) {
                 certificate.params = {
@@ -514,16 +541,17 @@ const prepareLedgerCertificates = (certificates, knownAddresses, rewardAccountKe
             }
         }
         else if (cert.kind() === 3) {
-            const params = cert.as_pool_registration()?.pool_params();
+            const poolRegistration = scope.manage(cert.as_pool_registration());
+            const params = scope.manage(poolRegistration?.pool_params());
             if (!params) {
                 throw new HwMappingError('Missing pool registration pool parameters.');
             }
             certificate.type = ledger.CertificateType.STAKE_POOL_REGISTRATION;
-            const owners = params?.pool_owners();
+            const owners = scope.manage(params?.pool_owners());
             const poolOwners = [];
             if (owners) {
                 for (let j = 0; j < owners.len(); j++) {
-                    const keyHash = Buffer.from(owners.get(j).to_bytes()).toString('hex');
+                    const keyHash = Buffer.from(scope.manage(owners.get(j)).to_bytes()).toString('hex');
                     if (keyHash === rewardAccountKeyHash) {
                         signingMode = ledger.TransactionSigningMode.POOL_REGISTRATION_AS_OWNER;
                         poolOwners.push({
@@ -543,25 +571,27 @@ const prepareLedgerCertificates = (certificates, knownAddresses, rewardAccountKe
                     }
                 }
             }
-            const relays = params?.relays();
+            const relays = scope.manage(params?.relays());
             const ledgerRelays = [];
             if (relays) {
                 for (let k = 0; k < relays.len(); k++) {
-                    const relay = relays.get(k);
+                    const relay = scope.manage(relays.get(k));
                     if (relay.kind() === 0) {
-                        const singleHostAddr = relay.as_single_host_addr();
+                        const singleHostAddr = scope.manage(relay.as_single_host_addr());
                         const type = 0;
                         const portNumber = singleHostAddr?.port();
-                        const ipv4 = singleHostAddr?.ipv4() ? bytesToIp(singleHostAddr.ipv4()?.ip()) : null;
-                        const ipv6 = singleHostAddr?.ipv6() ? bytesToIp(singleHostAddr.ipv6()?.ip()) : null;
-                        ledgerRelays.push({ params: { ipv4, ipv6, portNumber }, type });
+                        const ipv4 = scope.manage(singleHostAddr?.ipv4());
+                        const ipv6 = scope.manage(singleHostAddr?.ipv6());
+                        const ipv4Address = ipv4 ? bytesToIp(ipv4.ip()) : null;
+                        const ipv6Address = ipv6 ? bytesToIp(ipv6.ip()) : null;
+                        ledgerRelays.push({ params: { ipv4: ipv4Address, ipv6: ipv6Address, portNumber }, type });
                     }
                     else if (relay.kind() === 1) {
                         const type = 1;
-                        const singleHostName = relay.as_single_host_name();
+                        const singleHostName = scope.manage(relay.as_single_host_name());
                         if (singleHostName) {
                             const portNumber = singleHostName.port();
-                            const dnsName = singleHostName.dns_name().record();
+                            const dnsName = scope.manage(singleHostName.dns_name()).record();
                             ledgerRelays.push({
                                 params: { dnsName, portNumber },
                                 type
@@ -570,8 +600,8 @@ const prepareLedgerCertificates = (certificates, knownAddresses, rewardAccountKe
                     }
                     else if (relay.kind() === 2) {
                         const type = 2;
-                        const multiHostName = relay.as_multi_host_name();
-                        const dnsName = multiHostName?.dns_name().record();
+                        const multiHostName = scope.manage(relay.as_multi_host_name());
+                        const dnsName = scope.manage(multiHostName?.dns_name())?.record();
                         if (dnsName) {
                             ledgerRelays.push({
                                 params: { dnsName },
@@ -581,10 +611,10 @@ const prepareLedgerCertificates = (certificates, knownAddresses, rewardAccountKe
                     }
                 }
             }
-            const cost = params?.cost().to_str();
-            const margin = params?.margin();
-            const pledge = params?.pledge().to_str();
-            const operator = Buffer.from(params.operator().to_bytes()).toString('hex');
+            const cost = scope.manage(params?.cost()).to_str();
+            const margin = scope.manage(params?.margin());
+            const pledge = scope.manage(params?.pledge()).to_str();
+            const operator = Buffer.from(scope.manage(params.operator()).to_bytes()).toString('hex');
             let poolKey;
             if (operator === rewardAccountKeyHash) {
                 signingMode = ledger.TransactionSigningMode.POOL_REGISTRATION_AS_OPERATOR;
@@ -599,14 +629,15 @@ const prepareLedgerCertificates = (certificates, knownAddresses, rewardAccountKe
                     type: ledger.PoolKeyType.THIRD_PARTY
                 };
             }
-            const poolMetadata = params.pool_metadata();
+            const poolMetadata = scope.manage(params.pool_metadata());
             const metadata = poolMetadata
                 ? {
-                    metadataHashHex: Buffer.from(poolMetadata.pool_metadata_hash().to_bytes()).toString('hex'),
-                    metadataUrl: poolMetadata.url().url()
+                    metadataHashHex: Buffer.from(scope.manage(poolMetadata.pool_metadata_hash()).to_bytes()).toString('hex'),
+                    metadataUrl: scope.manage(poolMetadata.url()).url()
                 }
                 : null;
-            const rewardAccountBytes = Buffer.from(params.reward_account().to_address().to_bytes());
+            const poolRewardAccount = scope.manage(params.reward_account());
+            const rewardAccountBytes = Buffer.from(scope.manage(poolRewardAccount.to_address()).to_bytes());
             const isDeviceOwned = knownAddresses.some(({ address }) => address.toString() === ledger.utils.bech32_encodeAddress(rewardAccountBytes));
             const rewardAccount = isDeviceOwned
                 ? {
@@ -617,12 +648,12 @@ const prepareLedgerCertificates = (certificates, knownAddresses, rewardAccountKe
                     params: { rewardAccountHex: rewardAccountBytes.toString('hex') },
                     type: ledger.PoolRewardAccountType.THIRD_PARTY
                 };
-            const vrfKeyHashHex = Buffer.from(params.vrf_keyhash().to_bytes()).toString('hex');
+            const vrfKeyHashHex = Buffer.from(scope.manage(params.vrf_keyhash()).to_bytes()).toString('hex');
             certificate.params = {
                 cost,
                 margin: {
-                    denominator: margin.denominator().to_str(),
-                    numerator: margin.numerator().to_str()
+                    denominator: scope.manage(margin.denominator()).to_str(),
+                    numerator: scope.manage(margin.numerator()).to_str()
                 },
                 metadata,
                 pledge,
@@ -639,15 +670,16 @@ const prepareLedgerCertificates = (certificates, knownAddresses, rewardAccountKe
         certs,
         signingMode
     };
-};
-const prepareLedgerWithdrawals = (withdrawals, rewardAccountKeyPath) => {
+});
+const prepareLedgerWithdrawals = (withdrawals, rewardAccountKeyPath) => usingAutoFree((scope) => {
     const ledgerWithdrawals = [];
-    for (let i = 0; i < withdrawals.keys().len(); i++) {
+    const withdrawalsKeys = scope.manage(withdrawals.keys());
+    for (let i = 0; i < withdrawalsKeys.len(); i++) {
         const withdrawal = { stakeCredential: {} };
-        const rewardAddress = withdrawals.keys().get(i);
-        const paymentCredentials = rewardAddress.payment_cred();
-        const paymentCredentialsScriptHash = paymentCredentials.to_scripthash();
-        if (rewardAddress.payment_cred().kind() === 0) {
+        const rewardAddress = scope.manage(withdrawalsKeys.get(i));
+        const paymentCredentials = scope.manage(rewardAddress.payment_cred());
+        const paymentCredentialsScriptHash = scope.manage(paymentCredentials.to_scripthash());
+        if (paymentCredentials.kind() === 0) {
             const stakeCredential = {
                 keyPath: rewardAccountKeyPath,
                 type: ledger.StakeCredentialParamsType.KEY_PATH
@@ -661,7 +693,7 @@ const prepareLedgerWithdrawals = (withdrawals, rewardAccountKeyPath) => {
             };
             withdrawal.stakeCredential = stakeCredential;
         }
-        const withdrawalAmount = withdrawals.get(rewardAddress);
+        const withdrawalAmount = scope.manage(withdrawals.get(rewardAddress));
         if (!withdrawalAmount) {
             throw new HwMappingError('Withdrawal amount is not defined.');
         }
@@ -671,20 +703,22 @@ const prepareLedgerWithdrawals = (withdrawals, rewardAccountKeyPath) => {
         });
     }
     return ledgerWithdrawals;
-};
-const prepareLedgerMintBundle = (mint, paymentKeyPaths, rewardAccountKeyPath) => {
+});
+const prepareLedgerMintBundle = (mint, paymentKeyPaths, rewardAccountKeyPath) => usingAutoFree((scope) => {
     const additionalWitnessPaths = [];
     const mintAssetsGroup = [];
-    for (let j = 0; j < mint.keys().len(); j++) {
-        const policy = mint.keys().get(j);
-        const assets = mint.get(policy);
+    const mintKeys = scope.manage(mint.keys());
+    for (let j = 0; j < mintKeys.len(); j++) {
+        const policy = scope.manage(mintKeys.get(j));
+        const assets = scope.manage(mint.get(policy));
         const tokens = [];
         if (assets) {
-            for (let k = 0; k < assets.keys().len(); k++) {
-                const assetName = assets.keys().get(k);
-                const amount = assets.get(assetName);
-                const positiveAmount = amount?.as_positive()?.to_str();
-                const negativeAmount = amount?.as_negative()?.to_str();
+            const assetsKeys = assets.keys();
+            for (let k = 0; k < assetsKeys.len(); k++) {
+                const assetName = scope.manage(assetsKeys.get(k));
+                const amount = scope.manage(assets.get(assetName));
+                const positiveAmount = scope.manage(amount?.as_positive())?.to_str();
+                const negativeAmount = scope.manage(amount?.as_negative())?.to_str();
                 if (!amount || !positiveAmount || !negativeAmount) {
                     throw new HwMappingError('Missing token amount.');
                 }
@@ -708,8 +742,9 @@ const prepareLedgerMintBundle = (mint, paymentKeyPaths, rewardAccountKeyPath) =>
         additionalWitnessPaths,
         mintAssetsGroup
     };
-};
+});
 export const txToLedger = async ({ cslTxBody, networkId, inputResolver: inputAddressResolver, knownAddresses, protocolMagic }) => {
+    const scope = new ManagedFreeableScope();
     const accountAddress = knownAddresses[0];
     const rewardAccount = accountAddress.rewardAccount;
     const rewardAccountKeyHash = getRewardAccountKeyHash(rewardAccount);
@@ -720,19 +755,19 @@ export const txToLedger = async ({ cslTxBody, networkId, inputResolver: inputAdd
         STAKE_KEY_DERIVATION_PATH.role,
         STAKE_KEY_DERIVATION_PATH.index
     ];
-    const ledgerInputs = await prepareLedgerInputs(cslTxBody.inputs(), inputAddressResolver, knownAddresses);
-    const ledgerOutputs = prepareLedgerOutputs(cslTxBody.outputs(), knownAddresses);
-    const cslWithdrawals = cslTxBody.withdrawals();
+    const ledgerInputs = await prepareLedgerInputs(scope.manage(cslTxBody.inputs()), inputAddressResolver, knownAddresses);
+    const ledgerOutputs = prepareLedgerOutputs(scope.manage(cslTxBody.outputs()), knownAddresses);
+    const cslWithdrawals = scope.manage(cslTxBody.withdrawals());
     const ledgerWithdrawals = cslWithdrawals ? prepareLedgerWithdrawals(cslWithdrawals, rewardAccountKeyPath) : null;
-    const cslCertificates = cslTxBody.certs();
+    const cslCertificates = scope.manage(cslTxBody.certs());
     const ledgerCertificatesData = cslCertificates
         ? prepareLedgerCertificates(cslCertificates, knownAddresses, rewardAccountKeyPath, rewardAccountKeyHash.toString())
         : null;
     const signingMode = ledgerCertificatesData?.signingMode || ledger.TransactionSigningMode.ORDINARY_TRANSACTION;
-    const fee = cslTxBody.fee().to_str();
-    const ttl = cslTxBody.ttl();
-    const validityStartInterval = cslTxBody.validity_start_interval();
-    const txBodyAuxDataHash = cslTxBody.auxiliary_data_hash();
+    const fee = scope.manage(cslTxBody.fee()).to_str();
+    const ttl = Number(scope.manage(cslTxBody.ttl())?.to_str());
+    const validityStartInterval = Number(scope.manage(cslTxBody.validity_start_interval())?.to_str());
+    const txBodyAuxDataHash = scope.manage(cslTxBody.auxiliary_data_hash());
     const auxiliaryData = txBodyAuxDataHash
         ? {
             params: {
@@ -741,7 +776,7 @@ export const txToLedger = async ({ cslTxBody, networkId, inputResolver: inputAdd
             type: ledger.TxAuxiliaryDataType.ARBITRARY_HASH
         }
         : null;
-    const cslMint = cslTxBody.multiassets();
+    const cslMint = scope.manage(cslTxBody.multiassets());
     let ledgerMintBundle = null;
     if (cslMint) {
         const paymentKeyPaths = uniq(ledgerInputs.map((ledgerInput) => ledgerInput.path).filter(isNotNil));
@@ -767,6 +802,7 @@ export const txToLedger = async ({ cslTxBody, networkId, inputResolver: inputAdd
         const objKey = key;
         !ledgerTx[objKey] && ledgerTx[objKey] !== 0 && delete ledgerTx[objKey];
     }
+    scope.dispose();
     return {
         additionalWitnessPaths,
         signingMode,
@@ -774,6 +810,7 @@ export const txToLedger = async ({ cslTxBody, networkId, inputResolver: inputAdd
     };
 };
 export const txToTrezor = async ({ cslTxBody, networkId, inputResolver: inputAddressResolver, knownAddresses, protocolMagic }) => {
+    const scope = new ManagedFreeableScope();
     const accountAddress = knownAddresses[0];
     const rewardAccount = accountAddress.rewardAccount;
     const rewardAccountKeyHash = getRewardAccountKeyHash(rewardAccount);
@@ -784,36 +821,37 @@ export const txToTrezor = async ({ cslTxBody, networkId, inputResolver: inputAdd
         STAKE_KEY_DERIVATION_PATH.role,
         STAKE_KEY_DERIVATION_PATH.index
     ];
-    const trezorInputs = await prepareTrezorInputs(cslTxBody.inputs(), inputAddressResolver, knownAddresses);
-    const trezorOutputs = prepareTrezorOutputs(cslTxBody.outputs(), knownAddresses);
-    const cslWithdrawals = cslTxBody.withdrawals();
+    const trezorInputs = await prepareTrezorInputs(scope.manage(cslTxBody.inputs()), inputAddressResolver, knownAddresses);
+    const trezorOutputs = prepareTrezorOutputs(scope.manage(cslTxBody.outputs()), knownAddresses);
+    const cslWithdrawals = scope.manage(cslTxBody.withdrawals());
     const trezorWithdrawals = cslWithdrawals ? prepareTrezorWithdrawals(cslWithdrawals, rewardAccountKeyPath) : undefined;
-    const cslCertificates = cslTxBody.certs();
+    const cslCertificates = scope.manage(cslTxBody.certs());
     let trezorCertificatesData;
     if (cslCertificates) {
         trezorCertificatesData = prepareTrezorCertificates(cslCertificates, rewardAccountKeyPath, rewardAccountKeyHash.toString());
     }
     const signingMode = trezorCertificatesData?.signingMode || trezor.CardanoTxSigningMode.ORDINARY_TRANSACTION;
-    const fee = cslTxBody.fee().to_str();
+    const fee = scope.manage(cslTxBody.fee()).to_str();
     let ttl;
     const cslTTL = cslTxBody.ttl();
     if (cslTTL) {
         ttl = cslTTL.toString();
     }
     const validityIntervalStart = cslTxBody.validity_start_interval();
-    const txBodyAuxDataHash = cslTxBody.auxiliary_data_hash();
+    const txBodyAuxDataHash = scope.manage(cslTxBody.auxiliary_data_hash());
     let auxiliaryData;
     if (txBodyAuxDataHash) {
         auxiliaryData = {
             hash: Buffer.from(txBodyAuxDataHash.to_bytes()).toString('hex')
         };
     }
-    const cslMint = cslTxBody.multiassets();
+    const cslMint = scope.manage(cslTxBody.multiassets());
     let trezorMintBundle = null;
     if (cslMint) {
         const paymentKeyPaths = uniq(trezorInputs.map((trezorInput) => trezorInput.path).filter(isNotNil));
         trezorMintBundle = prepareTrezorMintBundle(cslMint, paymentKeyPaths, rewardAccountKeyPath);
     }
+    scope.dispose();
     return {
         additionalWitnessRequests: trezorMintBundle?.additionalWitnessPaths,
         auxiliaryData,