@cardano-sdk/wallet 0.1.4 → 0.1.8

package/src/InMemoryUtxoRepository.ts

@@ -1,192 +0,0 @@
-import Schema, { TxIn, TxOut } from '@cardano-ogmios/schema';
-import { Buffer } from 'buffer';
-import { CardanoProvider, Ogmios, CardanoSerializationLib, CSL, cslUtil } from '@cardano-sdk/core';
-import { dummyLogger, Logger } from 'ts-log';
-import { ImplicitCoin, InputSelector, SelectionConstraints, SelectionResult } from '@cardano-sdk/cip2';
-import { KeyManager } from './KeyManagement';
-import {
-  UtxoRepository,
-  OnTransactionArgs,
-  TransactionTracker,
-  TransactionTrackerEvent,
-  UtxoRepositoryEvent,
-  UtxoRepositoryEvents
-} from './types';
-import { cslToOgmios } from '@cardano-sdk/core/src/Ogmios';
-import Emittery from 'emittery';
-
-export interface InMemoryUtxoRepositoryProps {
-  csl: CardanoSerializationLib;
-  provider: CardanoProvider;
-  keyManager: KeyManager;
-  inputSelector: InputSelector;
-  txTracker: TransactionTracker;
-  logger?: Logger;
-}
-
-const utxoEquals = ([txIn1]: [Schema.TxIn, Schema.TxOut], [txIn2]: [Schema.TxIn, Schema.TxOut]): boolean =>
-  txIn1.txId === txIn2.txId && txIn1.index === txIn2.index;
-
-export class InMemoryUtxoRepository extends Emittery<UtxoRepositoryEvents> implements UtxoRepository {
-  #csl: CardanoSerializationLib;
-  #delegationAndRewards: Ogmios.DelegationsAndRewards;
-  #inputSelector: InputSelector;
-  #keyManager: KeyManager;
-  #logger: Logger;
-  #provider: CardanoProvider;
-  #utxoSet: Set<[TxIn, TxOut]>;
-  #lockedUtxoSet: Set<[TxIn, TxOut]> = new Set();
-  #lockedRewards = 0n;
-
-  constructor({
-    csl,
-    logger = dummyLogger,
-    provider,
-    inputSelector,
-    keyManager,
-    txTracker
-  }: InMemoryUtxoRepositoryProps) {
-    super();
-    this.#csl = csl;
-    this.#logger = logger;
-    this.#provider = provider;
-    this.#utxoSet = new Set();
-    this.#delegationAndRewards = { rewards: undefined, delegate: undefined };
-    this.#inputSelector = inputSelector;
-    this.#keyManager = keyManager;
-    txTracker.on(TransactionTrackerEvent.NewTransaction, (args) => {
-      // not blocking to make it testable easier
-      this.#onTransaction(args).catch(this.#logger.error);
-    });
-  }
-
-  public async sync(): Promise<void> {
-    this.#logger.debug('Syncing InMemoryUtxoRepository');
-    const result = await this.#provider.utxoDelegationAndRewards(
-      [this.#keyManager.deriveAddress(1, 0)],
-      Buffer.from(this.#keyManager.stakeKey.hash().to_bytes()).toString('hex')
-    );
-    this.#logger.trace(result);
-    for (const utxo of result.utxo) {
-      if (!this.allUtxos.some((oldUtxo) => utxoEquals(utxo, oldUtxo))) {
-        this.#utxoSet.add(utxo);
-        this.#logger.debug('New UTxO', utxo);
-      }
-    }
-    for (const utxo of this.#utxoSet) {
-      if (!result.utxo.some((newUtxo) => utxoEquals(utxo, newUtxo))) {
-        this.#utxoSet.delete(utxo);
-        this.#logger.debug('UTxO is gone', utxo);
-      }
-    }
-    if (this.#delegationAndRewards.delegate !== result.delegationAndRewards.delegate) {
-      this.#delegationAndRewards.delegate = result.delegationAndRewards.delegate;
-      this.#logger.debug('Delegation stored', result.delegationAndRewards.delegate);
-    }
-    if (this.#delegationAndRewards.rewards !== result.delegationAndRewards.rewards) {
-      this.#delegationAndRewards.rewards = result.delegationAndRewards.rewards
-        ? BigInt(result.delegationAndRewards.rewards)
-        : undefined;
-      this.#logger.debug('Rewards balance stored', result.delegationAndRewards.rewards);
-    }
-    this.#emitSynced();
-  }
-
-  public async selectInputs(
-    outputs: Set<CSL.TransactionOutput>,
-    constraints: SelectionConstraints,
-    implicitCoin?: ImplicitCoin
-  ): Promise<SelectionResult> {
-    if (this.#utxoSet.size === 0) {
-      this.#logger.debug('Local UTxO set is empty. Syncing...');
-      await this.sync();
-    }
-    return this.#inputSelector.select({
-      utxo: new Set(Ogmios.ogmiosToCsl(this.#csl).utxo(this.availableUtxos)),
-      outputs,
-      constraints,
-      implicitCoin
-    });
-  }
-
-  public get allUtxos(): Schema.Utxo {
-    return [...this.#utxoSet.values()];
-  }
-
-  public get availableUtxos(): Schema.Utxo {
-    return this.allUtxos.filter((utxo) => !this.#lockedUtxoSet.has(utxo));
-  }
-
-  public get allRewards(): Ogmios.Lovelace | null {
-    return this.#delegationAndRewards.rewards ?? null;
-  }
-
-  public get availableRewards(): Ogmios.Lovelace | null {
-    if (!this.allRewards) return null;
-    return this.allRewards - this.#lockedRewards;
-  }
-
-  public get delegation(): Schema.PoolId | null {
-    return this.#delegationAndRewards.delegate ?? null;
-  }
-
-  #emitSynced() {
-    this.emit(UtxoRepositoryEvent.Changed, {
-      allUtxos: this.allUtxos,
-      availableUtxos: this.availableUtxos,
-      allRewards: this.allRewards,
-      availableRewards: this.availableRewards,
-      delegation: this.delegation
-    }).catch(this.#logger.error);
-  }
-
-  async #onTransaction({ transaction, confirmed }: OnTransactionArgs) {
-    // Lock reward
-    const rewardsLockedByTx = this.#getOwnTransactionWithdrawalQty(transaction);
-    this.#lockedRewards += rewardsLockedByTx;
-    // Lock utxo
-    const utxoLockedByTx: Schema.Utxo = [];
-    const inputs = transaction.body().inputs();
-    for (let inputIdx = 0; inputIdx < inputs.len(); inputIdx++) {
-      const { txId, index } = cslToOgmios.txIn(inputs.get(inputIdx));
-      const utxo = this.allUtxos.find(([txIn]) => txIn.txId === txId && txIn.index === index)!;
-      this.#lockedUtxoSet.add(utxo);
-      utxoLockedByTx.push(utxo);
-    }
-    this.#emitSynced();
-    // Await confirmation. Rejection should be handled by the user after submitting transaction.
-    await confirmed.catch(() => void 0);
-    // Unlock utxo
-    for (const utxo of utxoLockedByTx) {
-      this.#lockedUtxoSet.delete(utxo);
-    }
-    // Unlock rewards
-    this.#lockedRewards -= rewardsLockedByTx;
-    // Sync utxo and rewards with the provider
-    await this.#trySync();
-  }
-
-  async #trySync() {
-    try {
-      await this.sync();
-    } catch (error) {
-      this.#logger.debug('InMemoryUtxoRepository.#trySync failed:', error);
-      this.emit(UtxoRepositoryEvent.OutOfSync, void 0).catch(this.#logger.error);
-    }
-  }
-
-  #getOwnTransactionWithdrawalQty(transaction: CSL.Transaction) {
-    const withdrawals = transaction.body().withdrawals();
-    if (!withdrawals) return 0n;
-    const ownStakeCredential = this.#csl.StakeCredential.from_keyhash(this.#keyManager.stakeKey.hash());
-    const withdrawalKeys = withdrawals.keys();
-    let withdrawalTotal = 0n;
-    for (let withdrawalKeyIdx = 0; withdrawalKeyIdx < withdrawalKeys.len(); withdrawalKeyIdx++) {
-      const rewardAddress = withdrawalKeys.get(withdrawalKeyIdx);
-      if (cslUtil.bytewiseEquals(rewardAddress.payment_cred(), ownStakeCredential)) {
-        withdrawalTotal += BigInt(withdrawals.get(rewardAddress)!.to_str());
-      }
-    }
-    return withdrawalTotal;
-  }
-}

package/src/KeyManagement/InMemoryKeyManager.ts

@@ -1,67 +0,0 @@
-import * as bip39 from 'isomorphic-bip39';
-import { Cardano, CardanoSerializationLib, CSL } from '@cardano-sdk/core';
-import { Buffer } from 'buffer';
-import * as errors from './errors';
-import { KeyManager } from './types';
-import { harden, joinMnemonicWords } from './util';
-
-export const createInMemoryKeyManager = ({
-  csl,
-  password,
-  accountIndex,
-  mnemonicWords,
-  networkId
-}: {
-  csl: CardanoSerializationLib;
-  password: string;
-  accountIndex?: number;
-  mnemonicWords: string[];
-  networkId: Cardano.NetworkId;
-}): KeyManager => {
-  if (!accountIndex) {
-    accountIndex = 0;
-  }
-
-  const mnemonic = joinMnemonicWords(mnemonicWords);
-  const validMnemonic = bip39.validateMnemonic(mnemonic);
-  if (!validMnemonic) throw new errors.InvalidMnemonic();
-
-  const entropy = bip39.mnemonicToEntropy(mnemonic);
-  const accountPrivateKey = csl.Bip32PrivateKey.from_bip39_entropy(Buffer.from(entropy, 'hex'), Buffer.from(password))
-    .derive(harden(1852))
-    .derive(harden(1815))
-    .derive(harden(accountIndex));
-
-  const privateParentKey = accountPrivateKey.derive(0).derive(0);
-  const publicParentKey = privateParentKey.to_public();
-  const publicKey = accountPrivateKey.to_public();
-  const stakeKey = publicKey.derive(2).derive(0);
-
-  return {
-    deriveAddress: (addressIndex, index) => {
-      const utxoPubKey = publicKey.derive(index).derive(addressIndex);
-      const baseAddr = csl.BaseAddress.new(
-        networkId,
-        csl.StakeCredential.from_keyhash(utxoPubKey.to_raw_key().hash()),
-        csl.StakeCredential.from_keyhash(stakeKey.to_raw_key().hash())
-      );
-
-      return baseAddr.to_address().to_bech32();
-    },
-    signMessage: async (_addressType, _signingIndex, message) => ({
-      publicKey: publicParentKey.toString(),
-      signature: `Signature for ${message} is not implemented yet`
-    }),
-    signTransaction: async (txHash: CSL.TransactionHash) => {
-      const witnessSet = csl.TransactionWitnessSet.new();
-      const vkeyWitnesses = csl.Vkeywitnesses.new();
-      const vkeyWitness = csl.make_vkey_witness(txHash, privateParentKey.to_raw_key());
-      vkeyWitnesses.add(vkeyWitness);
-      witnessSet.set_vkeys(vkeyWitnesses);
-      return witnessSet;
-    },
-    stakeKey: stakeKey.to_raw_key(),
-    publicKey: publicKey.to_raw_key(),
-    publicParentKey: publicParentKey.to_raw_key()
-  };
-};

package/src/KeyManagement/errors/InvalidMnemonic.ts

@@ -1,9 +0,0 @@
-import { CustomError } from 'ts-custom-error';
-
-export class InvalidMnemonic extends CustomError {
-  constructor() {
-    super();
-    this.message = 'Invalid Mnemonic';
-    this.name = 'InvalidMnemonic';
-  }
-}

package/src/KeyManagement/types.ts

@@ -1,15 +0,0 @@
-import { CSL } from '@cardano-sdk/core';
-import { Address } from '..';
-
-export interface KeyManager {
-  deriveAddress: (addressIndex: number, index: 0 | 1) => string;
-  signMessage: (
-    addressType: Address.AddressType,
-    signingIndex: number,
-    message: string
-  ) => Promise<{ publicKey: string; signature: string }>;
-  publicKey: CSL.PublicKey;
-  publicParentKey: CSL.PublicKey;
-  signTransaction: (txHash: CSL.TransactionHash) => Promise<CSL.TransactionWitnessSet>;
-  stakeKey: CSL.PublicKey;
-}

package/src/KeyManagement/util.ts

@@ -1,14 +0,0 @@
-import * as bip39 from 'isomorphic-bip39';
-
-/**
- * A wrapper around the bip39 package function, with default strength applied to produce 24 words
- */
-export const generateMnemonicWords = (strength = 256) => bip39.generateMnemonic(strength).split(' ');
-export const joinMnemonicWords = (mnenomic: string[]) => mnenomic.join(' ');
-
-/**
- * A wrapper around the bip39 package function
- */
-export const validateMnemonic = bip39.validateMnemonic;
-
-export const harden = (num: number): number => 0x80_00_00_00 + num;

package/src/SingleAddressWallet.ts

@@ -1,120 +0,0 @@
-import Schema from '@cardano-ogmios/schema';
-import { CardanoProvider, Ogmios, Transaction, CardanoSerializationLib, CSL, ProviderError } from '@cardano-sdk/core';
-import { UtxoRepository } from './types';
-import { dummyLogger, Logger } from 'ts-log';
-import { defaultSelectionConstraints } from '@cardano-sdk/cip2';
-import { computeImplicitCoin, createTransactionInternals, InitializeTxProps, TxInternals } from './Transaction';
-import {
-  BalanceTracker,
-  InMemoryTransactionTracker,
-  KeyManagement,
-  TransactionError,
-  TransactionFailure,
-  TransactionTracker
-} from '.';
-
-export interface SubmitTxResult {
-  /**
-   * Resolves when transaction is submitted.
-   * Rejects with {TransactionError}.
-   */
-  submitted: Promise<void>;
-  /**
-   * Resolves when transaction is submitted and confirmed.
-   * Rejects with {TransactionError}.
-   */
-  confirmed: Promise<void>;
-}
-export interface SingleAddressWallet {
-  address: Schema.Address;
-  balance: BalanceTracker;
-  initializeTx: (props: InitializeTxProps) => Promise<TxInternals>;
-  name: string;
-  signTx: (body: CSL.TransactionBody, hash: CSL.TransactionHash) => Promise<CSL.Transaction>;
-  submitTx: (tx: CSL.Transaction) => SubmitTxResult;
-}
-
-export interface SingleAddressWalletDependencies {
-  csl: CardanoSerializationLib;
-  keyManager: KeyManagement.KeyManager;
-  logger?: Logger;
-  provider: CardanoProvider;
-  utxoRepository: UtxoRepository;
-  txTracker?: TransactionTracker;
-  balanceTracker?: BalanceTracker;
-}
-
-export interface SingleAddressWalletProps {
-  name: string;
-}
-
-const ensureValidityInterval = (
-  currentSlot: number,
-  validityInterval?: Transaction.ValidityInterval
-): Transaction.ValidityInterval =>
-  // Todo: Based this on slot duration, to equal 2hrs
-  ({ invalidHereafter: currentSlot + 3600, ...validityInterval });
-
-export const createSingleAddressWallet = async (
-  { name }: SingleAddressWalletProps,
-  {
-    csl,
-    provider,
-    keyManager,
-    utxoRepository,
-    txTracker = new InMemoryTransactionTracker({ csl, provider }),
-    balanceTracker = new BalanceTracker(utxoRepository),
-    logger = dummyLogger
-  }: SingleAddressWalletDependencies
-): Promise<SingleAddressWallet> => {
-  const address = keyManager.deriveAddress(0, 0);
-  const protocolParameters = await provider.currentWalletProtocolParameters();
-  const signTx = async (body: CSL.TransactionBody, hash: CSL.TransactionHash) => {
-    const witnessSet = await keyManager.signTransaction(hash);
-    return csl.Transaction.new(body, witnessSet);
-  };
-  return {
-    address,
-    balance: balanceTracker,
-    initializeTx: async (props) => {
-      const tip = await provider.ledgerTip();
-      const validityInterval = ensureValidityInterval(tip.slot, props.options?.validityInterval);
-      const txOutputs = new Set([...props.outputs].map((output) => Ogmios.ogmiosToCsl(csl).txOut(output)));
-      const constraints = defaultSelectionConstraints({
-        csl,
-        protocolParameters,
-        buildTx: async (inputSelection) => {
-          logger.debug('Building TX for selection constraints', inputSelection);
-          const { body, hash } = await createTransactionInternals(csl, {
-            changeAddress: address,
-            inputSelection,
-            validityInterval
-          });
-          return signTx(body, hash);
-        }
-      });
-      const implicitCoin = computeImplicitCoin(protocolParameters, props);
-      const inputSelectionResult = await utxoRepository.selectInputs(txOutputs, constraints, implicitCoin);
-      return createTransactionInternals(csl, {
-        changeAddress: address,
-        inputSelection: inputSelectionResult.selection,
-        validityInterval
-      });
-    },
-    name,
-    signTx,
-    submitTx: (tx) => {
-      const submitted = provider.submitTx(tx).catch((error) => {
-        if (error instanceof ProviderError) {
-          throw new TransactionError(TransactionFailure.FailedToSubmit, error, error.detail);
-        }
-        throw new TransactionError(TransactionFailure.FailedToSubmit, error);
-      });
-      const confirmed = txTracker.track(tx, submitted);
-      return {
-        submitted,
-        confirmed
-      };
-    }
-  };
-};

package/src/Transaction/CertificateFactory.ts

@@ -1,154 +0,0 @@
-import { ByName } from '@cardano-ogmios/schema';
-import { CardanoSerializationLib, CSL, NotImplementedError, Ogmios } from '@cardano-sdk/core';
-import { KeyManager } from '../KeyManagement';
-
-export type Ed25519KeyHashBech32 = string;
-export type VrfKeyHashBech32 = string;
-export type AddressBech32 = string;
-export type PoolMetadataHashBech32 = string;
-
-interface Ratio {
-  numerator: number;
-  denominator: number;
-}
-
-interface MultiHostNameRelay {
-  relayType: 'multihost-name';
-  dnsName: string;
-}
-
-type SingleHostAddrRelay = {
-  relayType: 'singlehost-addr';
-  ipv4?: string;
-  ipv6?: string;
-  port?: number;
-};
-
-type SingleHostNameRelay = {
-  relayType: 'singlehost-name';
-} & ByName;
-
-type Relay = MultiHostNameRelay | SingleHostAddrRelay | SingleHostNameRelay;
-
-interface PoolMetadata {
-  hash: PoolMetadataHashBech32;
-  url: string;
-}
-
-interface PoolParameters {
-  poolKeyHash: Ed25519KeyHashBech32;
-  vrfKeyHash: VrfKeyHashBech32;
-  pledge: Ogmios.Lovelace;
-  cost: Ogmios.Lovelace;
-  margin: Ratio;
-  rewardAddress: AddressBech32;
-  owners: Ed25519KeyHashBech32[];
-  relays: Relay[];
-  poolMetadata?: PoolMetadata;
-}
-
-export class CertificateFactory {
-  readonly #stakeCredential: CSL.StakeCredential;
-  readonly #csl: CardanoSerializationLib;
-
-  constructor(csl: CardanoSerializationLib, keyManager: KeyManager) {
-    this.#csl = csl;
-    this.#stakeCredential = csl.StakeCredential.from_keyhash(keyManager.stakeKey.hash());
-  }
-
-  stakeKeyRegistration() {
-    return this.#csl.Certificate.new_stake_registration(this.#csl.StakeRegistration.new(this.#stakeCredential));
-  }
-
-  stakeKeyDeregistration() {
-    return this.#csl.Certificate.new_stake_deregistration(this.#csl.StakeDeregistration.new(this.#stakeCredential));
-  }
-
-  poolRegistration({
-    poolKeyHash,
-    vrfKeyHash,
-    pledge,
-    cost,
-    margin,
-    rewardAddress,
-    owners,
-    relays,
-    poolMetadata
-  }: PoolParameters) {
-    const cslOwners = this.#csl.Ed25519KeyHashes.new();
-    for (const owner of owners) {
-      cslOwners.add(this.#csl.Ed25519KeyHash.from_bech32(owner));
-    }
-    const cslRelays = this.#createCslRelays(relays);
-    const poolParams = this.#csl.PoolParams.new(
-      this.#csl.Ed25519KeyHash.from_bech32(poolKeyHash),
-      this.#csl.VRFKeyHash.from_bech32(vrfKeyHash),
-      this.#csl.BigNum.from_str(pledge.toString()),
-      this.#csl.BigNum.from_str(cost.toString()),
-      this.#csl.UnitInterval.new(
-        this.#csl.BigNum.from_str(margin.numerator.toString()),
-        this.#csl.BigNum.from_str(margin.denominator.toString())
-      ),
-      this.#csl.RewardAddress.from_address(this.#csl.Address.from_bech32(rewardAddress))!,
-      cslOwners,
-      cslRelays,
-      poolMetadata
-        ? this.#csl.PoolMetadata.new(
-            this.#csl.URL.new(poolMetadata.url),
-            this.#csl.PoolMetadataHash.from_bech32(poolMetadata.hash)
-          )
-        : undefined
-    );
-    return this.#csl.Certificate.new_pool_registration(this.#csl.PoolRegistration.new(poolParams));
-  }
-
-  poolRetirement(poolKeyHash: Ed25519KeyHashBech32, epoch: number) {
-    return this.#csl.Certificate.new_pool_retirement(
-      this.#csl.PoolRetirement.new(this.#csl.Ed25519KeyHash.from_bech32(poolKeyHash), epoch)
-    );
-  }
-
-  stakeDelegation(delegatee: Ed25519KeyHashBech32) {
-    return this.#csl.Certificate.new_stake_delegation(
-      this.#csl.StakeDelegation.new(this.#stakeCredential, this.#csl.Ed25519KeyHash.from_bech32(delegatee))
-    );
-  }
-
-  #createCslRelays(relays: Relay[]) {
-    const cslRelays = this.#csl.Relays.new();
-    for (const relay of relays) {
-      switch (relay.relayType) {
-        case 'singlehost-addr':
-          if (relay.ipv6) {
-            throw new NotImplementedError('Parse IPv6 to byte array');
-          }
-          cslRelays.add(
-            this.#csl.Relay.new_single_host_addr(
-              this.#csl.SingleHostAddr.new(
-                relay.port,
-                relay.ipv4
-                  ? this.#csl.Ipv4.new(new Uint8Array(relay.ipv4.split('.').map((segment) => Number.parseInt(segment))))
-                  : undefined
-              )
-            )
-          );
-          break;
-        case 'singlehost-name':
-          cslRelays.add(
-            this.#csl.Relay.new_single_host_name(
-              this.#csl.SingleHostName.new(relay.port || undefined, this.#csl.DNSRecordAorAAAA.new(relay.hostname))
-            )
-          );
-          break;
-        case 'multihost-name':
-          cslRelays.add(
-            this.#csl.Relay.new_multi_host_name(this.#csl.MultiHostName.new(this.#csl.DNSRecordSRV.new(relay.dnsName)))
-          );
-          break;
-        default:
-          throw new NotImplementedError('Relay type');
-      }
-    }
-    return cslRelays;
-  }
-}

