- PersonalWallet has a new optional prop in the constructor: handlePolicyIds - Add some handle-related data to mockProviders in `util-dev`, update affected tests
import { Asset, Cardano } from '@cardano-sdk/core';
import { handleAssetId, handleAssetName, handleFingerprint, handlePolicyId } from './mockData';
export const asset = {
export const asset: Asset.AssetInfo = {
assetId: Cardano.AssetId('659f2917fb63f12b33667463ee575eeac1845bbc736b9c0bbc40ba8254534c41'),
fingerprint: Cardano.AssetFingerprint('asset1rjklcrnsdzqp65wjgrg55sy9723kw09mlgvlc3'),
history: [
transactionId: Cardano.TransactionId('886206542d63b23a047864021fbfccf291d78e47c1e59bd4c75fbc67b248c5e8')
}
],
mintOrBurnCount: 5,
name: Cardano.AssetName('54534c41'),
nftMetadata: null,
policyId: Cardano.PolicyId('7eae28af2208be856f7a119668ae52a49b73725e326dc16579dcc373'),
quantity: 1000n,
supply: 1000n,
tokenMetadata: null
} as Asset.AssetInfo;
};
export const handleAssetInfo: Asset.AssetInfo = {
assetId: handleAssetId,
fingerprint: handleFingerprint,
mintOrBurnCount: 1,
name: handleAssetName,
policyId: handlePolicyId,
quantity: 1n,
supply: 1n
};
export const mockAssetProvider = () => ({
getAsset: jest.fn().mockResolvedValue(asset),
getAssets: jest.fn().mockResolvedValue([asset]),
getAssets: jest
.fn()
.mockImplementation(async ({ assetIds }) =>
assetIds.map((assetId: Cardano.AssetId) => (assetId === handleAssetId ? handleAssetInfo : asset))
),
healthCheck: jest.fn().mockResolvedValue({ ok: true })
});
import * as AssetId from '../assetId';
import { Cardano, Paginated } from '@cardano-sdk/core';
import { currentEpoch, ledgerTip, stakeKeyHash } from './mockData';
import { currentEpoch, handleAssetId, ledgerTip, stakeKeyHash } from './mockData';
import { somePartialStakePools } from '../createStubStakePoolProvider';
import delay from 'delay';
address: Cardano.PaymentAddress(
'addr_test1qq585l3hyxgj3nas2v3xymd23vvartfhceme6gv98aaeg9muzcjqw982pcftgx53fu5527z2cj2tkx2h8ux2vxsg475q2g7k3g'
),
value: { assets: new Map([[AssetId.TSLA, 1n]]), coins: 5_000_000n }
value: {
assets: new Map([
[AssetId.TSLA, 1n],
[handleAssetId, 1n]
]),
coins: 5_000_000n
}
}
],
validityInterval: {
export const rewardAccountBalance = 33_333n;
export const handlePolicyId = Cardano.PolicyId('f0ff48bbb7bbe9d59a40f1ce90e9e9d0ff5002ec48f232b49ca0fb9a');
export const handle = 'bob';
export const handleAssetId = Cardano.AssetId.fromParts(
handlePolicyId,
Cardano.AssetName(Buffer.from('bob').toString('hex'))
);
export const handleAssetName = Cardano.AssetName(Buffer.from(handle, 'utf8').toString('hex'));
export const handleFingerprint = Cardano.AssetFingerprint('asset1f0azzptnr8dghzjh7egqvdjmt33e3lz5uy59th');
export const ledgerTip = {
blockNo: Cardano.BlockNo(1_111_111),
hash: Cardano.BlockId('10d64cc11e9b20e15b6c46aa7b1fed11246f437e62225655a30ea47bf8cc22d0'),
import * as AssetId from '../assetId';
import { Cardano, UtxoProvider } from '@cardano-sdk/core';
import { handleAssetId } from './mockData';
import delay from 'delay';
export const utxo: Cardano.Utxo[] = [
'addr_test1qq585l3hyxgj3nas2v3xymd23vvartfhceme6gv98aaeg9muzcjqw982pcftgx53fu5527z2cj2tkx2h8ux2vxsg475q2g7k3g'
),
value: {
assets: new Map([[handleAssetId, 1n]]),
coins: 9_825_963n
}
}
createAssetsTracker,
createBalanceTracker,
createDelegationTracker,
createHandlesTracker,
createProviderStatusTracker,
createSimpleConnectionStatusTracker,
createTransactionsTracker,
import {
Assets,
FinalizeTxProps,
HandleInfo,
ObservableWallet,
SignDataProps,
SyncStatus,
map,
mergeMap,
switchMap,
tap
tap,
throwError
} from 'rxjs';
import { Cip30DataSignature } from '@cardano-sdk/dapp-connector';
import {
GenericTxBuilder,
InitializeTxProps,
InitializeTxResult,
InvalidConfigurationError,
TxBuilderDependencies,
finalizeTx,
initializeTx
export interface PersonalWalletProps {
readonly name: string;
readonly polling?: PollingConfig;
/**
* If set, will track and emit own handles on PersonalWallet.handles$ observable
*/
readonly handlePolicyIds?: Cardano.PolicyId[];
readonly retryBackoffConfig?: RetryBackoffConfig;
}
readonly protocolParameters$: TrackerSubject<Cardano.ProtocolParameters>;
readonly genesisParameters$: TrackerSubject<Cardano.CompactGenesis>;
readonly assetInfo$: TrackerSubject<Assets>;
readonly handles$: Observable<HandleInfo[]>;
readonly fatalError$: Subject<unknown>;
readonly syncStatus: SyncStatus;
readonly name: string;
retryBackoffConfig = {
initialInterval: Math.min(pollInterval, 1000),
maxInterval
}
},
handlePolicyIds
}: PersonalWalletProps,
{
txSubmitProvider,
}),
stores.assets
);
this.handles$ = handlePolicyIds?.length
? createHandlesTracker({
assetInfo$: this.assetInfo$,
handlePolicyIds,
logger: contextLogger(this.#logger, 'handles$'),
tip$: this.tip$,
utxo$: this.utxo.total$
})
: throwError(() => new InvalidConfigurationError('Missing handlePolicyIds option in PersonalWallet'));
this.util = createWalletUtil({
protocolParameters$: this.protocolParameters$,
utxo: this.utxo
import { Assets, HandleInfo } from '../types';
import { Cardano } from '@cardano-sdk/core';
import { Logger } from 'ts-log';
import {
NEVER,
Observable,
combineLatest,
distinctUntilChanged,
map,
mergeMap,
of,
shareReplay,
withLatestFrom
} from 'rxjs';
import { deepEquals, isNotNil } from '@cardano-sdk/util';
import { sameArrayItems, strictEquals } from './util';
import uniqBy from 'lodash/uniqBy';
export interface HandlesTrackerProps {
utxo$: Observable<Cardano.Utxo[]>;
assetInfo$: Observable<Assets>;
tip$: Observable<Cardano.Tip>;
handlePolicyIds: Cardano.PolicyId[];
logger: Logger;
}
const handleInfoEquals = (a: HandleInfo, b: HandleInfo) =>
a.assetId === b.assetId &&
a.resolvedAt.hash === b.resolvedAt.hash &&
deepEquals(a.tokenMetadata, b.tokenMetadata) &&
deepEquals(a.nftMetadata, b.nftMetadata);
export const createHandlesTracker = ({ tip$, assetInfo$, handlePolicyIds, logger, utxo$ }: HandlesTrackerProps) =>
combineLatest([
utxo$.pipe(
map((utxo) =>
utxo.flatMap(([_, txOut]) =>
uniqBy(
[...(txOut.value.assets?.keys() || [])]
.filter((assetId) => handlePolicyIds.some((policyId) => assetId.startsWith(policyId)))
.map((assetId) => ({
handleAssetId: assetId,
txOut
})),
({ handleAssetId }) => handleAssetId
)
)
),
distinctUntilChanged((a, b) => sameArrayItems(a, b, strictEquals)),
withLatestFrom(tip$)
),
assetInfo$
]).pipe(
mergeMap(([[utxo, tip], assets]) => {
const handlesWithAssetInfo = utxo
.map(({ handleAssetId, txOut }): HandleInfo | null => {
const assetInfo = assets.get(handleAssetId);
if (!assetInfo) {
logger.debug(`Asset info not (yet?) found for ${handleAssetId}`);
return null;
}
return {
...assetInfo,
handle: Buffer.from(Cardano.AssetId.getAssetName(handleAssetId), 'hex').toString('utf8'),
hasDatum: !!txOut.datum,
resolvedAddresses: {
cardano: txOut.address
},
resolvedAt: tip
};
})
.filter(isNotNil);
if (utxo.length > 0 && handlesWithAssetInfo.length === 0) {
// AssetInfo is still resolving
return NEVER;
}
return of(
handlesWithAssetInfo.filter(({ handle, supply }) => {
if (supply > 1n) {
logger.warn(`Omitting handle with supply >1: ${handle}`);
return false;
}
return true;
})
);
}),
distinctUntilChanged((a, b) => sameArrayItems(a, b, handleInfoEquals)),
shareReplay({ bufferSize: 1, refCount: true })
);
export * from './SmartTxSubmitProvider';
export * from './KeyAgent';
export * from './AddressDiscovery';
export * from './HandlesTracker';
import { Asset, Cardano, EpochInfo, EraSummary, NetworkInfoProvider, TxCBOR } from '@cardano-sdk/core';
import {
Asset,
Cardano,
EpochInfo,
EraSummary,
HandleResolution,
NetworkInfoProvider,
TxCBOR
} from '@cardano-sdk/core';
import { BalanceTracker, DelegationTracker, TransactionsTracker, UtxoTracker } from './services';
import { Cip30DataSignature } from '@cardano-sdk/dapp-connector';
import { GroupedAddress, cip8 } from '@cardano-sdk/key-management';
tx: Cardano.TxBodyWithHash;
};
export type HandleInfo = HandleResolution & Asset.AssetInfo;
export interface ObservableWallet {
readonly balance: BalanceTracker;
readonly delegation: DelegationTracker;
readonly currentEpoch$: Observable<EpochInfo>;
readonly protocolParameters$: Observable<Cardano.ProtocolParameters>;
readonly addresses$: Observable<GroupedAddress[]>;
readonly handles$: Observable<HandleInfo[]>;
/** All owned and historical assets */
readonly assetInfo$: Observable<Assets>;
/**
AddressDiscovery,
ConnectionStatus,
ConnectionStatusTracker,
HandleInfo,
ObservableWallet,
PersonalWallet,
PollingConfig,
UtxoProvider,
coalesceValueQuantities
} from '@cardano-sdk/core';
import { InvalidConfigurationError } from '@cardano-sdk/tx-construction';
import { InvalidStringError } from '@cardano-sdk/util';
import { ReplaySubject, firstValueFrom } from 'rxjs';
import { WalletStores, createInMemoryWalletStores } from '../../src/persistence';
import delay from 'delay';
import flatten from 'lodash/flatten';
const { currentEpoch, networkInfo, queryTransactionsResult, queryTransactionsResult2 } = mocks;
const { currentEpoch, networkInfo, queryTransactionsResult, queryTransactionsResult2, handleAssetId, handleAssetInfo } =
mocks;
const name = 'Test Wallet';
const address = mocks.utxo[0][0].address!;
addressDiscovery?: AddressDiscovery;
asyncKeyAgent?: AsyncKeyAgent;
pollingConfig?: PollingConfig;
handlePolicyIds?: Cardano.PolicyId[];
};
const createWallet = async (props: CreateWalletProps) => {
const stakePoolProvider = createStubStakePoolProvider();
return new PersonalWallet(
{ name, polling: props.pollingConfig },
{ handlePolicyIds: props.handlePolicyIds, name, polling: props.pollingConfig },
{
addressDiscovery: props?.addressDiscovery,
assetProvider,
const assertWalletProperties = async (
wallet: PersonalWallet,
expectedDelegateeId: Cardano.PoolId | undefined,
expectedRewardsHistory = flatten([...mocks.rewardsHistory.values()])
expectedRewardsHistory = flatten([...mocks.rewardsHistory.values()]),
expectedHandles?: Partial<HandleInfo>[]
) => {
expect(wallet.keyAgent).toBeTruthy();
// name
expect(addresses[0].address).toEqual(address);
expect(addresses[0].rewardAccount).toEqual(rewardAccount);
// assets$
expect(await firstValueFrom(wallet.assetInfo$)).toEqual(new Map([[AssetId.TSLA, mocks.asset]]));
expect(await firstValueFrom(wallet.assetInfo$)).toEqual(
new Map([
[AssetId.TSLA, mocks.asset],
[handleAssetId, handleAssetInfo]
])
);
// handles$
await (expectedHandles
? expect(firstValueFrom(wallet.handles$)).resolves.toMatchObject(expectedHandles)
: expect(firstValueFrom(wallet.handles$)).rejects.toThrowError(InvalidConfigurationError));
// inputAddressResolver
expect(typeof wallet.util).toBe('object');
};
await assertWalletProperties(wallet1, somePartialStakePools[0].id);
wallet1.shutdown();
const wallet2 = await createWallet({
handlePolicyIds: [mocks.handlePolicyId],
providers: {
chainHistoryProvider: mocks.mockChainHistoryProvider2(100),
networkInfoProvider: mocks.mockNetworkInfoProvider2(100),
},
stores
});
await assertWalletProperties(wallet2, somePartialStakePools[0].id);
await assertWalletProperties(wallet2, somePartialStakePools[0].id, undefined, [{ handle: mocks.handle }]);
await waitForWalletStateSettle(wallet2);
await assertWalletProperties2(wallet2);
wallet2.shutdown();
expect(addresses[0].address).toEqual(address);
expect(addresses[0].rewardAccount).toEqual(rewardAccount);
// assets$
expect(await firstValueFrom(wallet.assetInfo$)).toEqual(new Map([[AssetId.TSLA, mocks.asset]]));
expect(await firstValueFrom(wallet.assetInfo$)).toEqual(
new Map([
[AssetId.TSLA, mocks.asset],
[mocks.handleAssetId, mocks.handleAssetInfo]
])
);
// inputAddressResolver
expect(typeof wallet.util).toBe('object');
};
/* eslint-disable prettier/prettier */
/* eslint-disable no-multi-spaces */
/* eslint-disable space-in-parens */
import { HandleInfo, createHandlesTracker } from '../../src';
import { combineLatest, take } from 'rxjs';
import { createTestScheduler, logger, mockProviders } from '@cardano-sdk/util-dev';
const {
utxo, utxo2, ledgerTip, ledgerTip2, handleAssetId,
handlePolicyId, handle, handleFingerprint, handleAssetName, handleAssetInfo
} = mockProviders;
const handleOutput = utxo.find(([_, { value: { assets } }]) =>
[...assets?.keys() || []].some(assetId => assetId.startsWith(handlePolicyId)))![1];
const expectedHandleInfo = {
assetId: handleAssetId,
fingerprint: handleFingerprint,
handle,
hasDatum: !!handleOutput.datum,
mintOrBurnCount: handleAssetInfo.mintOrBurnCount,
name: handleAssetName,
policyId: handlePolicyId,
quantity: 1n,
resolvedAddresses: {
cardano: handleOutput.address
},
// We consider that handle was resolved when we got the utxo,
// as AssetInfo is just some supplementary data
resolvedAt: ledgerTip,
supply: 1n
} as HandleInfo;
describe('createHandlesTracker', () => {
it('matches utxo$ assets to given handlePolicyIds and adds context from assetInfo$ and tip$ observables', () => {
createTestScheduler().run(({ hot, expectObservable }) => {
const utxo$ = hot( '-ab-', { a: utxo, b: utxo2 });
const tip$ = hot( 'a-b-', { a: ledgerTip, b: ledgerTip2 });
const assetInfo$ = hot('-a-b', {
a: new Map(),
b: new Map([[handleAssetId, handleAssetInfo]])
});
const handles$ = createHandlesTracker({
assetInfo$, handlePolicyIds: [handlePolicyId], logger, tip$, utxo$
});
expectObservable(handles$).toBe('---a', { a: [expectedHandleInfo] });
});
});
it('filters out handles that have total supply >1', () => {
createTestScheduler().run(({ hot, expectObservable }) => {
const utxo$ = hot( '-a', { a: utxo });
const tip$ = hot( 'a-', { a: ledgerTip });
const assetInfo$ = hot('-a', {
a: new Map([[handleAssetId, {
...handleAssetInfo,
supply: 2n
}]])
});
const handles$ = createHandlesTracker({
assetInfo$, handlePolicyIds: [handlePolicyId], logger, tip$, utxo$
});
expectObservable(handles$).toBe('-a', { a: [] });
});
});
it('does not emit duplicates with no changes', () => {
createTestScheduler().run(({ hot, expectObservable }) => {
const utxo$ = hot( '-a-', { a: utxo });
const tip$ = hot( 'a--', { a: ledgerTip });
const assetInfo$ = hot('-aa', { a: new Map([[handleAssetId, handleAssetInfo]]) });
const handles$ = createHandlesTracker({
assetInfo$, handlePolicyIds: [handlePolicyId], logger, tip$, utxo$
});
expectObservable(handles$).toBe('-a-', { a: [expectedHandleInfo] });
});
});
it('shares a single subscription to dependency observables', () => {
createTestScheduler().run(({ hot, expectSubscriptions }) => {
const utxo$ = hot('-a', { a: utxo });
const tip$ = hot('a-', { a: ledgerTip });
const assetInfo$ = hot('-a', {
a: new Map([[handleAssetId, handleAssetInfo]])
});
const handles$ = createHandlesTracker({
assetInfo$, handlePolicyIds: [handlePolicyId], logger, tip$, utxo$
});
combineLatest([handles$, handles$]).pipe(take(1)).subscribe();
expectSubscriptions(utxo$.subscriptions).toBe('^!');
expectSubscriptions(tip$.subscriptions).toBe('^!');
expectSubscriptions(assetInfo$.subscriptions).toBe('^!');
});
});
});
finalizeTx: RemoteApiPropertyType.MethodReturningPromise,
genesisParameters$: RemoteApiPropertyType.HotObservable,
getName: RemoteApiPropertyType.MethodReturningPromise,
handles$: RemoteApiPropertyType.HotObservable,
initializeTx: RemoteApiPropertyType.MethodReturningPromise,
protocolParameters$: RemoteApiPropertyType.HotObservable,
signData: RemoteApiPropertyType.MethodReturningPromise,
Cardano-Perf regression: UMap.size regression fix
Signed-off-by: Pat Losoponkul <[email protected]>
Co-authored-by: Alexey Kuleshevich <[email protected]>
Corresponding to [this PR](https://github.com/input-output-hk/cardano-ledger/pull/3756).
Signed-off-by: Pat Losoponkul <[email protected]>
Feat/lw 7973 cip95 sign tx
Signed-off-by: Juliano Lazzarotto <[email protected]>
