feat!: update for Conway transaction fields Allow signing Conway transactions.… - input-output-hk/cardano-js-sdk@c32513bb - Cardano Updates

Home / Input Output / cardano-js-sdk / c32513bb

View on GitHub

File Changes

m

packages/key-management/src/InMemoryKeyAgent.ts

+7/-3

  SignTransactionOptions

} from './types';

import { Cardano } from '@cardano-sdk/core';

-

import { HexBlob } from '@cardano-sdk/util';

-

import { KeyAgentBase } from './KeyAgentBase';

import {

+

  DREP_KEY_DERIVATION_PATH,

  deriveAccountPrivateKey,

  harden,

  joinMnemonicWords,

  mnemonicWordsToEntropy,

  ownSignatureKeyPaths,

  validateMnemonic

} from './util';

+

import { HexBlob } from '@cardano-sdk/util';

+

import { KeyAgentBase } from './KeyAgentBase';

import { emip3decrypt, emip3encrypt } from './emip3';

import uniqBy from 'lodash/uniqBy';

  ): Promise<Cardano.Signatures> {

    // Possible optimization is casting strings to OpaqueString types directly and skipping validation

    const blob = HexBlob(hash);

-

    const derivationPaths = await ownSignatureKeyPaths(body, this.knownAddresses, this.inputResolver);

+

    const dRepKeyHash = (

+

      await Crypto.Ed25519PublicKey.fromHex(await this.derivePublicKey(DREP_KEY_DERIVATION_PATH)).hash()

+

    ).hex();

+

    const derivationPaths = await ownSignatureKeyPaths(body, this.knownAddresses, this.inputResolver, dRepKeyHash);

    const keyPaths = uniqBy([...derivationPaths, ...additionalKeyPaths], ({ role, index }) => `${role}.${index}`);

    // TODO:

    // if (keyPaths.length === 0) {

m

packages/key-management/src/util/ownSignatureKeyPaths.ts

+121/-12

import * as Crypto from '@cardano-sdk/crypto';

import { AccountKeyDerivationPath, GroupedAddress } from '../types';

import { Cardano } from '@cardano-sdk/core';

+

import { DREP_KEY_DERIVATION_PATH } from './key';

import { isNotNil } from '@cardano-sdk/util';

import isEqual from 'lodash/isEqual';

import uniq from 'lodash/uniq';

): SignatureCheck => {

  const signatureCheck: SignatureCheck = { derivationPaths: [], requiresForeignSignatures: false };

  switch (certificate.__typename) {

+

    case Cardano.CertificateType.VoteDelegation:

+

    case Cardano.CertificateType.StakeVoteDelegation:

+

    case Cardano.CertificateType.StakeRegistrationDelegation:

+

    case Cardano.CertificateType.VoteRegistrationDelegation:

+

    case Cardano.CertificateType.StakeVoteRegistrationDelegation:

+

    case Cardano.CertificateType.Unregistration:

    case Cardano.CertificateType.StakeKeyDeregistration:

    case Cardano.CertificateType.StakeDelegation: {

      const account = accounts.find((acct) => acct.stakeKeyHash === certificate.stakeKeyHash);

  return signatureCheck;

};

-

/**

-

 * Gets whether withdrawals or any certificate in the provided certificate list requires a stake key signature.

-

-

 * @param groupedAddresses The known grouped addresses.

-

 * @param txBody The transaction body.

-

*/

-

const getStakeCredentialKeyPaths = (groupedAddresses: GroupedAddress[], txBody: Cardano.TxBody) => {

-

  let requiresForeignSignatures = false;

-

  const paths: AccountKeyDerivationPath[] = [];

-

  const uniqueAccounts = uniqBy(groupedAddresses, 'rewardAccount')

+

const getSignersData = (groupedAddresses: GroupedAddress[]): StakeKeySignerData[] =>

+

  uniqBy(groupedAddresses, 'rewardAccount')

    .map((groupedAddress) => {

      const stakeKeyHash = Cardano.RewardAccount.toHash(groupedAddress.rewardAccount);

      const poolId = Cardano.PoolId.fromKeyHash(stakeKeyHash);

})

    .filter((acct): acct is StakeKeySignerData => acct.derivationPath !== undefined);

+

/**

+

 * Gets whether withdrawals or any certificate in the provided certificate list requires a stake key signature.

+

+

 * @param groupedAddresses The known grouped addresses.

+

 * @param txBody The transaction body.

+

*/

+

const getStakeCredentialKeyPaths = (groupedAddresses: GroupedAddress[], txBody: Cardano.TxBody) => {

+

  let requiresForeignSignatures = false;

+

  const paths: AccountKeyDerivationPath[] = [];

+

  const uniqueAccounts = getSignersData(groupedAddresses);

+

  const withdrawalCheck = checkWithdrawals(txBody, uniqueAccounts);

  requiresForeignSignatures ||= withdrawalCheck.requiresForeignSignatures;

  paths.push(...withdrawalCheck.derivationPaths);

  return { derivationPaths: new Set(paths), requiresForeignSignatures };

};

+

/**

+

 * Depending on transaction `voting_procedures = { + voter => { + gov_action_id => voting_procedure } }`

+

 * ; Constitutional Committee Hot KeyHash: 0

+

 * ; Constitutional Committee Hot ScriptHash: 1

+

 * ; DRep KeyHash: 2

+

 * ; DRep ScriptHash: 3

+

 * ; StakingPool KeyHash: 4

+

 * voter =

+

 *   [ 0, addr_keyhash

+

 *   // 1, scripthash

+

 *   // 2, addr_keyhash

+

 *   // 3, scripthash

+

 *   // 4, addr_keyhash

+

 *   ]

+

*/

+

export const getVotingProcedureKeyPaths = ({

+

  groupedAddresses,

+

  dRepKeyHash,

+

  txBody

+

}: {

+

  groupedAddresses: GroupedAddress[];

+

  dRepKeyHash?: Crypto.Ed25519KeyHashHex;

+

  txBody: Cardano.TxBody;

+

}): SignatureCheck => {

+

  const signatureCheck: SignatureCheck = { derivationPaths: [], requiresForeignSignatures: false };

+

+

  const accounts = getSignersData(groupedAddresses);

+

+

  for (const { voter } of txBody.votingProcedures || []) {

+

    switch (voter.__typename) {

+

      case Cardano.VoterType.dRepKeyHash: {

+

        if (dRepKeyHash && voter.credential.hash === Crypto.Hash28ByteBase16.fromEd25519KeyHashHex(dRepKeyHash)) {

+

          signatureCheck.derivationPaths.push(DREP_KEY_DERIVATION_PATH);

+

        } else {

+

          signatureCheck.requiresForeignSignatures = true;

+

+

        break;

+

+

      case Cardano.VoterType.stakePoolKeyHash: {

+

        const account = accounts.find(

+

          (acct) => Crypto.Hash28ByteBase16.fromEd25519KeyHashHex(acct.stakeKeyHash) === voter.credential.hash

+

);

+

        if (account) {

+

          signatureCheck.derivationPaths.push(account.derivationPath);

+

        } else {

+

          signatureCheck.requiresForeignSignatures = true;

+

+

        break;

+

+

      default:

+

        // case Cardano.VoterType.ccHotKeyHash:

+

        // case Cardano.VoterType.ccHotScriptHash:

+

        // case Cardano.VoterType.dRepScriptHash:

+

        signatureCheck.requiresForeignSignatures = true;

+

        break;

+

+

+

+

  return signatureCheck;

+

};

+

/**

 * Search for the key hashes provided in the requiredSigners in our current set of known addresses.

  return paths;

};

+

/** Check if there are certificates that require DRep credentials and if we own them */

+

export const getDRepCredentialKeyPaths = ({

+

  dRepKeyHash,

+

  txBody

+

}: {

+

  dRepKeyHash?: Crypto.Ed25519KeyHashHex;

+

  txBody: Cardano.TxBody;

+

}): SignatureCheck => {

+

  const signature: SignatureCheck = { derivationPaths: [], requiresForeignSignatures: false };

+

+

  for (const certificate of txBody.certificates || []) {

+

    if (

+

      certificate.__typename === Cardano.CertificateType.UnregisterDelegateRepresentative ||

+

      certificate.__typename === Cardano.CertificateType.UpdateDelegateRepresentative

+

      // Cardano.CertificateType.RegisterDelegateRepresentative does not require signing

+

) {

+

      if (

+

        certificate.dRepCredential.type === Cardano.CredentialType.ScriptHash ||

+

        !dRepKeyHash ||

+

        certificate.dRepCredential.hash !== Crypto.Hash28ByteBase16.fromEd25519KeyHashHex(dRepKeyHash)

+

) {

+

        // Scripts are foreign

+

        signature.requiresForeignSignatures = true;

+

      } else {

+

        // There's only one drep key that the wallet owns.

+

        signature.derivationPaths = [DREP_KEY_DERIVATION_PATH];

+

+

+

+

+

  return signature;

+

};

+

/**

 * Assumes that a single stake key is used for all addresses (index=0)

export const ownSignatureKeyPaths = async (

  txBody: Cardano.TxBody,

  knownAddresses: GroupedAddress[],

-

  inputResolver: Cardano.InputResolver

+

  inputResolver: Cardano.InputResolver,

+

  dRepKeyHash?: Crypto.Ed25519KeyHashHex

): Promise<AccountKeyDerivationPath[]> => {

  const txInputs = [...txBody.inputs, ...(txBody.collaterals ? txBody.collaterals : [])];

  const paymentKeyPaths = uniq(

    ).filter(isNotNil)

  ).map(({ type, index }) => ({ index, role: Number(type) }));

+

  // TODO: add `proposal_procedure` witnesses.

+

  return uniqWith(

      ...paymentKeyPaths,

      ...getStakeCredentialKeyPaths(knownAddresses, txBody).derivationPaths,

-

      ...getRequiredSignersKeyPaths(knownAddresses, txBody.requiredExtraSignatures)

+

      ...getDRepCredentialKeyPaths({ dRepKeyHash, txBody }).derivationPaths,

+

      ...getRequiredSignersKeyPaths(knownAddresses, txBody.requiredExtraSignatures),

+

      ...getVotingProcedureKeyPaths({ dRepKeyHash, groupedAddresses: knownAddresses, txBody }).derivationPaths

],

    isEqual

);

m

packages/key-management/src/util/stubSignTransaction.ts

+20/-8

const randomHexChar = () => Math.floor(Math.random() * 16).toString(16);

const randomPublicKey = () => Crypto.Ed25519PublicKeyHex(Array.from({ length: 64 }).map(randomHexChar).join(''));

-

export const stubSignTransaction = async (

-

  txBody: Cardano.TxBody,

-

  knownAddresses: GroupedAddress[],

-

  inputResolver: Cardano.InputResolver,

-

  extraSigners?: TransactionSigner[],

-

  { additionalKeyPaths = [] }: SignTransactionOptions = {}

-

): Promise<Cardano.Signatures> => {

+

export interface StubSignTransactionProps {

+

  txBody: Cardano.TxBody;

+

  knownAddresses: GroupedAddress[];

+

  inputResolver: Cardano.InputResolver;

+

  extraSigners?: TransactionSigner[];

+

  dRepPublicKey: Crypto.Ed25519PublicKeyHex;

+

  signTransactionOptions?: SignTransactionOptions;

+

+

+

export const stubSignTransaction = async ({

+

  txBody,

+

  knownAddresses,

+

  inputResolver,

+

  extraSigners,

+

  dRepPublicKey,

+

  signTransactionOptions = { additionalKeyPaths: [] }

+

}: StubSignTransactionProps): Promise<Cardano.Signatures> => {

+

  const { additionalKeyPaths = [] } = signTransactionOptions;

  const mockSignature = Crypto.Ed25519SignatureHex(

    // eslint-disable-next-line max-len

    'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'

);

+

  const dRepKeyHash = (await Crypto.Ed25519PublicKey.fromHex(dRepPublicKey).hash()).hex();

  const signatureKeyPaths = uniqWith(

-

    [...(await ownSignatureKeyPaths(txBody, knownAddresses, inputResolver)), ...additionalKeyPaths],

+

    [...(await ownSignatureKeyPaths(txBody, knownAddresses, inputResolver, dRepKeyHash)), ...additionalKeyPaths],

    deepEquals

);

m

packages/key-management/test/InMemoryKeyAgent.test.ts

+1/-1

      body,

      hash: Cardano.TransactionId('8561258e210352fba2ac0488afed67b3427a27ccf1d41ec030c98a8199bc22ec')

});

-

    expect(ownSignatureKeyPaths).toBeCalledWith(body, keyAgent.knownAddresses, inputResolver);

+

    expect(ownSignatureKeyPaths).toBeCalledWith(body, keyAgent.knownAddresses, inputResolver, expect.anything());

    expect(witnessSet.size).toBe(2);

    expect(typeof [...witnessSet.values()][0]).toBe('string');

});

m

packages/key-management/test/util/ownSignaturePaths.test.ts

+270/-5

  const ownStakeKeyHash = Cardano.RewardAccount.toHash(ownRewardAccount);

  const otherStakeKeyHash = Cardano.RewardAccount.toHash(otherRewardAccount);

+

  let dRepPublicKey: Crypto.Ed25519PublicKeyHex;

+

  let dRepKeyHash: Crypto.Ed25519KeyHashHex;

+

  const foreignDRepKeyHash = Crypto.Hash28ByteBase16('8293d319ef5b3ac72366dd28006bd315b715f7e7cfcbd3004129b80d');

+

  const knownAddress1 = createGroupedAddress(address1, ownRewardAccount, AddressType.External, 0, stakeKeyPath);

+

  beforeEach(async () => {

+

    dRepPublicKey = Crypto.Ed25519PublicKeyHex('deeb8f82f2af5836ebbc1b450b6dbf0b03c93afe5696f10d49e8a8304ebfac01');

+

    dRepKeyHash = (await Crypto.Ed25519PublicKey.fromHex(dRepPublicKey).hash()).hex();

+

});

+

  it('returns distinct derivation paths required to sign the transaction', async () => {

    const txBody = {

      inputs: [{}, {}, {}]

]);

});

-

  // eslint-disable-next-line max-len

-

  it('does not return stake key derivation path when no certificate with wallet stake key hash is present', async () => {

+

  it('does not return derivation paths when all certificates and voting procedures are foreign', async () => {

    const txBody = {

-

      certificates: [{ __typename: Cardano.CertificateType.StakeKeyRegistration, stakeKeyHash: otherStakeKeyHash }],

-

      inputs: [{}, {}, {}]

+

      certificates: [

+

        { __typename: Cardano.CertificateType.StakeKeyRegistration, stakeKeyHash: otherStakeKeyHash },

+

        { __typename: Cardano.CertificateType.VoteDelegation, stakeKeyHash: otherStakeKeyHash },

+

        { __typename: Cardano.CertificateType.StakeVoteDelegation, stakeKeyHash: otherStakeKeyHash },

+

+

          __typename: Cardano.CertificateType.StakeRegistrationDelegation,

+

          stakeKeyHash: otherStakeKeyHash

+

},

+

+

          __typename: Cardano.CertificateType.VoteRegistrationDelegation,

+

          stakeKeyHash: otherStakeKeyHash

+

},

+

+

          __typename: Cardano.CertificateType.StakeVoteRegistrationDelegation,

+

          stakeKeyHash: otherStakeKeyHash

+

},

+

        { __typename: Cardano.CertificateType.Unregistration, otherStakeKeyHash },

+

+

          __typename: Cardano.CertificateType.UnregisterDelegateRepresentative,

+

          dRepCredential: {

+

            hash: foreignDRepKeyHash,

+

            type: Cardano.CredentialType.KeyHash

+

},

+

          deposit: 0n

+

        } as Cardano.UnRegisterDelegateRepresentativeCertificate,

+

+

          __typename: Cardano.CertificateType.UpdateDelegateRepresentative,

+

          dRepCredential: {

+

            hash: foreignDRepKeyHash,

+

            type: Cardano.CredentialType.KeyHash

+

+

        } as Cardano.UpdateDelegateRepresentativeCertificate

+

],

+

      fee: 0n,

+

      inputs: [{}, {}, {}] as Cardano.TxIn[],

+

      outputs: [],

+

      votingProcedures: [

+

+

          voter: {

+

            __typename: Cardano.VoterType.dRepKeyHash,

+

            credential: { hash: foreignDRepKeyHash, type: Cardano.CredentialType.KeyHash }

+

},

+

          votes: []

+

},

+

+

          voter: {

+

            __typename: Cardano.VoterType.stakePoolKeyHash,

+

            credential: {

+

              hash: Crypto.Hash28ByteBase16(otherStakeKeyHash),

+

              type: Cardano.CredentialType.KeyHash

+

+

},

+

          votes: []

+

+

    } as Cardano.TxBody;

    const resolveInput = jest

      .fn()

      .mockReturnValueOnce({ ...txOut, address: address1 })

      .mockReturnValueOnce(address1);

-

    expect(await util.ownSignatureKeyPaths(txBody, [knownAddress1], { resolveInput })).toEqual([

+

    expect(await util.ownSignatureKeyPaths(txBody, [knownAddress1], { resolveInput }, dRepKeyHash)).toEqual([

        index: 0,

        role: KeyRole.External

]);

});

+

+

  describe('Stake key derivation path', () => {

+

    const rewardAccounts = [

+

      'stake_test1uqfu74w3wh4gfzu8m6e7j987h4lq9r3t7ef5gaw497uu85qsqfy27',

+

      'stake_test1up7pvfq8zn4quy45r2g572290p9vf99mr9tn7r9xrgy2l2qdsf58d',

+

      'stake_test1uqrw9tjymlm8wrwq7jk68n6v7fs9qz8z0tkdkve26dylmfc2ux2hj',

+

      'stake_test1uzwd0ng8pw7vvhm4k3s28azx9c6ytug60uh35jvztgg03rge58jf8',

+

      'stake_test1urpklgzqsh9yqz8pkyuxcw9dlszpe5flnxjtl55epla6ftqktdyfz',

+

      'stake_test1upqykkjq3zhf4085s6n70w8cyp57dl87r0ezduv9rnnj2uqk5zmdv'

+

+

      .map((acct) => ({ account: Cardano.RewardAccount(acct) }))

+

      .map(({ account }) => ({ account, stakeKeyHash: Cardano.RewardAccount.toHash(account) }));

+

+

    // Using multiple stake keys with one payment key to have separate derivation paths per each certificate

+

    const knownAddresses = rewardAccounts.map(({ account }, index) =>

+

      createGroupedAddress(address1, account, AddressType.External, 0, { index, role: KeyRole.Stake })

+

);

+

+

    it('is returned for certificates with the wallet stake key hash', async () => {

+

      const txBody = {

+

        certificates: [

+

          { __typename: Cardano.CertificateType.VoteDelegation, stakeKeyHash: rewardAccounts[0].stakeKeyHash },

+

          { __typename: Cardano.CertificateType.StakeVoteDelegation, stakeKeyHash: rewardAccounts[1].stakeKeyHash },

+

+

            __typename: Cardano.CertificateType.StakeRegistrationDelegation,

+

            stakeKeyHash: rewardAccounts[2].stakeKeyHash

+

},

+

+

            __typename: Cardano.CertificateType.VoteRegistrationDelegation,

+

            stakeKeyHash: rewardAccounts[3].stakeKeyHash

+

},

+

+

            __typename: Cardano.CertificateType.StakeVoteRegistrationDelegation,

+

            stakeKeyHash: rewardAccounts[4].stakeKeyHash

+

},

+

          { __typename: Cardano.CertificateType.Unregistration, stakeKeyHash: rewardAccounts[5].stakeKeyHash }

+

],

+

        inputs: [{}, {}, {}]

+

      } as Cardano.TxBody;

+

      const resolveInput = jest

+

        .fn()

+

        .mockReturnValueOnce({ ...txOut, address: address1 })

+

        .mockReturnValueOnce(address1);

+

      expect(await util.ownSignatureKeyPaths(txBody, knownAddresses, { resolveInput })).toEqual([

+

        { index: 0, role: KeyRole.External },

+

        { index: 0, role: KeyRole.Stake },

+

        { index: 1, role: KeyRole.Stake },

+

        { index: 2, role: KeyRole.Stake },

+

        { index: 3, role: KeyRole.Stake },

+

        { index: 4, role: KeyRole.Stake },

+

        { index: 5, role: KeyRole.Stake }

+

]);

+

});

+

+

    it('duplicates are removed when multiple certificates use the wallet stake key hash', async () => {

+

      const txBody = {

+

        certificates: [

+

          { __typename: Cardano.CertificateType.VoteDelegation, stakeKeyHash: rewardAccounts[0].stakeKeyHash },

+

          { __typename: Cardano.CertificateType.StakeVoteDelegation, stakeKeyHash: rewardAccounts[0].stakeKeyHash }

+

],

+

        inputs: [{}, {}, {}]

+

      } as Cardano.TxBody;

+

      const resolveInput = jest

+

        .fn()

+

        .mockReturnValueOnce({ ...txOut, address: address1 })

+

        .mockReturnValueOnce(address1);

+

      expect(await util.ownSignatureKeyPaths(txBody, knownAddresses, { resolveInput })).toEqual([

+

        { index: 0, role: KeyRole.External },

+

        { index: 0, role: KeyRole.Stake }

+

]);

+

});

+

+

    it('is returned for StakePool voter in voting procedures', async () => {

+

      const txBody = {

+

        fee: 0n,

+

        inputs: [{}, {}, {}] as Cardano.TxIn[],

+

        outputs: [],

+

        votingProcedures: [

+

+

            voter: {

+

              __typename: Cardano.VoterType.stakePoolKeyHash,

+

              credential: {

+

                hash: Crypto.Hash28ByteBase16(rewardAccounts[3].stakeKeyHash),

+

                type: Cardano.CredentialType.KeyHash

+

+

},

+

            votes: []

+

+

+

      } as Cardano.TxBody;

+

+

      const resolveInput = jest

+

        .fn()

+

        .mockReturnValueOnce({ ...txOut, address: address1 })

+

        .mockReturnValueOnce(address1);

+

      expect(await util.ownSignatureKeyPaths(txBody, knownAddresses, { resolveInput })).toEqual([

+

        { index: 0, role: KeyRole.External },

+

        { index: 3, role: KeyRole.Stake }

+

]);

+

});

+

});

+

+

  describe('DRep key derivation path', () => {

m

packages/key-management/test/util/stubSignTransaction.test.ts

+7/-3

import { Cardano } from '@cardano-sdk/core';

+

import { Ed25519PublicKey, Ed25519PublicKeyHex } from '@cardano-sdk/crypto';

+

import { GroupedAddress, util } from '../../src';

jest.mock('../../src/util/ownSignatureKeyPaths');

    const inputResolver = {} as Cardano.InputResolver; // not called

    const txBody = {} as Cardano.HydratedTxBody;

    const knownAddresses = [{} as GroupedAddress];

+

    const dRepPublicKey = Ed25519PublicKeyHex('0b1c96fad4179d7910bd9485ac28c4c11368c83d18d01b29d4cf84d8ff6a06c4');

+

    const dRepKeyHash = (await Ed25519PublicKey.fromHex(dRepPublicKey).hash()).hex();

    ownSignatureKeyPaths.mockReturnValueOnce(['a']).mockReturnValueOnce(['a', 'b']);

-

    expect((await util.stubSignTransaction(txBody, knownAddresses, inputResolver)).size).toBe(1);

-

    expect((await util.stubSignTransaction(txBody, knownAddresses, inputResolver)).size).toBe(2);

-

    expect(ownSignatureKeyPaths).toBeCalledWith(txBody, knownAddresses, inputResolver);

+

    expect((await util.stubSignTransaction({ dRepPublicKey, inputResolver, knownAddresses, txBody })).size).toBe(1);

+

    expect((await util.stubSignTransaction({ dRepPublicKey, inputResolver, knownAddresses, txBody })).size).toBe(2);

+

    expect(ownSignatureKeyPaths).toBeCalledWith(txBody, knownAddresses, inputResolver, dRepKeyHash);

});

});

m

packages/tx-construction/src/tx-builder/finalizeTx.ts

+7/-6

  stubSign = false

): Promise<SignedTx> => {

  const signatures = stubSign

-

    ? await keyManagementUtil.stubSignTransaction(

-

        tx.body,

-

        ownAddresses,

+

    ? await keyManagementUtil.stubSignTransaction({

+

        dRepPublicKey: await keyAgent.derivePublicKey(keyManagementUtil.DREP_KEY_DERIVATION_PATH),

+

        extraSigners: witness?.extraSigners,

        inputResolver,

-

        witness?.extraSigners,

-

        signingOptions

-

+

        knownAddresses: ownAddresses,

+

        signTransactionOptions: signingOptions,

+

        txBody: tx.body

+

})

    : await getSignatures(keyAgent, tx, witness?.extraSigners, signingOptions);

  const transaction = {

m

packages/util-dev/src/StubKeyAgent.ts

+21/-3

import * as Crypto from '@cardano-sdk/crypto';

-

import { AsyncKeyAgent, GroupedAddress, SignBlobResult, util } from '@cardano-sdk/key-management';

+

import {

+

  AccountKeyDerivationPath,

+

  AsyncKeyAgent,

+

  GroupedAddress,

+

  SignBlobResult,

+

  util

+

} from '@cardano-sdk/key-management';

import { BehaviorSubject, firstValueFrom } from 'rxjs';

import { Cardano } from '@cardano-sdk/core';

import { generateRandomHexString } from './dataGeneration';

const NOT_IMPLEMENTED = 'Method not implemented';

export class StubKeyAgent implements AsyncKeyAgent {

+

  static readonly dRepPubKey = Crypto.Ed25519PublicKeyHex(

+

    '0b1c96fad4179d7910bd9485ac28c4c11368c83d18d01b29d4cf84d8ff6a06c4'

+

);

+

  knownAddresses$ = new BehaviorSubject<GroupedAddress[]>([]);

  constructor(private inputResolver: Cardano.InputResolver) {}

  deriveAddress(): Promise<GroupedAddress> {

    throw new Error(NOT_IMPLEMENTED);

-

  derivePublicKey(): Promise<Crypto.Ed25519PublicKeyHex> {

+

  derivePublicKey(derivationPath: AccountKeyDerivationPath): Promise<Crypto.Ed25519PublicKeyHex> {

+

    if (derivationPath.role === util.DREP_KEY_DERIVATION_PATH.role) {

+

      return Promise.resolve(StubKeyAgent.dRepPubKey);

+

    throw new Error(NOT_IMPLEMENTED);

  signBlob(): Promise<SignBlobResult> {

  async signTransaction(txInternals: Cardano.TxBodyWithHash): Promise<Cardano.Signatures> {

    const signatures = new Map<Crypto.Ed25519PublicKeyHex, Crypto.Ed25519SignatureHex>();

    const knownAddresses = await firstValueFrom(this.knownAddresses$);

-

    for (const _ of await util.ownSignatureKeyPaths(txInternals.body, knownAddresses, this.inputResolver)) {

+

    for (const _ of await util.ownSignatureKeyPaths(

+

      txInternals.body,

+

      knownAddresses,

+

      this.inputResolver,

+

      Crypto.Ed25519KeyHashHex('f15db05f56035465bf8900a09bdaa16c3d8b8244fea686524408dd80')

+

    )) {

      signatures.set(

        Crypto.Ed25519PublicKeyHex(generateRandomHexString(64)),

        Crypto.Ed25519SignatureHex(generateRandomHexString(128))

m

packages/wallet/src/services/WalletUtil.ts

+15/-1

/* eslint-disable no-bitwise */

+

import * as Crypto from '@cardano-sdk/crypto';

import { Cardano } from '@cardano-sdk/core';

import { util as KeyManagementUtil } from '@cardano-sdk/key-management';

import { Observable, firstValueFrom } from 'rxjs';

  utxoSet: Cardano.Utxo[]

): boolean => [...inputs, ...collaterals].some((txIn) => utxoSet.every((utxo) => !txInEquals(txIn, utxo[0])));

+

/** Wallet does not include committee certificate keys, so they cannot be signed  */

+

const hasCommitteeCertificates = ({ certificates }: Cardano.TxBody) =>

+

  (certificates || []).some(

+

    (certificate) =>

+

      certificate.__typename === Cardano.CertificateType.AuthorizeCommitteeHot ||

+

      certificate.__typename === Cardano.CertificateType.ResignCommitteeCold

+

);

/**

 * Gets whether the given TX requires signatures that can not be provided by the given wallet.

})

    .filter((acct): acct is KeyManagementUtil.StakeKeySignerData => acct.derivationPath !== null);

+

  const dRepKeyHash = (await Crypto.Ed25519PublicKey.fromHex(await wallet.getPubDRepKey()).hash()).hex();

+

  return (

    hasForeignInputs(tx, utxoSet) ||

-

    KeyManagementUtil.checkStakeCredentialCertificates(uniqueAccounts, tx.body).requiresForeignSignatures

+

    KeyManagementUtil.checkStakeCredentialCertificates(uniqueAccounts, tx.body).requiresForeignSignatures ||

+

    KeyManagementUtil.getDRepCredentialKeyPaths({ dRepKeyHash, txBody: tx.body }).requiresForeignSignatures ||

+

    KeyManagementUtil.getVotingProcedureKeyPaths({ dRepKeyHash, groupedAddresses: knownAddresses, txBody: tx.body })

+

      .requiresForeignSignatures ||

+

    hasCommitteeCertificates(tx.body)

);

};

m

packages/wallet/test/services/WalletUtil.test.ts

+274/-0

);

    const foreignRewardAccountHash = Cardano.RewardAccount.toHash(foreignRewardAccount);

+

    let dRepCredential: Crypto.Ed25519PublicKeyHex;

+

    let dRepKeyHash: Crypto.Hash28ByteBase16;

+

    const foreignDRepKeyHash = Crypto.Hash28ByteBase16('8293d319ef5b3ac72366dd28006bd315b715f7e7cfcbd3004129b80d');

+

    beforeEach(async () => {

      txSubmitProvider = mocks.mockTxSubmitProvider();

      networkInfoProvider = mocks.mockNetworkInfoProvider();

};

      tx = await wallet.finalizeTx({ tx: await wallet.initializeTx(props) });

+

+

      dRepCredential = await wallet.getPubDRepKey();

+

      dRepKeyHash = Crypto.Hash28ByteBase16.fromEd25519KeyHashHex(

+

        (await Crypto.Ed25519PublicKey.fromHex(dRepCredential).hash()).hex()

+

);

});

    afterEach(() => {

];

        expect(await requiresForeignSignatures(tx, wallet)).toBeFalsy();

});

+

+

      it('accepts valid conway certificates', async () => {

+

        tx.body.certificates = [

+

+

            __typename: Cardano.CertificateType.Registration,

+

            // using foreign intentionally because registration is not signed so it should be accepted

+

            stakeKeyHash: foreignRewardAccountHash

+

          } as Cardano.NewStakeAddressCertificate,

+

+

            __typename: Cardano.CertificateType.Unregistration,

+

            stakeKeyHash: mocks.stakeKeyHash

+

          } as Cardano.NewStakeAddressCertificate,

+

+

            __typename: Cardano.CertificateType.VoteDelegation,

+

            stakeKeyHash: mocks.stakeKeyHash

+

          } as Cardano.VoteDelegationCertificate,

+

+

            __typename: Cardano.CertificateType.StakeVoteDelegation,

+

            stakeKeyHash: mocks.stakeKeyHash

+

          } as Cardano.StakeVoteDelegationCertificate,

+

+

            __typename: Cardano.CertificateType.StakeRegistrationDelegation,

+

            stakeKeyHash: mocks.stakeKeyHash

+

          } as Cardano.StakeRegistrationDelegationCertificate,

+

+

            __typename: Cardano.CertificateType.VoteRegistrationDelegation,

+

            stakeKeyHash: mocks.stakeKeyHash

+

          } as Cardano.VoteRegistrationDelegationCertificate,

+

+

            __typename: Cardano.CertificateType.StakeVoteRegistrationDelegation,

+

            stakeKeyHash: mocks.stakeKeyHash

+

          } as Cardano.StakeVoteRegistrationDelegationCertificate,

+

          ...tx.body.certificates!

+

];

+

+

        expect(await requiresForeignSignatures(tx, wallet)).toBeFalsy();

+

});

+

+

      it('detects foreign VoteDelegation', async () => {

+

        tx.body.certificates = [

+

+

            __typename: Cardano.CertificateType.VoteDelegation,

+

            stakeKeyHash: foreignRewardAccountHash

+

          } as Cardano.VoteDelegationCertificate,

+

          ...tx.body.certificates!

+

];

+

+

        expect(await requiresForeignSignatures(tx, wallet)).toBeTruthy();

+

});

+

+

      it('detects foreign StakeVoteDelegation', async () => {

+

        tx.body.certificates = [

+

+

            __typename: Cardano.CertificateType.StakeVoteDelegation,

+

            stakeKeyHash: foreignRewardAccountHash

+

          } as Cardano.StakeVoteDelegationCertificate,

+

          ...tx.body.certificates!

+

];

+

+

        expect(await requiresForeignSignatures(tx, wallet)).toBeTruthy();

+

});

+

+

      it('detects foreign StakeRegistrationDelegation', async () => {

+

        tx.body.certificates = [

+

+

            __typename: Cardano.CertificateType.StakeRegistrationDelegation,

+

            stakeKeyHash: foreignRewardAccountHash

+

          } as Cardano.StakeRegistrationDelegationCertificate,

+

          ...tx.body.certificates!

+

];

+

+

        expect(await requiresForeignSignatures(tx, wallet)).toBeTruthy();

+

});

+

+

      it('detects foreign VoteRegistrationDelegation', async () => {

+

        tx.body.certificates = [

+

+

            __typename: Cardano.CertificateType.VoteRegistrationDelegation,

+

            stakeKeyHash: foreignRewardAccountHash

+

          } as Cardano.VoteRegistrationDelegationCertificate,

+

          ...tx.body.certificates!

+

];

+

+

        expect(await requiresForeignSignatures(tx, wallet)).toBeTruthy();

+

});

+

+

      it('detects foreign stake_vote_reg_deleg_cert', async () => {

+

        tx.body.certificates = [

+

+

            __typename: Cardano.CertificateType.StakeVoteRegistrationDelegation,

+

            stakeKeyHash: foreignRewardAccountHash

+

          } as Cardano.StakeVoteRegistrationDelegationCertificate,

+

          ...tx.body.certificates!

+

];

+

+

        expect(await requiresForeignSignatures(tx, wallet)).toBeTruthy();

+

});

+

+

      it('detects foreign Unregistration', async () => {

+

        tx.body.certificates = [

+

+

            __typename: Cardano.CertificateType.Unregistration,

+

            stakeKeyHash: foreignRewardAccountHash

+

          } as Cardano.NewStakeAddressCertificate,

+

          ...tx.body.certificates!

+

];

+

+

        expect(await requiresForeignSignatures(tx, wallet)).toBeTruthy();

+

});

});

    describe('MIR certificates', () => {

        expect(tx.body.certificates!.length).toBe(2);

        expect(await requiresForeignSignatures(tx, wallet)).toBeTruthy();

});

+

+

      it('detects as foreign if type is "toOtherPot"', async () => {

+

        tx.body.certificates = [

+

+

            __typename: Cardano.CertificateType.MIR,

+

            kind: Cardano.MirCertificateKind.ToOtherPot

+

          } as Cardano.MirCertificate,

+

          ...tx.body.certificates!

+

];

+

+

        expect(await requiresForeignSignatures(tx, wallet)).toBeTruthy();

+

});

});

    describe('inputs and collaterals', () => {

        expect(await requiresForeignSignatures(tx, wallet)).toBeTruthy();

});

});

+

+

    describe('Voting procedures', () => {

+

      it('accepts dRep and stakePool voters', async () => {

+

        tx.body.votingProcedures = [

+

+

            voter: {

+

              __typename: Cardano.VoterType.dRepKeyHash,

+

              credential: { hash: dRepKeyHash, type: Cardano.CredentialType.KeyHash }

+

},

+

            votes: []

+

},

+

+

            voter: {

+

              __typename: Cardano.VoterType.stakePoolKeyHash,

+

              credential: { hash: Crypto.Hash28ByteBase16(mocks.stakeKeyHash), type: Cardano.CredentialType.KeyHash }

+

},

+

            votes: []

+

+

];

+

+

        expect(await requiresForeignSignatures(tx, wallet)).toBeFalsy();

+

});

+

+

      it('detects foreign dRep voter credentials', async () => {

+

        tx.body.votingProcedures = [

+

+

            voter: {

+

              __typename: Cardano.VoterType.dRepKeyHash,

+

              credential: { hash: foreignDRepKeyHash, type: Cardano.CredentialType.KeyHash }

+

},

+

            votes: []

+

+

];

+

        expect(await requiresForeignSignatures(tx, wallet)).toBeTruthy();

+

});

+

+

      it('detects foreign stakePool voter credentials', async () => {

+

        tx.body.votingProcedures = [

m

yarn-project.nix

+0/-1

"fs-minipass@npm:3.0.0" = { filename = "fs-minipass-npm-3.0.0-3692c14b65-b72e9fe426.zip"; sha512 = "b72e9fe426e39f05b35bf237c8218b7ab3f68a65f325725ad7b4e431ff5a10725946fc62883b78446c07515ab938d25fdde3d08fb5ac8693f7f9eb9990da21f0"; };

"fs.realpath@npm:1.0.0" = { filename = "fs.realpath-npm-1.0.0-c8f05d8126-99ddea01a7.zip"; sha512 = "99ddea01a7e75aa276c250a04eedeffe5662bce66c65c07164ad6264f9de18fb21be9433ead460e54cff20e31721c811f4fb5d70591799df5f85dce6d6746fd0"; };

"fsevents@npm:2.3.2" = { filename = "fsevents-npm-2.3.2-a881d6ac9f-97ade64e75.zip"; sha512 = "97ade64e75091afee5265e6956cb72ba34db7819b4c3e94c431d4be2b19b8bb7a2d4116da417950c3425f17c8fe693d25e20212cac583ac1521ad066b77ae31f"; };

-

"fsevents@patch:fsevents@npm%3A2.3.2#~builtin<compat/fsevents>::version=2.3.2&hash=18f3a7" = { filename = "fsevents-patch-3340e2eb10-8.zip"; sha512 = "edbd0fd80be379c14409605f77e52fdc78a119e17f875e8b90a220c3e5b29e54a1477c21d91fd30b957ea4866406dc3ff87b61432d2840ff8866b309e5866140"; };

"ftp@npm:0.3.10" = { filename = "ftp-npm-0.3.10-348fb9ac23-ddd313c1d4.zip"; sha512 = "ddd313c1d44eb7429f3a7d77a0155dc8fe86a4c64dca58f395632333ce4b4e74c61413c6e0ef66ea3f3d32d905952fbb6d028c7117d522f793eb1fa282e17357"; };

"function-bind@npm:1.1.1" = { filename = "function-bind-npm-1.1.1-b56b322ae9-b32fbaebb3.zip"; sha512 = "b32fbaebb3f8ec4969f033073b43f5c8befbb58f1a79e12f1d7490358150359ebd92f49e72ff0144f65f2c48ea2a605bff2d07965f548f6474fd8efd95bf361a"; };

"function.prototype.name@npm:1.1.5" = { filename = "function.prototype.name-npm-1.1.5-e776a642bb-acd21d733a.zip"; sha512 = "acd21d733a9b649c2c442f067567743214af5fa248dbeee69d8278ce7df3329ea5abac572be9f7470b4ec1cd4d8f1040e3c5caccf98ebf2bf861a0deab735c27"; };

Yesterday's Report

Friday, December 1, 2023

606 commits in 72 repos

New Repo Discovered

Thu, 30 Nov 23 15:26:13 +0000 · cf-cip-frontend

JavaScript · No license

New Releases

Fri, 01 Dec 23 15:57:24 +0000 · Cardano Node 8.7.1-pre cardano-node Fri, 01 Dec 23 14:10:59 +0000 · lace-extension 1.7.1 lace Thu, 30 Nov 23 16:12:11 +0000 · Unstable Development Builds mithril Thu, 30 Nov 23 14:25:10 +0000 · PRISM Wallet SDK TypeScript v3.1.0 atala-prism-wallet-sdk-ts Thu, 30 Nov 23 14:21:39 +0000 · Atala PRISM Wallet SDK KMM v2.6.0 atala-prism-wallet-sdk-kmm Thu, 30 Nov 23 10:20:53 +0000 · v0.1.1 adahandle-resolver

3,913 commits this week Nov 25, 2023 - Dec 02, 2023

Showing 25 of 3913 recent commits.