package/src/Transaction/computeImplicitCoin.ts

@@ -1,36 +0,0 @@
-import { ImplicitCoin } from '@cardano-sdk/cip2';
-import { BigIntMath, ProtocolParametersRequiredByWallet } from '@cardano-sdk/core';
-import { InitializeTxProps } from './types';
-
-/**
- * Implementation is the same as in csl.get_implicit_input() and csl.get_deposit().
- */
-export const computeImplicitCoin = (
-  { stakeKeyDeposit, poolDeposit }: ProtocolParametersRequiredByWallet,
-  { certificates, withdrawals }: InitializeTxProps
-): ImplicitCoin => {
-  const stakeKeyDepositBigint = stakeKeyDeposit && BigInt(stakeKeyDeposit);
-  const poolDepositBigint = poolDeposit && BigInt(poolDeposit);
-  const deposit = BigIntMath.sum(
-    certificates?.map(
-      (cert) =>
-        (cert.as_stake_registration() && stakeKeyDepositBigint) ||
-        (cert.as_pool_registration() && poolDepositBigint) ||
-        0n
-    ) || []
-  );
-  const withdrawalsTotal =
-    (withdrawals && BigIntMath.sum(withdrawals.map(({ quantity }) => BigInt(quantity.to_str())))) || 0n;
-  const reclaimTotal = BigIntMath.sum(
-    certificates?.map(
-      (cert) =>
-        (cert.as_stake_deregistration() && stakeKeyDepositBigint) ||
-        (cert.as_pool_retirement() && poolDepositBigint) ||
-        0n
-    ) || []
-  );
-  return {
-    deposit,
-    input: withdrawalsTotal + reclaimTotal
-  };
-};

package/src/Transaction/createTransactionInternals.ts

@@ -1,60 +0,0 @@
-import { SelectionResult } from '@cardano-sdk/cip2';
-import { Transaction, CardanoSerializationLib, CSL } from '@cardano-sdk/core';
-import { Withdrawal } from './withdrawal';
-
-export type TxInternals = {
-  hash: CSL.TransactionHash;
-  body: CSL.TransactionBody;
-};
-
-export type CreateTxInternalsProps = {
-  changeAddress: string;
-  inputSelection: SelectionResult['selection'];
-  validityInterval: Transaction.ValidityInterval;
-  certificates?: CSL.Certificate[];
-  withdrawals?: Withdrawal[];
-};
-
-export const createTransactionInternals = async (
-  csl: CardanoSerializationLib,
-  props: CreateTxInternalsProps
-): Promise<TxInternals> => {
-  const inputs = csl.TransactionInputs.new();
-  for (const utxo of props.inputSelection.inputs) {
-    inputs.add(utxo.input());
-  }
-  const outputs = csl.TransactionOutputs.new();
-  for (const output of props.inputSelection.outputs) {
-    outputs.add(output);
-  }
-  for (const value of props.inputSelection.change) {
-    outputs.add(csl.TransactionOutput.new(csl.Address.from_bech32(props.changeAddress), value));
-  }
-  const body = csl.TransactionBody.new(
-    inputs,
-    outputs,
-    props.inputSelection.fee,
-    props.validityInterval.invalidHereafter
-  );
-  if (props.validityInterval.invalidBefore !== undefined) {
-    body.set_validity_start_interval(props.validityInterval.invalidBefore);
-  }
-  if (props.certificates?.length) {
-    const certs = csl.Certificates.new();
-    for (const cert of props.certificates) {
-      certs.add(cert);
-    }
-    body.set_certs(certs);
-  }
-  if (props.withdrawals?.length) {
-    const withdrawals = csl.Withdrawals.new();
-    for (const { address, quantity } of props.withdrawals) {
-      withdrawals.insert(address, quantity);
-    }
-    body.set_withdrawals(withdrawals);
-  }
-  return {
-    body,
-    hash: csl.hash_transaction(body)
-  };
-};

package/src/Transaction/index.ts

@@ -1,5 +0,0 @@
-export * from './CertificateFactory';
-export * from './withdrawal';
-export * from './computeImplicitCoin';
-export * from './createTransactionInternals';
-export * from './types';

package/src/Transaction/types.ts

@@ -1,12 +0,0 @@
-import * as Schema from '@cardano-ogmios/schema';
-import { CSL, Transaction } from '@cardano-sdk/core';
-import { Withdrawal } from './withdrawal';
-
-export type InitializeTxProps = {
-  outputs: Set<Schema.TxOut>;
-  certificates?: CSL.Certificate[];
-  withdrawals?: Withdrawal[];
-  options?: {
-    validityInterval?: Transaction.ValidityInterval;
-  };
-};