From 976ae5bf7a5af377fb1b4a044630c9a2130e8a21 Mon Sep 17 00:00:00 2001 From: Rishabh Singh Date: Mon, 19 Jan 2026 15:29:08 +0530 Subject: [PATCH 1/3] feat: update mint input process --- src/commands/helpers.ts | 85 +++++- src/commands/token-registry/mint.ts | 149 ++++----- src/types.ts | 10 +- src/utils/cli-options.ts | 268 +++++++++++++++- src/utils/file-io.ts | 2 +- src/utils/networks.ts | 7 +- tests/commands/token-registry/mint.test.ts | 339 +++++++++++++++------ 7 files changed, 675 insertions(+), 185 deletions(-) diff --git a/src/commands/helpers.ts b/src/commands/helpers.ts index 9d210ae..7598ed5 100644 --- a/src/commands/helpers.ts +++ b/src/commands/helpers.ts @@ -1,7 +1,7 @@ // External dependencies -import { BytesLike, Wallet, HDNodeWallet, ZeroAddress } from 'ethers'; +import { BytesLike, Wallet, HDNodeWallet, ZeroAddress, Provider } from 'ethers'; import signale from 'signale'; -import { v5Contracts } from '@trustvc/trustvc'; +import { v5Contracts, checkSupportsInterface, v4SupportInterfaceIds, v5SupportInterfaceIds } from '@trustvc/trustvc'; import { encrypt } from '@trustvc/trustvc'; // Internal utilities @@ -9,6 +9,46 @@ import { ConnectedSigner } from '../utils'; // Contract factories from TrustVC v5 const { TitleEscrow__factory, TradeTrustToken__factory } = v5Contracts; + +// Interface for connectToTokenRegistry function arguments +interface ConnectToTokenRegistryArgs { + address: string; + wallet: Wallet | HDNodeWallet | ConnectedSigner; +} + +/** + * Connects to a token registry contract instance. + * + * @param address - The address of the token registry contract + * @param wallet - The wallet or signer to use for the connection + * @returns Promise resolving to the connected TradeTrustToken contract instance + * @throws Error if connection fails + */ +export const connectToTokenRegistry = async ({ + address, + wallet, +}: ConnectToTokenRegistryArgs): Promise> => { + try { + // Connect to the token registry contract + signale.info(`Connecting to token registry at: ${address}`); + const tokenRegistry = TradeTrustToken__factory.connect(address, wallet); + + // Validate the connection was successful + if (!tokenRegistry) { + const error = `Failed to connect to token registry at address: ${address}`; + signale.error(error); + throw new Error(error); + } + + signale.success(`Successfully connected to token registry`); + return tokenRegistry; + } catch (error) { + signale.error( + `Error in connectToTokenRegistry: ${error instanceof Error ? error.message : String(error)}`, + ); + throw error; + } +}; // Interface for connectToTitleEscrow function arguments interface ConnectToTitleEscrowArgs { tokenId: string; @@ -232,3 +272,44 @@ export const validateAndEncryptRemark = (remark?: string, keyId?: string): Bytes const encrpyted = encrypt(remark, keyId ?? ''); return encrpyted.startsWith('0x') ? encrpyted : `0x${encrpyted}`; }; + +/** + * Determines the version of a token registry contract by checking supported interfaces. + * Checks for V5 first, then V4 compatibility. + * + * @param tokenRegistryAddress - The address of the token registry contract + * @param provider - The provider to use for the contract call + * @returns Promise resolving to 'v5', 'v4', or 'unknown' + */ +export const getTokenRegistryVersion = async ( + tokenRegistryAddress: string, + provider: Provider, +): Promise<'v5' | 'v4' | 'unknown'> => { + try { + // Check if it's V5 + const isV5 = await checkSupportsInterface( + tokenRegistryAddress, + v5SupportInterfaceIds.SBT, + provider, + ); + + if (isV5) { + return 'v5'; + } + + // Check if it's V4 + const isV4 = await checkSupportsInterface( + tokenRegistryAddress, + v4SupportInterfaceIds.SBT, + provider, + ); + + if (isV4) { + return 'v4'; + } + + return 'unknown'; + } catch (error) { + throw new Error(`Failed to determine token registry version: ${error instanceof Error ? error.message : String(error)}`); + } +}; diff --git a/src/commands/token-registry/mint.ts b/src/commands/token-registry/mint.ts index 686948e..c6c396e 100644 --- a/src/commands/token-registry/mint.ts +++ b/src/commands/token-registry/mint.ts @@ -1,4 +1,3 @@ -import { input } from '@inquirer/prompts'; import signale, { error, info, success } from 'signale'; import { TokenRegistryMintCommand } from '../../types'; import { @@ -7,14 +6,18 @@ import { getErrorMessage, getEtherscanAddress, NetworkCmdName, - promptRemarkAndEncryptionKey, - promptNetworkSelection, promptWalletSelection, getWalletOrSigner, canEstimateGasPrice, getGasFees, + extractDocumentInfo, + promptAndReadDocument, + promptRemark, + promptAddress, + performDryRunWithConfirmation, } from '../../utils'; -import { BigNumberish, TransactionReceipt } from 'ethers'; +import { connectToTokenRegistry, validateAndEncryptRemark } from '../helpers'; +import { TransactionReceipt } from 'ethers'; import { mint } from '@trustvc/trustvc'; export const command = 'mint'; @@ -34,76 +37,32 @@ export const handler = async (): Promise => { // Prompt user for all required inputs export const promptForInputs = async (): Promise => { - // Network selection - const network = await promptNetworkSelection(); - - // Token Registry Address - const address = await input({ - message: 'Enter the token registry contract address:', - required: true, - validate: (value: string) => { - if (!value || value.trim() === '') { - return 'Token registry address is required'; - } - if (!/^0x[a-fA-F0-9]{40}$/.test(value)) { - return 'Invalid Ethereum address format'; - } - return true; - }, - }); + // Extract document information using utility function + const document = await promptAndReadDocument(); - // Token ID (Document Hash) - const tokenId = await input({ - message: 'Enter the document hash (tokenId) to mint:', - required: true, - validate: (value: string) => { - if (!value || value.trim() === '') { - return 'Token ID is required'; - } - return true; - }, - }); + // Extract document information using utility function + const { tokenRegistry, tokenId, network, documentId, registryVersion } = + await extractDocumentInfo(document); // Beneficiary Address - const beneficiary = await input({ - message: 'Enter the beneficiary address (initial recipient):', - required: true, - validate: (value: string) => { - if (!value || value.trim() === '') { - return 'Beneficiary address is required'; - } - if (!/^0x[a-fA-F0-9]{40}$/.test(value)) { - return 'Invalid Ethereum address format'; - } - return true; - }, - }); + const beneficiary = await promptAddress('beneficiary', 'initial recipient'); // Holder Address - const holder = await input({ - message: 'Enter the holder address (initial holder):', - required: true, - validate: (value: string) => { - if (!value || value.trim() === '') { - return 'Holder address is required'; - } - if (!/^0x[a-fA-F0-9]{40}$/.test(value)) { - return 'Invalid Ethereum address format'; - } - return true; - }, - }); + const holder = await promptAddress('holder', 'initial holder'); // Wallet selection const { encryptedWalletPath, key, keyFile } = await promptWalletSelection(); - // Optional: Remark and Encryption Key - const { remark, encryptionKey } = await promptRemarkAndEncryptionKey(); + // Optional: Remark (only for V5) + const remark = await promptRemark(registryVersion); + + // Use document ID as encryption key + const encryptionKey = documentId; // Build the result object with proper typing const baseResult = { network, - address, + address: tokenRegistry, tokenId, beneficiary, holder, @@ -177,30 +136,76 @@ const mintToTokenRegistry = async ({ ...rest }: TokenRegistryMintCommand): Promise => { const wallet = await getWalletOrSigner({ network, ...rest }); - let transactionOptions: { maxFeePerGas?: BigNumberish; maxPriorityFeePerGas?: BigNumberish } = {}; if (dryRun) { console.log('šŸ”§ Dry run mode is currently undergoing upgrades and will be available soon.'); process.exit(0); } + // Automatic dry run for Ethereum and Polygon networks + const shouldProceed = await performDryRunWithConfirmation({ + network, + getTransactionCallback: async () => { + const tokenRegistry = await connectToTokenRegistry({ address, wallet }); + + // Validate and encrypt the remark with document ID as encryption key + const encryptedRemark = validateAndEncryptRemark(remark, encryptionKey); + + // Populate the transaction for gas estimation + const tx = await tokenRegistry.mint.populateTransaction( + beneficiary, + holder, + tokenId, + encryptedRemark + ); + + // Ensure the transaction has a 'from' address for proper gas estimation + return { + ...tx, + from: await wallet.getAddress(), + }; + }, + }); + + if (!shouldProceed) { + process.exit(0); + } + + let transaction; + + // Execute transaction with appropriate gas settings based on network capabilities if (canEstimateGasPrice(network)) { + // Ensure provider is available for gas estimation if (!wallet.provider) { throw new Error('Provider is required for gas estimation'); } + + // Get current gas fees from the network const gasFees = await getGasFees({ provider: wallet.provider, ...rest }); - transactionOptions = { - maxFeePerGas: gasFees.maxFeePerGas as BigNumberish, - maxPriorityFeePerGas: gasFees.maxPriorityFeePerGas as BigNumberish, - }; + + // Execute mint with EIP-1559 gas parameters + transaction = await mint( + { tokenRegistryAddress: address }, + wallet, + { beneficiaryAddress: beneficiary, holderAddress: holder, tokenId, remarks: remark }, + { + id: encryptionKey, + maxFeePerGas: gasFees.maxFeePerGas?.toString(), + maxPriorityFeePerGas: gasFees.maxPriorityFeePerGas?.toString(), + }, + ); + } else { + // Execute mint without gas estimation (for networks that don't support it) + transaction = await mint( + { tokenRegistryAddress: address }, + wallet, + { beneficiaryAddress: beneficiary, holderAddress: holder, tokenId, remarks: remark }, + { + id: encryptionKey, + }, + ); } - const transaction = await mint( - { tokenRegistryAddress: address }, - wallet, - { beneficiaryAddress: beneficiary, holderAddress: holder, tokenId, remarks: remark }, - { id: encryptionKey, ...transactionOptions }, - ); signale.await(`Waiting for transaction ${transaction.hash} to be mined`); const receipt = (await transaction.wait()) as unknown as TransactionReceipt; if (!receipt) { diff --git a/src/types.ts b/src/types.ts index 1986c47..f67eb07 100644 --- a/src/types.ts +++ b/src/types.ts @@ -1,12 +1,18 @@ import { credentialStatus, issuer, RawVerifiableCredential } from '@trustvc/trustvc'; -import { GasOption, NetworkOption, RpcUrlOption, WalletOrSignerOption } from './utils'; +import { + GasOption, + NetworkAndWalletSignerOption, + NetworkOption, + RpcUrlOption, + WalletOrSignerOption, +} from './utils'; export type SignInput = { credential: RawVerifiableCredential; keyPairData: typeof issuer.IssuedDIDOption; encryptionAlgorithm: typeof credentialStatus.cryptoSuiteName; pathToSignedVC: string; -} +}; export type DidInput = { keyPairPath: string; domainName: string; diff --git a/src/utils/cli-options.ts b/src/utils/cli-options.ts index 6406d36..5af1420 100644 --- a/src/utils/cli-options.ts +++ b/src/utils/cli-options.ts @@ -1,7 +1,19 @@ -import { input, select } from '@inquirer/prompts'; -import { info } from 'signale'; +import { input, select, confirm } from '@inquirer/prompts'; +import { info, error } from 'signale'; import { Argv } from 'yargs'; -import { NetworkCmdName, supportedNetwork } from './networks'; +import { NetworkCmdName, supportedNetwork, getSupportedNetwork } from './networks'; +import { readDocumentFile } from './file-io'; +import { + getTokenRegistryAddress, + getTokenId, + getChainId, + CHAIN_ID, + SUPPORTED_CHAINS, +} from '@trustvc/trustvc'; +import fs from 'fs'; +import { getTokenRegistryVersion } from '../commands/helpers'; +import { getErrorMessage } from './index'; +import { dryRunMode } from './dryRun'; export interface NetworkOption { network: string; @@ -280,3 +292,253 @@ export const promptRemarkAndEncryptionKey = async (): Promise<{ encryptionKey: encryptionKey || undefined, }; }; + +/** + * Maps a chainId to a network name + * @param chainId - The chain ID from the document + * @returns The network name + */ +export const getNetworkFromChainId = (chainId: number): string => { + const chainIdMap: Record = { + 1: 'mainnet', + 11155111: 'sepolia', + 137: 'matic', + 80002: 'amoy', + 101010: 'stability', + 20180427: 'stabilitytestnet', + 1338: 'astron', + 21002: 'astrontestnet', + 50: 'xdc', + 51: 'xdcapothem', + 1337: 'local', + }; + + const network = chainIdMap[chainId]; + if (!network) { + throw new Error( + `Unsupported chainId: ${chainId}. Please add mapping or select network manually.`, + ); + } + + return network; +}; + +/** + * Prompts for document file path and reads the document. + * @returns The parsed document object + */ +export const promptAndReadDocument = async (): Promise => { + // Document file path + const documentPath = await input({ + message: 'Enter the path to the TT/JSON document file:', + required: true, + validate: (value: string) => { + if (!value || value.trim() === '') { + return 'Document file path is required'; + } + if (!fs.existsSync(value)) { + return 'File does not exist'; + } + if (!/\.(tt|json|jsonld)$/i.test(value)) { + return 'File must be a .tt, .json, or .jsonld file'; + } + return true; + }, + }); + + // Read and parse the document + let document: any; + try { + document = readDocumentFile(documentPath); + } catch (err) { + throw new Error( + `Failed to read document file: ${err instanceof Error ? err.message : String(err)}`, + ); + } + + return document; +}; + +/** + * Prompts for document file path, extracts and displays document information. + * @returns An object containing the document, tokenRegistry, tokenId, network, documentId, and registryVersion + */ +export const extractDocumentInfo = async ( + document: any, +): Promise<{ + document: any; + tokenRegistry: string; + tokenId: string; + network: string; + documentId: string; + registryVersion: string; +}> => { + // Extract information using trustvc utility functions + let tokenRegistry: string | undefined; + let tokenId: string | undefined; + let chainId: CHAIN_ID | undefined; + + try { + tokenRegistry = getTokenRegistryAddress(document); + tokenId = getTokenId(document); + chainId = getChainId(document); + } catch (err) { + throw new Error( + `Failed to extract document information: ${err instanceof Error ? err.message : String(err)}`, + ); + } + + // Validate extracted values + if (!tokenRegistry) { + throw new Error('Document does not contain a valid token registry address'); + } + + if (!tokenId) { + throw new Error('Document does not contain a valid token ID'); + } + + if (!chainId) { + throw new Error('Document does not contain a valid chain ID'); + } + + // Map chainId to network name + const network = SUPPORTED_CHAINS[chainId].name; + + // Get provider to check token registry version (no wallet needed) + const provider = getSupportedNetwork(network).provider(); + const registryVersion = await getTokenRegistryVersion(tokenRegistry, provider); + + // Extract document ID + const documentId = document.id || 'N/A'; + + info(`Extracted from document:`); + info(` Network: ${network} (Chain ID: ${chainId})`); + info(` Token Registry (Version ${registryVersion.toUpperCase()}): ${tokenRegistry}`); + info(` Token ID: ${tokenId}`); + info(` Document ID: ${documentId}`); + + return { + document, + tokenRegistry, + tokenId, + network, + documentId, + registryVersion, + }; +}; + +/** + * Prompts for an optional remark based on token registry version. + * Only prompts if the registry version is V5. + * @param registryVersion - The token registry version ('v4' or 'v5') + * @returns The remark string or undefined + */ +export const promptRemark = async (registryVersion: string): Promise => { + if (registryVersion === 'v5') { + const remarkInput = await input({ + message: 'Enter a remark (optional, press Enter to skip):', + required: false, + }); + return remarkInput || undefined; + } else { + info('Remark is not supported for V4 token registries. Skipping remark input.'); + return undefined; + } +}; + +/** + * Prompts for an Ethereum address with validation. + * @param role - The role of the address (e.g., 'beneficiary', 'holder', 'new holder') + * @param description - Optional additional description (e.g., 'initial recipient', 'initial holder') + * @returns The validated Ethereum address + */ +export const promptAddress = async (role: string, description?: string): Promise => { + const roleCapitalized = role.charAt(0).toUpperCase() + role.slice(1); + const messageText = description + ? `Enter the address of the ${role} (${description}):` + : `Enter the address of the ${role}:`; + + const address = await input({ + message: messageText, + required: true, + validate: (value: string) => { + if (!value || value.trim() === '') { + return `${roleCapitalized} address is required`; + } + if (!/^0x[a-fA-F0-9]{40}$/.test(value)) { + return 'Invalid Ethereum address format'; + } + return true; + }, + }); + + return address; +}; + +/** + * Checks if the network requires automatic dry run (Ethereum and Polygon networks) + */ +export const shouldRunDryRun = (network: string): boolean => { + const dryRunNetworks = [ + NetworkCmdName.Mainnet, // Ethereum Mainnet + NetworkCmdName.Sepolia, // Ethereum Sepolia Testnet + NetworkCmdName.Matic, // Polygon Mainnet + NetworkCmdName.Amoy, // Polygon Amoy Testnet + ]; + return dryRunNetworks.includes(network as NetworkCmdName); +}; + +/** + * Performs automatic dry run for specified networks with gas estimation and user confirmation + * Uses the existing dryRunMode function for comprehensive display + */ +export const performDryRunWithConfirmation = async ({ + network, + getTransactionCallback, +}: { + network: string; + getTransactionCallback: () => Promise; +}): Promise => { + if (!shouldRunDryRun(network)) { + return true; // Proceed without dry run for other networks + } + + try { + // Get the populated transaction - dryRunMode will estimate gas automatically + const transaction = await getTransactionCallback(); + + // Use the existing dryRunMode function for comprehensive display + // It will automatically estimate gas from the transaction + await dryRunMode({ + network, + transaction, + }); + + // Ask user to proceed + const proceed = await confirm({ + message: '\nDo you want to proceed with the actual transaction?', + default: true, + }); + + if (!proceed) { + info('Transaction cancelled by user.'); + return false; + } + + info('\nāœ… Proceeding with transaction...'); + return true; + } catch (estimateError) { + error(`Gas estimation failed: ${getErrorMessage(estimateError)}`); + const proceedAnyway = await confirm({ + message: 'Gas estimation failed. Do you want to proceed anyway?', + default: false, + }); + + if (!proceedAnyway) { + info('Transaction cancelled by user.'); + return false; + } + + return true; + } +}; diff --git a/src/utils/file-io.ts b/src/utils/file-io.ts index f661453..45542b7 100644 --- a/src/utils/file-io.ts +++ b/src/utils/file-io.ts @@ -22,7 +22,7 @@ export const readFile = (filename: string): any => { return fs.readFileSync(filename, 'utf8'); }; -export const readOpenAttestationFile = (filename: string): any => { +export const readDocumentFile = (filename: string): any => { return JSON.parse(readFile(filename)); }; diff --git a/src/utils/networks.ts b/src/utils/networks.ts index 5071ded..20e9360 100644 --- a/src/utils/networks.ts +++ b/src/utils/networks.ts @@ -44,10 +44,7 @@ const jsonRpcProvider = * Example: SEPOLIA_RPC=https://sepolia.infura.io/v3/your-key */ const getProviderWithEnvOverride = - ( - networkName: NetworkCmdName, - defaultProvider: () => Provider, - ): (() => Provider) => + (networkName: NetworkCmdName, defaultProvider: () => Provider): (() => Provider) => () => { const envVarName = `${networkName.toUpperCase()}_RPC`; const customRpcUrl = process.env[envVarName]; @@ -109,7 +106,7 @@ export const supportedNetwork: { networkId: 80002, networkName: NetworkCmdName.Amoy, currency: 'MATIC', - gasStation: gasStation('https://gasstation.polygon.technology/amoy'), + gasStation: gasStation('https://gasstation.polygon.technology/v2'), }, [NetworkCmdName.XDC]: { explorer: 'https://xdcscan.io', diff --git a/tests/commands/token-registry/mint.test.ts b/tests/commands/token-registry/mint.test.ts index 095d2bd..5a52371 100644 --- a/tests/commands/token-registry/mint.test.ts +++ b/tests/commands/token-registry/mint.test.ts @@ -1,14 +1,7 @@ import { TransactionReceipt } from '@ethersproject/providers'; -import * as prompts from '@inquirer/prompts'; import { beforeEach, describe, expect, it, MockedFunction, vi } from 'vitest'; -import { - handler, - mintToken, - promptForInputs, -} from '../../../src/commands/token-registry/mint'; +import { handler, mintToken, promptForInputs } from '../../../src/commands/token-registry/mint'; import { NetworkCmdName } from '../../../src/utils'; - -vi.mock('@inquirer/prompts'); vi.mock('signale', async (importOriginal) => { const originalSignale = await importOriginal(); return { @@ -28,6 +21,18 @@ vi.mock('signale', async (importOriginal) => { vi.mock('@trustvc/trustvc', () => ({ mint: vi.fn(), + v5Contracts: { + TitleEscrow__factory: {}, + TradeTrustToken__factory: {}, + }, + checkSupportsInterface: vi.fn(), + v4SupportInterfaceIds: {}, + v5SupportInterfaceIds: {}, + encrypt: vi.fn(), + getTokenRegistryAddress: vi.fn(), + getTokenId: vi.fn(), + getChainId: vi.fn(), + SUPPORTED_CHAINS: {}, })); vi.mock('../../../src/utils/wallet', () => ({ @@ -47,9 +52,31 @@ vi.mock('../../../src/utils', async (importOriginal) => { displayTransactionPrice: vi.fn(), canEstimateGasPrice: vi.fn(() => false), getGasFees: vi.fn(), + promptAndReadDocument: vi.fn(), + extractDocumentInfo: vi.fn(), + promptAddress: vi.fn(), + promptWalletSelection: vi.fn(), + promptRemark: vi.fn(), + performDryRunWithConfirmation: vi.fn(async () => true), // Mock to always proceed }; }); +vi.mock('../../../src/commands/helpers', () => ({ + connectToTokenRegistry: vi.fn(async () => ({ + mint: { + populateTransaction: vi.fn(), + }, + })), + connectToTitleEscrow: vi.fn(), + validateEndorseChangeOwner: vi.fn(), + validateNominateBeneficiary: vi.fn(), + validatePreviousBeneficiary: vi.fn(), + validatePreviousHolder: vi.fn(), + validateEndorseTransferOwner: vi.fn(), + validateAndEncryptRemark: vi.fn((remark?: string) => (remark ? `0x${remark}` : '0x')), + getTokenRegistryVersion: vi.fn(), +})); + describe('token-registry/mint', () => { beforeEach(() => { vi.clearAllMocks(); @@ -70,21 +97,31 @@ describe('token-registry/mint', () => { beneficiary: '0x0987654321098765432109876543210987654321', holder: '0x1111111111111111111111111111111111111111', remark: 'Test remark', - encryptionKey: 'test-key', + documentId: 'urn:uuid:019b9ce6-5048-7669-b1bf-e15d1f085692', }; - (prompts.select as any) - .mockResolvedValueOnce(mockInputs.network) // Network selection - .mockResolvedValueOnce('encryptedWallet'); // Wallet option + const mockDocument = { + id: mockInputs.documentId, + tokenRegistry: mockInputs.address, + }; - (prompts.input as any) - .mockResolvedValueOnce(mockInputs.address) // Token registry address - .mockResolvedValueOnce(mockInputs.tokenId) // Token ID + const utils = await import('../../../src/utils'); + (utils.promptAndReadDocument as any).mockResolvedValue(mockDocument); + (utils.extractDocumentInfo as any).mockResolvedValue({ + document: mockDocument, + tokenRegistry: mockInputs.address, + tokenId: mockInputs.tokenId, + network: mockInputs.network, + documentId: mockInputs.documentId, + registryVersion: 'v5', + }); + (utils.promptAddress as any) .mockResolvedValueOnce(mockInputs.beneficiary) // Beneficiary - .mockResolvedValueOnce(mockInputs.holder) // Holder - .mockResolvedValueOnce('./wallet.json') // Encrypted wallet path - .mockResolvedValueOnce(mockInputs.remark) // Remark - .mockResolvedValueOnce(mockInputs.encryptionKey); // Encryption key + .mockResolvedValueOnce(mockInputs.holder); // Holder + (utils.promptWalletSelection as any).mockResolvedValue({ + encryptedWalletPath: './wallet.json', + }); + (utils.promptRemark as any).mockResolvedValue(mockInputs.remark); const result = await promptForInputs(); @@ -95,7 +132,7 @@ describe('token-registry/mint', () => { expect(result.holder).toBe(mockInputs.holder); expect((result as any).encryptedWalletPath).toBe('./wallet.json'); expect(result.remark).toBe(mockInputs.remark); - expect(result.encryptionKey).toBe(mockInputs.encryptionKey); + expect(result.encryptionKey).toBe(mockInputs.documentId); expect(result.dryRun).toBe(false); expect(result.maxPriorityFeePerGasScale).toBe(1); }); @@ -107,26 +144,38 @@ describe('token-registry/mint', () => { tokenId: '0xabcdef1234567890', beneficiary: '0x0987654321098765432109876543210987654321', holder: '0x1111111111111111111111111111111111111111', + documentId: 'urn:uuid:019b9ce6-5048-7669-b1bf-e15d1f085692', }; - (prompts.select as any) - .mockResolvedValueOnce(mockInputs.network) - .mockResolvedValueOnce('keyFile'); + const mockDocument = { + id: mockInputs.documentId, + tokenRegistry: mockInputs.address, + }; - (prompts.input as any) - .mockResolvedValueOnce(mockInputs.address) - .mockResolvedValueOnce(mockInputs.tokenId) + const utils = await import('../../../src/utils'); + (utils.promptAndReadDocument as any).mockResolvedValue(mockDocument); + (utils.extractDocumentInfo as any).mockResolvedValue({ + document: mockDocument, + tokenRegistry: mockInputs.address, + tokenId: mockInputs.tokenId, + network: mockInputs.network, + documentId: mockInputs.documentId, + registryVersion: 'v4', + }); + (utils.promptAddress as any) .mockResolvedValueOnce(mockInputs.beneficiary) - .mockResolvedValueOnce(mockInputs.holder) - .mockResolvedValueOnce('./private-key.txt') // keyFile - .mockResolvedValueOnce(''); // Empty remark + .mockResolvedValueOnce(mockInputs.holder); + (utils.promptWalletSelection as any).mockResolvedValue({ + keyFile: './private-key.txt', + }); + (utils.promptRemark as any).mockResolvedValue(undefined); const result = await promptForInputs(); expect(result.network).toBe(mockInputs.network); expect((result as any).keyFile).toBe('./private-key.txt'); expect(result.remark).toBeUndefined(); - expect(result.encryptionKey).toBeUndefined(); + expect(result.encryptionKey).toBe(mockInputs.documentId); }); it('should return correct answers for valid inputs with direct private key', async () => { @@ -136,19 +185,31 @@ describe('token-registry/mint', () => { tokenId: '0xabcdef1234567890', beneficiary: '0x0987654321098765432109876543210987654321', holder: '0x1111111111111111111111111111111111111111', + documentId: 'urn:uuid:019b9ce6-5048-7669-b1bf-e15d1f085692', }; - (prompts.select as any) - .mockResolvedValueOnce(mockInputs.network) - .mockResolvedValueOnce('keyDirect'); + const mockDocument = { + id: mockInputs.documentId, + tokenRegistry: mockInputs.address, + }; - (prompts.input as any) - .mockResolvedValueOnce(mockInputs.address) - .mockResolvedValueOnce(mockInputs.tokenId) + const utils = await import('../../../src/utils'); + (utils.promptAndReadDocument as any).mockResolvedValue(mockDocument); + (utils.extractDocumentInfo as any).mockResolvedValue({ + document: mockDocument, + tokenRegistry: mockInputs.address, + tokenId: mockInputs.tokenId, + network: mockInputs.network, + documentId: mockInputs.documentId, + registryVersion: 'v5', + }); + (utils.promptAddress as any) .mockResolvedValueOnce(mockInputs.beneficiary) - .mockResolvedValueOnce(mockInputs.holder) - .mockResolvedValueOnce('0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80') // key - .mockResolvedValueOnce(''); // Empty remark + .mockResolvedValueOnce(mockInputs.holder); + (utils.promptWalletSelection as any).mockResolvedValue({ + key: '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80', + }); + (utils.promptRemark as any).mockResolvedValue(undefined); const result = await promptForInputs(); @@ -169,18 +230,29 @@ describe('token-registry/mint', () => { tokenId: '0xabcdef1234567890', beneficiary: '0x0987654321098765432109876543210987654321', holder: '0x1111111111111111111111111111111111111111', + documentId: 'urn:uuid:019b9ce6-5048-7669-b1bf-e15d1f085692', }; - (prompts.select as any) - .mockResolvedValueOnce(mockInputs.network) - .mockResolvedValueOnce('envVariable'); + const mockDocument = { + id: mockInputs.documentId, + tokenRegistry: mockInputs.address, + }; - (prompts.input as any) - .mockResolvedValueOnce(mockInputs.address) - .mockResolvedValueOnce(mockInputs.tokenId) + const utils = await import('../../../src/utils'); + (utils.promptAndReadDocument as any).mockResolvedValue(mockDocument); + (utils.extractDocumentInfo as any).mockResolvedValue({ + document: mockDocument, + tokenRegistry: mockInputs.address, + tokenId: mockInputs.tokenId, + network: mockInputs.network, + documentId: mockInputs.documentId, + registryVersion: 'v5', + }); + (utils.promptAddress as any) .mockResolvedValueOnce(mockInputs.beneficiary) - .mockResolvedValueOnce(mockInputs.holder) - .mockResolvedValueOnce(''); + .mockResolvedValueOnce(mockInputs.holder); + (utils.promptWalletSelection as any).mockResolvedValue({}); + (utils.promptRemark as any).mockResolvedValue(undefined); const result = await promptForInputs(); @@ -201,15 +273,38 @@ describe('token-registry/mint', () => { const originalEnv = process.env.OA_PRIVATE_KEY; delete process.env.OA_PRIVATE_KEY; - (prompts.select as any) - .mockResolvedValueOnce(NetworkCmdName.Sepolia) - .mockResolvedValueOnce('envVariable'); + const mockInputs = { + network: NetworkCmdName.Sepolia, + address: '0x1234567890123456789012345678901234567890', + tokenId: '0xabcdef1234567890', + beneficiary: '0x0987654321098765432109876543210987654321', + holder: '0x1111111111111111111111111111111111111111', + documentId: 'urn:uuid:019b9ce6-5048-7669-b1bf-e15d1f085692', + }; - (prompts.input as any) - .mockResolvedValueOnce('0x1234567890123456789012345678901234567890') - .mockResolvedValueOnce('0xabcdef1234567890') - .mockResolvedValueOnce('0x0987654321098765432109876543210987654321') - .mockResolvedValueOnce('0x1111111111111111111111111111111111111111'); + const mockDocument = { + id: mockInputs.documentId, + tokenRegistry: mockInputs.address, + }; + + const utils = await import('../../../src/utils'); + (utils.promptAndReadDocument as any).mockResolvedValue(mockDocument); + (utils.extractDocumentInfo as any).mockResolvedValue({ + document: mockDocument, + tokenRegistry: mockInputs.address, + tokenId: mockInputs.tokenId, + network: mockInputs.network, + documentId: mockInputs.documentId, + registryVersion: 'v5', + }); + (utils.promptAddress as any) + .mockResolvedValueOnce(mockInputs.beneficiary) + .mockResolvedValueOnce(mockInputs.holder); + (utils.promptWalletSelection as any).mockRejectedValue( + new Error( + 'OA_PRIVATE_KEY environment variable is not set. Please set it or choose another option.', + ), + ); await expect(promptForInputs()).rejects.toThrowError( 'OA_PRIVATE_KEY environment variable is not set. Please set it or choose another option.', @@ -221,18 +316,15 @@ describe('token-registry/mint', () => { } }); - it('should validate token registry address format', async () => { - const invalidAddress = 'invalid-address'; - - (prompts.select as any).mockResolvedValueOnce(NetworkCmdName.Sepolia); - (prompts.input as any).mockResolvedValueOnce(invalidAddress); - - // The validation happens in the prompt itself, we need to simulate it - // const addressPromptCall = (prompts.input as any).mock.calls; + it('should validate document file path', async () => { + const utils = await import('../../../src/utils'); + (utils.promptAndReadDocument as any).mockRejectedValue( + new Error('Failed to read document file: File does not exist'), + ); - // Since we can't directly test the validation function in the prompt, - // we'll verify that the validation logic exists by checking the structure - expect(prompts.input).toBeDefined(); + await expect(promptForInputs()).rejects.toThrowError( + 'Failed to read document file: File does not exist', + ); }); it('should handle optional remark without encryption key', async () => { @@ -242,25 +334,36 @@ describe('token-registry/mint', () => { tokenId: '0xabcdef1234567890', beneficiary: '0x0987654321098765432109876543210987654321', holder: '0x1111111111111111111111111111111111111111', - remark: '', + documentId: 'urn:uuid:019b9ce6-5048-7669-b1bf-e15d1f085692', }; - (prompts.select as any) - .mockResolvedValueOnce(mockInputs.network) - .mockResolvedValueOnce('encryptedWallet'); + const mockDocument = { + id: mockInputs.documentId, + tokenRegistry: mockInputs.address, + }; - (prompts.input as any) - .mockResolvedValueOnce(mockInputs.address) - .mockResolvedValueOnce(mockInputs.tokenId) + const utils = await import('../../../src/utils'); + (utils.promptAndReadDocument as any).mockResolvedValue(mockDocument); + (utils.extractDocumentInfo as any).mockResolvedValue({ + document: mockDocument, + tokenRegistry: mockInputs.address, + tokenId: mockInputs.tokenId, + network: mockInputs.network, + documentId: mockInputs.documentId, + registryVersion: 'v5', + }); + (utils.promptAddress as any) .mockResolvedValueOnce(mockInputs.beneficiary) - .mockResolvedValueOnce(mockInputs.holder) - .mockResolvedValueOnce('./wallet.json') - .mockResolvedValueOnce(mockInputs.remark); + .mockResolvedValueOnce(mockInputs.holder); + (utils.promptWalletSelection as any).mockResolvedValue({ + encryptedWalletPath: './wallet.json', + }); + (utils.promptRemark as any).mockResolvedValue(undefined); const result = await promptForInputs(); expect(result.remark).toBeUndefined(); - expect(result.encryptionKey).toBeUndefined(); + expect(result.encryptionKey).toBe(mockInputs.documentId); }); it('should support all network options', async () => { @@ -281,17 +384,36 @@ describe('token-registry/mint', () => { for (const network of networks) { vi.clearAllMocks(); - (prompts.select as any) - .mockResolvedValueOnce(network) - .mockResolvedValueOnce('encryptedWallet'); - - (prompts.input as any) - .mockResolvedValueOnce('0x1234567890123456789012345678901234567890') - .mockResolvedValueOnce('0xabcdef1234567890') - .mockResolvedValueOnce('0x0987654321098765432109876543210987654321') - .mockResolvedValueOnce('0x1111111111111111111111111111111111111111') - .mockResolvedValueOnce('./wallet.json') - .mockResolvedValueOnce(''); + const mockInputs = { + address: '0x1234567890123456789012345678901234567890', + tokenId: '0xabcdef1234567890', + beneficiary: '0x0987654321098765432109876543210987654321', + holder: '0x1111111111111111111111111111111111111111', + documentId: 'urn:uuid:019b9ce6-5048-7669-b1bf-e15d1f085692', + }; + + const mockDocument = { + id: mockInputs.documentId, + tokenRegistry: mockInputs.address, + }; + + const utils = await import('../../../src/utils'); + (utils.promptAndReadDocument as any).mockResolvedValue(mockDocument); + (utils.extractDocumentInfo as any).mockResolvedValue({ + document: mockDocument, + tokenRegistry: mockInputs.address, + tokenId: mockInputs.tokenId, + network: network, + documentId: mockInputs.documentId, + registryVersion: 'v5', + }); + (utils.promptAddress as any) + .mockResolvedValueOnce(mockInputs.beneficiary) + .mockResolvedValueOnce(mockInputs.holder); + (utils.promptWalletSelection as any).mockResolvedValue({ + encryptedWalletPath: './wallet.json', + }); + (utils.promptRemark as any).mockResolvedValue(undefined); const result = await promptForInputs(); expect(result.network).toBe(network); @@ -323,6 +445,9 @@ describe('token-registry/mint', () => { if (!address) return '0x'; return address.startsWith('0x') ? address : `0x${address}`; }); + + // Re-setup performDryRunWithConfirmation to always return true (proceed) + (utils.performDryRunWithConfirmation as any).mockResolvedValue(true); }); it('should successfully mint token and display transaction details', async () => { @@ -531,10 +656,16 @@ describe('token-registry/mint', () => { beneficiary: '0x0987654321098765432109876543210987654321', holder: '0x1111111111111111111111111111111111111111', encryptedWalletPath: './wallet.json', + documentId: 'urn:uuid:019b9ce6-5048-7669-b1bf-e15d1f085692', dryRun: false, maxPriorityFeePerGasScale: 1, }; + const mockDocument = { + id: mockInputs.documentId, + tokenRegistry: mockInputs.address, + }; + const mockTransaction: TransactionReceipt = { transactionHash: '0xtxhash', blockNumber: 12345, @@ -554,17 +685,23 @@ describe('token-registry/mint', () => { logsBloom: '0x', }; - (prompts.select as any) - .mockResolvedValueOnce(mockInputs.network) - .mockResolvedValueOnce('encryptedWallet'); - - (prompts.input as any) - .mockResolvedValueOnce(mockInputs.address) - .mockResolvedValueOnce(mockInputs.tokenId) + const utils = await import('../../../src/utils'); + (utils.promptAndReadDocument as any).mockResolvedValue(mockDocument); + (utils.extractDocumentInfo as any).mockResolvedValue({ + document: mockDocument, + tokenRegistry: mockInputs.address, + tokenId: mockInputs.tokenId, + network: mockInputs.network, + documentId: mockInputs.documentId, + registryVersion: 'v5', + }); + (utils.promptAddress as any) .mockResolvedValueOnce(mockInputs.beneficiary) - .mockResolvedValueOnce(mockInputs.holder) - .mockResolvedValueOnce(mockInputs.encryptedWalletPath) - .mockResolvedValueOnce(''); + .mockResolvedValueOnce(mockInputs.holder); + (utils.promptWalletSelection as any).mockResolvedValue({ + encryptedWalletPath: mockInputs.encryptedWalletPath, + }); + (utils.promptRemark as any).mockResolvedValue(undefined); const trustvcModule = await import('@trustvc/trustvc'); const mintMock = trustvcModule.mint as MockedFunction; @@ -586,7 +723,8 @@ describe('token-registry/mint', () => { it('should handle errors in handler', async () => { const errorMessage = 'Prompt error'; - (prompts.select as any).mockRejectedValue(new Error(errorMessage)); + const utils = await import('../../../src/utils'); + (utils.promptAndReadDocument as any).mockRejectedValue(new Error(errorMessage)); await handler(); @@ -596,7 +734,8 @@ describe('token-registry/mint', () => { it('should handle non-Error exceptions in handler', async () => { const errorMessage = 'String error'; - (prompts.select as any).mockRejectedValue(errorMessage); + const utils = await import('../../../src/utils'); + (utils.promptAndReadDocument as any).mockRejectedValue(errorMessage); await handler(); From 3ff852fe608a068a321f0ebe3b2cdef4ae68a884 Mon Sep 17 00:00:00 2001 From: Rishabh Singh Date: Mon, 19 Jan 2026 16:14:49 +0530 Subject: [PATCH 2/3] fix: remove dryRun as a param --- src/commands/token-registry/mint.ts | 7 -- test.json | 97 ++++++++++++++++++++++++++ testSepolia.json | 104 ++++++++++++++++++++++++++++ 3 files changed, 201 insertions(+), 7 deletions(-) create mode 100644 test.json create mode 100644 testSepolia.json diff --git a/src/commands/token-registry/mint.ts b/src/commands/token-registry/mint.ts index c6c396e..37c5cd4 100644 --- a/src/commands/token-registry/mint.ts +++ b/src/commands/token-registry/mint.ts @@ -68,7 +68,6 @@ export const promptForInputs = async (): Promise => { holder, remark, encryptionKey, - dryRun: false, maxPriorityFeePerGasScale: 1, }; @@ -132,16 +131,10 @@ const mintToTokenRegistry = async ({ remark, encryptionKey, network, - dryRun, ...rest }: TokenRegistryMintCommand): Promise => { const wallet = await getWalletOrSigner({ network, ...rest }); - if (dryRun) { - console.log('šŸ”§ Dry run mode is currently undergoing upgrades and will be available soon.'); - process.exit(0); - } - // Automatic dry run for Ethereum and Polygon networks const shouldProceed = await performDryRunWithConfirmation({ network, diff --git a/test.json b/test.json new file mode 100644 index 0000000..7aca4a4 --- /dev/null +++ b/test.json @@ -0,0 +1,97 @@ +{ + "@context": [ + "https://www.w3.org/2018/credentials/v1", + "https://trustvc.io/context/bill-of-lading-carrier.json", + "https://trustvc.io/context/attachments-context.json", + "https://trustvc.io/context/render-method-context.json", + "https://trustvc.io/context/transferable-records-context.json", + "https://trustvc.io/context/qrcode-context.json", + "https://w3id.org/security/bbs/v1" + ], + "renderMethod": [ + { + "type": "EMBEDDED_RENDERER", + "templateName": "BILL_OF_LADING_CARRIER", + "id": "https://generic-templates.tradetrust.io" + } + ], + "credentialSubject": { + "type": ["BillOfLadingCarrier"], + "shipperName": "MAERSK Co.", + "shipperAddressStreet": "101 ORCHARD ROAD", + "shipperAddressCountry": "Singapore", + "toOrderOfText": "TO ORDER", + "consigneeName": "ABC Natural Foods Inc.", + "notifyPartyName": "Amanda Green ā€“ Import Manager, ABC Natural Foods", + "packages": [ + { + "packagesDescription": "Organic Cashew Kernels (25kg bags)", + "packagesMeasurement": "100 Bags", + "packagesWeight": "2.65 MT" + }, + { + "packagesDescription": "Roasted Chickpeas (20kg packs)", + "packagesMeasurement": "60 Bundles", + "packagesWeight": "\t1.3" + } + ], + "blNumber": "SGCNM21566325", + "scac": "SGPU", + "carrierName": "Vikram Rao", + "logo": "data:image/png;base64,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", + "onwardInlandRouting": "Rail to Johor Port ā†’ Trucking to final inland delivery point (Long Beach, USA)", + "vessel": "MAERSK NATALIA", + "voyageNo": "7831W", + "portOfLoading": "Singapore", + "portOfDischarge": "LOS ANGELES, CA", + "placeOfReceipt": "JURONG PORT, SINGAPORE", + "placeOfDelivery": "Long Beach Distribution Center, CA", + "placeOfIssueBL": "Singapore", + "numberOfOriginalBL": "3", + "dateOfIssueBL": "2025-06-05", + "shippedOnBoardDate": "2025-06-05", + "signForTermsAndCondition": "The carrier accepts the goods as described in good order and condition for carriage under the terms stated herein and subject to the Carrier's standard Bill of Lading Terms and Conditions.", + "signedForCarrierText": "John Doe", + "carrierSignature": "data:image/png;base64,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", + "termsOfCarriage": "All shipments are subject to the Hague-Visby Rules. The carrier assumes liability only for loss or damage due to its own negligence. Responsibility ceases at the time goods are delivered to the consignee or their agent. Claims must be submitted within 7 working days of delivery.", + "attachments": [ + { + "data": "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", + "filename": "blank.pdf", + "mimeType": "application/pdf" + }, + { "data": "e30=", "filename": "empty.json", "mimeType": "application/json" }, + { + "data": "JVBERi0xLjMNCiXi48/TDQoNCjEgMCBvYmoNCjw8DQovVHlwZSAvQ2F0YWxvZw0KL091dGxpbmVzIDIgMCBSDQovUGFnZXMgMyAwIFINCj4+DQplbmRvYmoNCg0KMiAwIG9iag0KPDwNCi9UeXBlIC9PdXRsaW5lcw0KL0NvdW50IDANCj4+DQplbmRvYmoNCg0KMyAwIG9iag0KPDwNCi9UeXBlIC9QYWdlcw0KL0NvdW50IDINCi9LaWRzIFsgNCAwIFIgNiAwIFIgXSANCj4+DQplbmRvYmoNCg0KNCAwIG9iag0KPDwNCi9UeXBlIC9QYWdlDQovUGFyZW50IDMgMCBSDQovUmVzb3VyY2VzIDw8DQovRm9udCA8PA0KL0YxIDkgMCBSIA0KPj4NCi9Qcm9jU2V0IDggMCBSDQo+Pg0KL01lZGlhQm94IFswIDAgNjEyLjAwMDAgNzkyLjAwMDBdDQovQ29udGVudHMgNSAwIFINCj4+DQplbmRvYmoNCg0KNSAwIG9iag0KPDwgL0xlbmd0aCAxMDc0ID4+DQpzdHJlYW0NCjIgSg0KQlQNCjAgMCAwIHJnDQovRjEgMDAyNyBUZg0KNTcuMzc1MCA3MjIuMjgwMCBUZA0KKCBBIFNpbXBsZSBQREYgRmlsZSApIFRqDQpFVA0KQlQNCi9GMSAwMDEwIFRmDQo2OS4yNTAwIDY4OC42MDgwIFRkDQooIFRoaXMgaXMgYSBzbWFsbCBkZW1vbnN0cmF0aW9uIC5wZGYgZmlsZSAtICkgVGoNCkVUDQpCVA0KL0YxIDAwMTAgVGYNCjY5LjI1MDAgNjY0LjcwNDAgVGQNCigganVzdCBmb3IgdXNlIGluIHRoZSBWaXJ0dWFsIE1lY2hhbmljcyB0dXRvcmlhbHMuIE1vcmUgdGV4dC4gQW5kIG1vcmUgKSBUag0KRVQNCkJUDQovRjEgMDAxMCBUZg0KNjkuMjUwMCA2NTIuNzUyMCBUZA0KKCB0ZXh0LiBBbmQgbW9yZSB0ZXh0LiBBbmQgbW9yZSB0ZXh0LiBBbmQgbW9yZSB0ZXh0LiApIFRqDQpFVA0KQlQNCi9GMSAwMDEwIFRmDQo2OS4yNTAwIDYyOC44NDgwIFRkDQooIEFuZCBtb3JlIHRleHQuIEFuZCBtb3JlIHRleHQuIEFuZCBtb3JlIHRleHQuIEFuZCBtb3JlIHRleHQuIEFuZCBtb3JlICkgVGoNCkVUDQpCVA0KL0YxIDAwMTAgVGYNCjY5LjI1MDAgNjE2Ljg5NjAgVGQNCiggdGV4dC4gQW5kIG1vcmUgdGV4dC4gQm9yaW5nLCB6enp6ei4gQW5kIG1vcmUgdGV4dC4gQW5kIG1vcmUgdGV4dC4gQW5kICkgVGoNCkVUDQpCVA0KL0YxIDAwMTAgVGYNCjY5LjI1MDAgNjA0Ljk0NDAgVGQNCiggbW9yZSB0ZXh0LiBBbmQgbW9yZSB0ZXh0LiBBbmQgbW9yZSB0ZXh0LiBBbmQgbW9yZSB0ZXh0LiBBbmQgbW9yZSB0ZXh0LiApIFRqDQpFVA0KQlQNCi9GMSAwMDEwIFRmDQo2OS4yNTAwIDU5Mi45OTIwIFRkDQooIEFuZCBtb3JlIHRleHQuIEFuZCBtb3JlIHRleHQuICkgVGoNCkVUDQpCVA0KL0YxIDAwMTAgVGYNCjY5LjI1MDAgNTY5LjA4ODAgVGQNCiggQW5kIG1vcmUgdGV4dC4gQW5kIG1vcmUgdGV4dC4gQW5kIG1vcmUgdGV4dC4gQW5kIG1vcmUgdGV4dC4gQW5kIG1vcmUgKSBUag0KRVQNCkJUDQovRjEgMDAxMCBUZg0KNjkuMjUwMCA1NTcuMTM2MCBUZA0KKCB0ZXh0LiBBbmQgbW9yZSB0ZXh0LiBBbmQgbW9yZSB0ZXh0LiBFdmVuIG1vcmUuIENvbnRpbnVlZCBvbiBwYWdlIDIgLi4uKSBUag0KRVQNCmVuZHN0cmVhbQ0KZW5kb2JqDQoNCjYgMCBvYmoNCjw8DQovVHlwZSAvUGFnZQ0KL1BhcmVudCAzIDAgUg0KL1Jlc291cmNlcyA8PA0KL0ZvbnQgPDwNCi9GMSA5IDAgUiANCj4+DQovUHJvY1NldCA4IDAgUg0KPj4NCi9NZWRpYUJveCBbMCAwIDYxMi4wMDAwIDc5Mi4wMDAwXQ0KL0NvbnRlbnRzIDcgMCBSDQo+Pg0KZW5kb2JqDQoNCjcgMCBvYmoNCjw8IC9MZW5ndGggNjc2ID4+DQpzdHJlYW0NCjIgSg0KQlQNCjAgMCAwIHJnDQovRjEgMDAyNyBUZg0KNTcuMzc1MCA3MjIuMjgwMCBUZA0KKCBTaW1wbGUgUERGIEZpbGUgMiApIFRqDQpFVA0KQlQNCi9GMSAwMDEwIFRmDQo2OS4yNTAwIDY4OC42MDgwIFRkDQooIC4uLmNvbnRpbnVlZCBmcm9tIHBhZ2UgMS4gWWV0IG1vcmUgdGV4dC4gQW5kIG1vcmUgdGV4dC4gQW5kIG1vcmUgdGV4dC4gKSBUag0KRVQNCkJUDQovRjEgMDAxMCBUZg0KNjkuMjUwMCA2NzYuNjU2MCBUZA0KKCBBbmQgbW9yZSB0ZXh0LiBBbmQgbW9yZSB0ZXh0LiBBbmQgbW9yZSB0ZXh0LiBBbmQgbW9yZSB0ZXh0LiBBbmQgbW9yZSApIFRqDQpFVA0KQlQNCi9GMSAwMDEwIFRmDQo2OS4yNTAwIDY2NC43MDQwIFRkDQooIHRleHQuIE9oLCBob3cgYm9yaW5nIHR5cGluZyB0aGlzIHN0dWZmLiBCdXQgbm90IGFzIGJvcmluZyBhcyB3YXRjaGluZyApIFRqDQpFVA0KQlQNCi9GMSAwMDEwIFRmDQo2OS4yNTAwIDY1Mi43NTIwIFRkDQooIHBhaW50IGRyeS4gQW5kIG1vcmUgdGV4dC4gQW5kIG1vcmUgdGV4dC4gQW5kIG1vcmUgdGV4dC4gQW5kIG1vcmUgdGV4dC4gKSBUag0KRVQNCkJUDQovRjEgMDAxMCBUZg0KNjkuMjUwMCA2NDAuODAwMCBUZA0KKCBCb3JpbmcuICBNb3JlLCBhIGxpdHRsZSBtb3JlIHRleHQuIFRoZSBlbmQsIGFuZCBqdXN0IGFzIHdlbGwuICkgVGoNCkVUDQplbmRzdHJlYW0NCmVuZG9iag0KDQo4IDAgb2JqDQpbL1BERiAvVGV4dF0NCmVuZG9iag0KDQo5IDAgb2JqDQo8PA0KL1R5cGUgL0ZvbnQNCi9TdWJ0eXBlIC9UeXBlMQ0KL05hbWUgL0YxDQovQmFzZUZvbnQgL0hlbHZldGljYQ0KL0VuY29kaW5nIC9XaW5BbnNpRW5jb2RpbmcNCj4+DQplbmRvYmoNCg0KMTAgMCBvYmoNCjw8DQovQ3JlYXRvciAoUmF2ZSBcKGh0dHA6Ly93d3cubmV2cm9uYS5jb20vcmF2ZVwpKQ0KL1Byb2R1Y2VyIChOZXZyb25hIERlc2lnbnMpDQovQ3JlYXRpb25EYXRlIChEOjIwMDYwMzAxMDcyODI2KQ0KPj4NCmVuZG9iag0KDQp4cmVmDQowIDExDQowMDAwMDAwMDAwIDY1NTM1IGYNCjAwMDAwMDAwMTkgMDAwMDAgbg0KMDAwMDAwMDA5MyAwMDAwMCBuDQowMDAwMDAwMTQ3IDAwMDAwIG4NCjAwMDAwMDAyMjIgMDAwMDAgbg0KMDAwMDAwMDM5MCAwMDAwMCBuDQowMDAwMDAxNTIyIDAwMDAwIG4NCjAwMDAwMDE2OTAgMDAwMDAgbg0KMDAwMDAwMjQyMyAwMDAwMCBuDQowMDAwMDAyNDU2IDAwMDAwIG4NCjAwMDAwMDI1NzQgMDAwMDAgbg0KDQp0cmFpbGVyDQo8PA0KL1NpemUgMTENCi9Sb290IDEgMCBSDQovSW5mbyAxMCAwIFINCj4+DQoNCnN0YXJ0eHJlZg0KMjcxNA0KJSVFT0YNCg==", + "filename": "sample.pdf", + "mimeType": "application/pdf" + }, + { + "data": "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", + "filename": "veryverylongfilenameoverhereveryverylongfilenameoverhere.pdf", + "mimeType": "application/pdf" + } + ] + }, + "type": ["VerifiableCredential"], + "qrCode": { + "type": "TrustVCQRCode", + "uri": "https://actions.tradetrust.io?q=%7B%22type%22%3A%22DOCUMENT%22%2C%22payload%22%3A%7B%22uri%22%3A%22https%3A%2F%2Fgallery.tradetrust.io%2Fstatic%2Fbill-of-lading-inoperative.json%22%2C%22redirect%22%3A%22https%3A%2F%2Fref.tradetrust.io%2F%22%2C%22chainId%22%3A%22101010%22%7D%7D" + }, + "credentialStatus": { + "type": "TransferableRecords", + "tokenNetwork": { "chain": "FREE", "chainId": 101010 }, + "tokenRegistry": "0x7202363bBDb126036F7C3243Ebac310d9d145040", + "tokenId": "d4418cbf05cc36ec2b446cfc7d6d4fd5c96fb247c3d89e3010113c4e4165c4e6" + }, + "issuer": "did:web:trustvc.github.io:did:1", + "issuanceDate": "2025-06-05T11:29:32.860Z", + "id": "urn:bnid:_:0198cc4e-c9bb-7eec-8c1d-2d16e12b4f20", + "proof": { + "type": "BbsBlsSignature2020", + "created": "2025-08-21T11:06:12Z", + "proofPurpose": "assertionMethod", + "proofValue": "kVNo63FXss6j7tbcLQQ1z07ldT1jVxATfcHJnOPTUgR5yGbpuXYF8lxCttGRqLmOYdU8j/3m9v0dN3yh95/KDC7t0RTVCfQLApwDr16tio0ATDDQ2Ism8JNtdgbTAtFT+PDwn/emFCmMPxZ2mjo4Uw==", + "verificationMethod": "did:web:trustvc.github.io:did:1#keys-1" + } +} diff --git a/testSepolia.json b/testSepolia.json new file mode 100644 index 0000000..516eab7 --- /dev/null +++ b/testSepolia.json @@ -0,0 +1,104 @@ +{ + "@context": [ + "https://www.w3.org/2018/credentials/v1", + "https://trustvc.io/context/bill-of-lading-carrier.json", + "https://trustvc.io/context/attachments-context.json", + "https://trustvc.io/context/render-method-context.json", + "https://trustvc.io/context/transferable-records-context.json", + "https://trustvc.io/context/qrcode-context.json", + "https://w3id.org/security/bbs/v1" + ], + "renderMethod": [ + { + "type": "EMBEDDED_RENDERER", + "templateName": "BILL_OF_LADING_CARRIER", + "id": "https://generic-templates.tradetrust.io" + } + ], + "credentialSubject": { + "type": ["BillOfLadingCarrier"], + "shipperName": "MAERSK Co.", + "shipperAddressStreet": "101 ORCHARD ROAD", + "shipperAddressCountry": "Singapore", + "toOrderOfText": "TO ORDER", + "consigneeName": "ABC Natural Foods Inc.", + "notifyPartyName": "Amanda Green ā€“ Import Manager, ABC Natural Foods", + "packages": [ + { + "packagesDescription": "Organic Cashew Kernels (25kg bags)", + "packagesMeasurement": "100 Bags", + "packagesWeight": "2.65 MT" + }, + { + "packagesDescription": "Roasted Chickpeas (20kg packs)", + "packagesMeasurement": "60 Bundles", + "packagesWeight": "\t1.3" + } + ], + "blNumber": "SGCNM21566325", + "scac": "SGPU", + "carrierName": "Vikram Rao", + "logo": "data:image/png;base64,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", + "onwardInlandRouting": "Rail to Johor Port ā†’ Trucking to final inland delivery point (Long Beach, USA)", + "vessel": "MAERSK NATALIA", + "voyageNo": "7831W", + "portOfLoading": "Singapore", + "portOfDischarge": "LOS ANGELES, CA", + "placeOfReceipt": "JURONG PORT, SINGAPORE", + "placeOfDelivery": "Long Beach Distribution Center, CA", + "placeOfIssueBL": "Singapore", + "numberOfOriginalBL": "3", + "dateOfIssueBL": "2025-06-05", + "shippedOnBoardDate": "2025-06-05", + "signForTermsAndCondition": "The carrier accepts the goods as described in good order and condition for carriage under the terms stated herein and subject to the Carrier's standard Bill of Lading Terms and Conditions.", + "signedForCarrierText": "John Doe", + "carrierSignature": "data:image/png;base64,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", + "termsOfCarriage": "All shipments are subject to the Hague-Visby Rules. The carrier assumes liability only for loss or damage due to its own negligence. Responsibility ceases at the time goods are delivered to the consignee or their agent. Claims must be submitted within 7 working days of delivery.", + "attachments": [ + { + "data": "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", + "filename": "blank.pdf", + "mimeType": "application/pdf" + }, + { + "data": "e30=", + "filename": "empty.json", + "mimeType": "application/json" + }, + { + "data": "JVBERi0xLjMNCiXi48/TDQoNCjEgMCBvYmoNCjw8DQovVHlwZSAvQ2F0YWxvZw0KL091dGxpbmVzIDIgMCBSDQovUGFnZXMgMyAwIFINCj4+DQplbmRvYmoNCg0KMiAwIG9iag0KPDwNCi9UeXBlIC9PdXRsaW5lcw0KL0NvdW50IDANCj4+DQplbmRvYmoNCg0KMyAwIG9iag0KPDwNCi9UeXBlIC9QYWdlcw0KL0NvdW50IDINCi9LaWRzIFsgNCAwIFIgNiAwIFIgXSANCj4+DQplbmRvYmoNCg0KNCAwIG9iag0KPDwNCi9UeXBlIC9QYWdlDQovUGFyZW50IDMgMCBSDQovUmVzb3VyY2VzIDw8DQovRm9udCA8PA0KL0YxIDkgMCBSIA0KPj4NCi9Qcm9jU2V0IDggMCBSDQo+Pg0KL01lZGlhQm94IFswIDAgNjEyLjAwMDAgNzkyLjAwMDBdDQovQ29udGVudHMgNSAwIFINCj4+DQplbmRvYmoNCg0KNSAwIG9iag0KPDwgL0xlbmd0aCAxMDc0ID4+DQpzdHJlYW0NCjIgSg0KQlQNCjAgMCAwIHJnDQovRjEgMDAyNyBUZg0KNTcuMzc1MCA3MjIuMjgwMCBUZA0KKCBBIFNpbXBsZSBQREYgRmlsZSApIFRqDQpFVA0KQlQNCi9GMSAwMDEwIFRmDQo2OS4yNTAwIDY4OC42MDgwIFRkDQooIFRoaXMgaXMgYSBzbWFsbCBkZW1vbnN0cmF0aW9uIC5wZGYgZmlsZSAtICkgVGoNCkVUDQpCVA0KL0YxIDAwMTAgVGYNCjY5LjI1MDAgNjY0LjcwNDAgVGQNCigganVzdCBmb3IgdXNlIGluIHRoZSBWaXJ0dWFsIE1lY2hhbmljcyB0dXRvcmlhbHMuIE1vcmUgdGV4dC4gQW5kIG1vcmUgKSBUag0KRVQNCkJUDQovRjEgMDAxMCBUZg0KNjkuMjUwMCA2NTIuNzUyMCBUZA0KKCB0ZXh0LiBBbmQgbW9yZSB0ZXh0LiBBbmQgbW9yZSB0ZXh0LiBBbmQgbW9yZSB0ZXh0LiApIFRqDQpFVA0KQlQNCi9GMSAwMDEwIFRmDQo2OS4yNTAwIDYyOC44NDgwIFRkDQooIEFuZCBtb3JlIHRleHQuIEFuZCBtb3JlIHRleHQuIEFuZCBtb3JlIHRleHQuIEFuZCBtb3JlIHRleHQuIEFuZCBtb3JlICkgVGoNCkVUDQpCVA0KL0YxIDAwMTAgVGYNCjY5LjI1MDAgNjE2Ljg5NjAgVGQNCiggdGV4dC4gQW5kIG1vcmUgdGV4dC4gQm9yaW5nLCB6enp6ei4gQW5kIG1vcmUgdGV4dC4gQW5kIG1vcmUgdGV4dC4gQW5kICkgVGoNCkVUDQpCVA0KL0YxIDAwMTAgVGYNCjY5LjI1MDAgNjA0Ljk0NDAgVGQNCiggbW9yZSB0ZXh0LiBBbmQgbW9yZSB0ZXh0LiBBbmQgbW9yZSB0ZXh0LiBBbmQgbW9yZSB0ZXh0LiBBbmQgbW9yZSB0ZXh0LiApIFRqDQpFVA0KQlQNCi9GMSAwMDEwIFRmDQo2OS4yNTAwIDU5Mi45OTIwIFRkDQooIEFuZCBtb3JlIHRleHQuIEFuZCBtb3JlIHRleHQuICkgVGoNCkVUDQpCVA0KL0YxIDAwMTAgVGYNCjY5LjI1MDAgNTY5LjA4ODAgVGQNCiggQW5kIG1vcmUgdGV4dC4gQW5kIG1vcmUgdGV4dC4gQW5kIG1vcmUgdGV4dC4gQW5kIG1vcmUgdGV4dC4gQW5kIG1vcmUgKSBUag0KRVQNCkJUDQovRjEgMDAxMCBUZg0KNjkuMjUwMCA1NTcuMTM2MCBUZA0KKCB0ZXh0LiBBbmQgbW9yZSB0ZXh0LiBBbmQgbW9yZSB0ZXh0LiBFdmVuIG1vcmUuIENvbnRpbnVlZCBvbiBwYWdlIDIgLi4uKSBUag0KRVQNCmVuZHN0cmVhbQ0KZW5kb2JqDQoNCjYgMCBvYmoNCjw8DQovVHlwZSAvUGFnZQ0KL1BhcmVudCAzIDAgUg0KL1Jlc291cmNlcyA8PA0KL0ZvbnQgPDwNCi9GMSA5IDAgUiANCj4+DQovUHJvY1NldCA4IDAgUg0KPj4NCi9NZWRpYUJveCBbMCAwIDYxMi4wMDAwIDc5Mi4wMDAwXQ0KL0NvbnRlbnRzIDcgMCBSDQo+Pg0KZW5kb2JqDQoNCjcgMCBvYmoNCjw8IC9MZW5ndGggNjc2ID4+DQpzdHJlYW0NCjIgSg0KQlQNCjAgMCAwIHJnDQovRjEgMDAyNyBUZg0KNTcuMzc1MCA3MjIuMjgwMCBUZA0KKCBTaW1wbGUgUERGIEZpbGUgMiApIFRqDQpFVA0KQlQNCi9GMSAwMDEwIFRmDQo2OS4yNTAwIDY4OC42MDgwIFRkDQooIC4uLmNvbnRpbnVlZCBmcm9tIHBhZ2UgMS4gWWV0IG1vcmUgdGV4dC4gQW5kIG1vcmUgdGV4dC4gQW5kIG1vcmUgdGV4dC4gKSBUag0KRVQNCkJUDQovRjEgMDAxMCBUZg0KNjkuMjUwMCA2NzYuNjU2MCBUZA0KKCBBbmQgbW9yZSB0ZXh0LiBBbmQgbW9yZSB0ZXh0LiBBbmQgbW9yZSB0ZXh0LiBBbmQgbW9yZSB0ZXh0LiBBbmQgbW9yZSApIFRqDQpFVA0KQlQNCi9GMSAwMDEwIFRmDQo2OS4yNTAwIDY2NC43MDQwIFRkDQooIHRleHQuIE9oLCBob3cgYm9yaW5nIHR5cGluZyB0aGlzIHN0dWZmLiBCdXQgbm90IGFzIGJvcmluZyBhcyB3YXRjaGluZyApIFRqDQpFVA0KQlQNCi9GMSAwMDEwIFRmDQo2OS4yNTAwIDY1Mi43NTIwIFRkDQooIHBhaW50IGRyeS4gQW5kIG1vcmUgdGV4dC4gQW5kIG1vcmUgdGV4dC4gQW5kIG1vcmUgdGV4dC4gQW5kIG1vcmUgdGV4dC4gKSBUag0KRVQNCkJUDQovRjEgMDAxMCBUZg0KNjkuMjUwMCA2NDAuODAwMCBUZA0KKCBCb3JpbmcuICBNb3JlLCBhIGxpdHRsZSBtb3JlIHRleHQuIFRoZSBlbmQsIGFuZCBqdXN0IGFzIHdlbGwuICkgVGoNCkVUDQplbmRzdHJlYW0NCmVuZG9iag0KDQo4IDAgb2JqDQpbL1BERiAvVGV4dF0NCmVuZG9iag0KDQo5IDAgb2JqDQo8PA0KL1R5cGUgL0ZvbnQNCi9TdWJ0eXBlIC9UeXBlMQ0KL05hbWUgL0YxDQovQmFzZUZvbnQgL0hlbHZldGljYQ0KL0VuY29kaW5nIC9XaW5BbnNpRW5jb2RpbmcNCj4+DQplbmRvYmoNCg0KMTAgMCBvYmoNCjw8DQovQ3JlYXRvciAoUmF2ZSBcKGh0dHA6Ly93d3cubmV2cm9uYS5jb20vcmF2ZVwpKQ0KL1Byb2R1Y2VyIChOZXZyb25hIERlc2lnbnMpDQovQ3JlYXRpb25EYXRlIChEOjIwMDYwMzAxMDcyODI2KQ0KPj4NCmVuZG9iag0KDQp4cmVmDQowIDExDQowMDAwMDAwMDAwIDY1NTM1IGYNCjAwMDAwMDAwMTkgMDAwMDAgbg0KMDAwMDAwMDA5MyAwMDAwMCBuDQowMDAwMDAwMTQ3IDAwMDAwIG4NCjAwMDAwMDAyMjIgMDAwMDAgbg0KMDAwMDAwMDM5MCAwMDAwMCBuDQowMDAwMDAxNTIyIDAwMDAwIG4NCjAwMDAwMDE2OTAgMDAwMDAgbg0KMDAwMDAwMjQyMyAwMDAwMCBuDQowMDAwMDAyNDU2IDAwMDAwIG4NCjAwMDAwMDI1NzQgMDAwMDAgbg0KDQp0cmFpbGVyDQo8PA0KL1NpemUgMTENCi9Sb290IDEgMCBSDQovSW5mbyAxMCAwIFINCj4+DQoNCnN0YXJ0eHJlZg0KMjcxNA0KJSVFT0YNCg==", + "filename": "sample.pdf", + "mimeType": "application/pdf" + }, + { + "data": "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", + "filename": "veryverylongfilenameoverhereveryverylongfilenameoverhere.pdf", + "mimeType": "application/pdf" + } + ] + }, + "type": ["VerifiableCredential"], + "qrCode": { + "type": "TrustVCQRCode", + "uri": "https://actions.tradetrust.io?q=%7B%22type%22%3A%22DOCUMENT%22%2C%22payload%22%3A%7B%22uri%22%3A%22https%3A%2F%2Fgallery.tradetrust.io%2Fstatic%2Fbill-of-lading-inoperative.json%22%2C%22redirect%22%3A%22https%3A%2F%2Fref.tradetrust.io%2F%22%2C%22chainId%22%3A%22101010%22%7D%7D" + }, + "credentialStatus": { + "type": "TransferableRecords", + "tokenNetwork": { + "chain": "ETH", + "chainId": 11155111 + }, + "tokenRegistry": "0x3A5f212f1D1bf90a8a0B7530698e25620DEb166B", + "tokenId": "d4418cbf05cc36ec2b446cfc7d6d4fd5c96fb247c3d89e3010113c4e4165c4e6" + }, + "issuer": "did:web:trustvc.github.io:did:1", + "issuanceDate": "2025-06-05T11:29:32.860Z", + "id": "urn:bnid:_:0198cc4e-c9bb-7eec-8c1d-2d16e12b4f20", + "proof": { + "type": "BbsBlsSignature2020", + "created": "2025-08-21T11:06:12Z", + "proofPurpose": "assertionMethod", + "proofValue": "kVNo63FXss6j7tbcLQQ1z07ldT1jVxATfcHJnOPTUgR5yGbpuXYF8lxCttGRqLmOYdU8j/3m9v0dN3yh95/KDC7t0RTVCfQLApwDr16tio0ATDDQ2Ism8JNtdgbTAtFT+PDwn/emFCmMPxZ2mjo4Uw==", + "verificationMethod": "did:web:trustvc.github.io:did:1#keys-1" + } +} From 275fec372162be2c9c63ead6169f402715d14460 Mon Sep 17 00:00:00 2001 From: Rishabh Singh Date: Mon, 19 Jan 2026 16:23:10 +0530 Subject: [PATCH 3/3] fix: update mint tests --- .gitignore | 2 + test.json | 97 ------------------- testSepolia.json | 104 --------------------- tests/commands/token-registry/mint.test.ts | 7 -- 4 files changed, 2 insertions(+), 208 deletions(-) delete mode 100644 test.json delete mode 100644 testSepolia.json diff --git a/.gitignore b/.gitignore index b0c1ad2..4c7a7f7 100644 --- a/.gitignore +++ b/.gitignore @@ -7,6 +7,8 @@ didKeyPairs.json wellknown.json credentialStatus.json signed_vc.json +test.json +testSepolia.json # Dependencies node_modules/ diff --git a/test.json b/test.json deleted file mode 100644 index 7aca4a4..0000000 --- a/test.json +++ /dev/null @@ -1,97 +0,0 @@ -{ - "@context": [ - "https://www.w3.org/2018/credentials/v1", - "https://trustvc.io/context/bill-of-lading-carrier.json", - "https://trustvc.io/context/attachments-context.json", - "https://trustvc.io/context/render-method-context.json", - "https://trustvc.io/context/transferable-records-context.json", - "https://trustvc.io/context/qrcode-context.json", - "https://w3id.org/security/bbs/v1" - ], - "renderMethod": [ - { - "type": "EMBEDDED_RENDERER", - "templateName": "BILL_OF_LADING_CARRIER", - "id": "https://generic-templates.tradetrust.io" - } - ], - "credentialSubject": { - "type": ["BillOfLadingCarrier"], - "shipperName": "MAERSK Co.", - "shipperAddressStreet": "101 ORCHARD ROAD", - "shipperAddressCountry": "Singapore", - "toOrderOfText": "TO ORDER", - "consigneeName": "ABC Natural Foods Inc.", - "notifyPartyName": "Amanda Green ā€“ Import Manager, ABC Natural Foods", - "packages": [ - { - "packagesDescription": "Organic Cashew Kernels (25kg bags)", - "packagesMeasurement": "100 Bags", - "packagesWeight": "2.65 MT" - }, - { - "packagesDescription": "Roasted Chickpeas (20kg packs)", - "packagesMeasurement": "60 Bundles", - "packagesWeight": "\t1.3" - } - ], - "blNumber": "SGCNM21566325", - "scac": "SGPU", - "carrierName": "Vikram Rao", - "logo": "data:image/png;base64,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", - "onwardInlandRouting": "Rail to Johor Port ā†’ Trucking to final inland delivery point (Long Beach, USA)", - "vessel": "MAERSK NATALIA", - "voyageNo": "7831W", - "portOfLoading": "Singapore", - "portOfDischarge": "LOS ANGELES, CA", - "placeOfReceipt": "JURONG PORT, SINGAPORE", - "placeOfDelivery": "Long Beach Distribution Center, CA", - "placeOfIssueBL": "Singapore", - "numberOfOriginalBL": "3", - "dateOfIssueBL": "2025-06-05", - "shippedOnBoardDate": "2025-06-05", - "signForTermsAndCondition": "The carrier accepts the goods as described in good order and condition for carriage under the terms stated herein and subject to the Carrier's standard Bill of Lading Terms and Conditions.", - "signedForCarrierText": "John Doe", - "carrierSignature": "data:image/png;base64,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", - "termsOfCarriage": "All shipments are subject to the Hague-Visby Rules. The carrier assumes liability only for loss or damage due to its own negligence. Responsibility ceases at the time goods are delivered to the consignee or their agent. Claims must be submitted within 7 working days of delivery.", - "attachments": [ - { - "data": "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", - "filename": "blank.pdf", - "mimeType": "application/pdf" - }, - { "data": "e30=", "filename": "empty.json", "mimeType": "application/json" }, - { - "data": "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", - "filename": "sample.pdf", - "mimeType": "application/pdf" - }, - { - "data": "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", - "filename": "veryverylongfilenameoverhereveryverylongfilenameoverhere.pdf", - "mimeType": "application/pdf" - } - ] - }, - "type": ["VerifiableCredential"], - "qrCode": { - "type": "TrustVCQRCode", - "uri": "https://actions.tradetrust.io?q=%7B%22type%22%3A%22DOCUMENT%22%2C%22payload%22%3A%7B%22uri%22%3A%22https%3A%2F%2Fgallery.tradetrust.io%2Fstatic%2Fbill-of-lading-inoperative.json%22%2C%22redirect%22%3A%22https%3A%2F%2Fref.tradetrust.io%2F%22%2C%22chainId%22%3A%22101010%22%7D%7D" - }, - "credentialStatus": { - "type": "TransferableRecords", - "tokenNetwork": { "chain": "FREE", "chainId": 101010 }, - "tokenRegistry": "0x7202363bBDb126036F7C3243Ebac310d9d145040", - "tokenId": "d4418cbf05cc36ec2b446cfc7d6d4fd5c96fb247c3d89e3010113c4e4165c4e6" - }, - "issuer": "did:web:trustvc.github.io:did:1", - "issuanceDate": "2025-06-05T11:29:32.860Z", - "id": "urn:bnid:_:0198cc4e-c9bb-7eec-8c1d-2d16e12b4f20", - "proof": { - "type": "BbsBlsSignature2020", - "created": "2025-08-21T11:06:12Z", - "proofPurpose": "assertionMethod", - "proofValue": "kVNo63FXss6j7tbcLQQ1z07ldT1jVxATfcHJnOPTUgR5yGbpuXYF8lxCttGRqLmOYdU8j/3m9v0dN3yh95/KDC7t0RTVCfQLApwDr16tio0ATDDQ2Ism8JNtdgbTAtFT+PDwn/emFCmMPxZ2mjo4Uw==", - "verificationMethod": "did:web:trustvc.github.io:did:1#keys-1" - } -} diff --git a/testSepolia.json b/testSepolia.json deleted file mode 100644 index 516eab7..0000000 --- a/testSepolia.json +++ /dev/null @@ -1,104 +0,0 @@ -{ - "@context": [ - "https://www.w3.org/2018/credentials/v1", - "https://trustvc.io/context/bill-of-lading-carrier.json", - "https://trustvc.io/context/attachments-context.json", - "https://trustvc.io/context/render-method-context.json", - "https://trustvc.io/context/transferable-records-context.json", - "https://trustvc.io/context/qrcode-context.json", - "https://w3id.org/security/bbs/v1" - ], - "renderMethod": [ - { - "type": "EMBEDDED_RENDERER", - "templateName": "BILL_OF_LADING_CARRIER", - "id": "https://generic-templates.tradetrust.io" - } - ], - "credentialSubject": { - "type": ["BillOfLadingCarrier"], - "shipperName": "MAERSK Co.", - "shipperAddressStreet": "101 ORCHARD ROAD", - "shipperAddressCountry": "Singapore", - "toOrderOfText": "TO ORDER", - "consigneeName": "ABC Natural Foods Inc.", - "notifyPartyName": "Amanda Green ā€“ Import Manager, ABC Natural Foods", - "packages": [ - { - "packagesDescription": "Organic Cashew Kernels (25kg bags)", - "packagesMeasurement": "100 Bags", - "packagesWeight": "2.65 MT" - }, - { - "packagesDescription": "Roasted Chickpeas (20kg packs)", - "packagesMeasurement": "60 Bundles", - "packagesWeight": "\t1.3" - } - ], - "blNumber": "SGCNM21566325", - "scac": "SGPU", - "carrierName": "Vikram Rao", - "logo": "data:image/png;base64,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", - "onwardInlandRouting": "Rail to Johor Port ā†’ Trucking to final inland delivery point (Long Beach, USA)", - "vessel": "MAERSK NATALIA", - "voyageNo": "7831W", - "portOfLoading": "Singapore", - "portOfDischarge": "LOS ANGELES, CA", - "placeOfReceipt": "JURONG PORT, SINGAPORE", - "placeOfDelivery": "Long Beach Distribution Center, CA", - "placeOfIssueBL": "Singapore", - "numberOfOriginalBL": "3", - "dateOfIssueBL": "2025-06-05", - "shippedOnBoardDate": "2025-06-05", - "signForTermsAndCondition": "The carrier accepts the goods as described in good order and condition for carriage under the terms stated herein and subject to the Carrier's standard Bill of Lading Terms and Conditions.", - "signedForCarrierText": "John Doe", - "carrierSignature": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABCwAAAG6CAYAAADDFddpAAAAAXNSR0IArs4c6QAAIABJREFUeF7t3QHWoziWJtDoleX0ymJ6ZTO5splUVdDtcAASIKEn6f7n5MnqTgzSfcI2n4X4jx/+CBAgQIAAAQIECBAgQIAAAQLBBP4jWHs0hwABAgQIECBAgAABAgQIECDwQ2BhEBAgQIAAAQIECBAgQIAAAQLhBAQW4UqiQQQIECBAgAABAgQIECBAgIDAwhggQIAAAQIECBAgQIAAAQIEwgkILMKVRIMIECBAgAABAgQIECBAgAABgYUxQIAAAQIECBAgQIAAAQIECIQTEFiEK4kGESBAgAABAgQIECBAgAABAgILY4AAAQIECBAgQIAAAQIECBAIJyCwCFcSDSJAgAABAgQIECBAgAABAgQEFsYAAQIECBAgQIAAAQIECBAgEE5AYBGuJBpEgAABAgQIECBAgAABAgQICCyMAQIECBAgQIAAAQIECBAgQCCcgMAiXEk0iAABAgQIECBAgAABAgQIEBBYGAMECBAgQIAAAQIECBAgQIBAOAGBRbiSaBABAgQIECBAgAABAgQIECAgsDAGCBAgQIAAAQIECBAgQIAAgXACAotwJdEgAgQIECBAgAABAgQIECBAQGBhDBAgQIAAgTYC/+vHjx/pn//76582R7FXAgQIECBAgMCkAgKLSQurW90EPi9Q0v/+391a4sAECPQU+D+/worPNvyX94SeJXFsAgQIECBAYDQBgcVoFdPeyAJ7FyipvekiJf0JLyJXT9sI1BP4fye7SrMt/vZ+UA/bnggQIECAAIF5BQQW89ZWz94TSDMpfu78mrrXAr+wvlcXRyLQQyC9H6TwMvf3n24TyRH57wQIECBAgMDqAgKL1UeA/tcQOPs19Wj/KbhwX3sNffsgEEsgzaRKAWbJnwCzRMk2BAgQIECAwLICAotlS6/jlQSuXJzsHdLtIpUKYTcEgggc3Rp2Fl66XSxI8TSDAAECBAgQiCUgsIhVD60ZT+DO7Iq9XrqvfbzaazGBPYG9EDOd3+lWEaGFMUOAAAECBAgQuCAgsLiAZVMCXwJnsytyFyhnmO5tN9QIjCtw9HSQ1KOzW0XcHjJuzbWcAAECBAgQaCQgsGgEa7dLCJwFFtu5tU31Lr2nfYNz8bLEENLJCQX2AosthMwtyOm8n3BA6BIBAgQIECBwX0Bgcd/OKwkc3aueZlekC5TvvxRe/FX4NBHBhfFFYEyBs8Ai9SgXWphhNWbdtZoAAQIECBBoICCwaIBql8sIHK1fcRRYbDBXZ1341XWZIaWjEwjkAovUxdxivUKLCQaCLhAgQIAAAQLPBQQWzw3tYV2Bs6cBlFxwpF9a0z+lt4sILtYda3o+jkBJYFESWvh8HqfmWkqAAAECBAg0EvCFqBGs3S4hcBZY5GZZfAPlfnHdthdaLDG0dHJggb2ZV0cBZu4RqCXB58BUmk6AAAECBAgQOBcQWBghBO4L5C42roYLpWtcXN3v/R56JQECVwX23hfOPmvPHo18Nfi82lbbEyBAgAABAgRCCwgsQpdH44IL5BbPS82/Ey6UzLZIFzJp3+nf/ggQiCNwZYZFanXufL/zHhJHQ0sIECBAgAABAg8EBBYP8LyUwD/rT5z9OroB3Z3WnZvBkfZ/d9+KR4BAG4GrMyxSK3LnuvO8Ta3slQABAgQIEAguILAIXiDNCy+Qu9B4Glrkfn0VWoQfIhq4mMDVGRaJJzdby60hiw0i3SVAgAABAgT+LSCwMBIIPBPIXWhse39ywVESWpg2/qyOXk2glsCdGRbp2Lnw0zleq0L2Q4AAAQIECAwjILAYplQaGligJFBIzX8SWrigCTwANI3Ah0DpY02/0UrCT5/ZhhoBAgQIECCwlIAvP0uVW2cbCrwVWuSO41fYhkW2awIFAncDi7Rr53cBsE0IECBAgACBdQQEFuvUWk/bC+QuNrYWPA0Vcsd5uv/2Uo5AYF6BJ4FFUsndGmIBznnHjp4RIECAAAECXwICC0OCQF2B3MXGW6GFi5q6dbU3AqUCTwOL3K0hT28tK+2H7QgQIECAAAEC3QUEFt1LoAETCkQJLcy0mHBw6VJ4gaeBRepg7j3EuR1+GGggAQIECBAgUENAYFFD0T4I/Cmw92jDPaenFx6520PMtDA6CbwrsHdOXj3PS2ZZpH2m2Rb+CBAgQIAAAQLTCggspi2tjnUWyF1wfDbvaaiQCy2uXix1pnN4AkML7J37d87B3Hnt1pChh4nGEyBAgAABAiUCAosSJdsQuCcQKbR4GorcE/AqAusJ1Aosklxuppbzer3xpccECBAgQGApAYHFUuXW2Q4CuV9JtyalX0ufTvHOHevOr7wdyBySwNACe4HF3dkQudDz7n6HBtZ4AgQIECBAYB0BgcU6tdbTfgK5IOEztEi/mD75yx3LL7JPdL2WQF6gZmCRjpZbgNM5na+JLQgQIECAAIFBBQQWgxZOs4cTyAUJnx16el7mjmWmxXDDR4MHE9i7lePueW2WxWDF11wCBAgQIECgnsDdL1D1WmBPBNYRyAUJm8Qbt4c499cZd3r6vsDerIgn55xZFu/X0BEJECBAgACBAAJPvkAFaL4mEBhOIHfh8RlauD1kuPJqMIF/Ceyd509v3cgtwOnz3OAjQIAAAQIEphPwBWe6kurQAAKRQgvvAQMMGE0cTqBFYJGboeVWr+GGiQYTIECAAAECOQEXKzkh/51AfYF0T/rPHz9+pH/n/mo8BSB3ofP0l99cH/x3AqsJ1Hy06afd2SyLGu8Vq9VJfwkQIECAAIHgAgKL4AXSvKkFclO8Pzv/9Fw9Cy1c6Ew9zHSug0DtJ4VsXRA+diimQxIgQIAAAQL9BJ5eBPVruSMTmEPgyu0hacp3Chfu/uWOZabFXVmvI/C7QKvAIh3FLAujjQABAgQIEFhGQGCxTKl1NKjA1dtDnoYWfqENOhA0azqBmo82/cRxDk83VHSIAAECBAgQOBIQWBgbBPoL7P0ae9QqjzztXy8tIFAi0GLhze24ZlmUVMA2BAgQIECAwPACAovhS6gDkwhcCS1Sl58+EcDtIZMMHN0IK7A3E6LWbVfO37Bl17CFBbYZk3//MkjvAf4IECBA4KGAwOIhoJcTqCyQuxD5PNzT0CK3EOfT208q09gdgaEEWq5jkSDMshhqOGjspALpPE///LXz5C8LWk9adN0iQOBdAYHFu96ORqBE4M3QInesWr8Il/TbNgRmEmgdWDh3Zxot+jKaQOn6U09/WBjNRXsJECBQXUBgUZ3UDglUEchdjHwe5OkXIov4VSmZnRD4Q6DVwpvpQLnbyJ6+LygnAQJ/CpQGFdsrzbIwiggQIPBQQGDxENDLCTQUyAUJNUOLXEBipkXDQtv1tAJ751XNz92z89aF0rTDSsc6CFwNKj6bWPOc79B1hyRAgEBfAW+iff0dnUBOQGiRE/LfCcQVaLnwZup1bpaFoDHu2NCyMQS2NSp+3myumU434byMAAECm4DAwlggEF/gSmjx9FfV3LFcAMUfL1oYR2AvUKh9Dll8M069tWQugdznYUlva5/vJce0DQECBKYSEFhMVU6dmVjgyhcnocXEA0HXhhJovfBmwsi9N/icH2rIaGwAgdw5VdLE9DnsSVslUrYhQIBARsAXGUOEwDgCV79EPfllx5oW44wLLY0t8D0D4mmguNfbs1kWT94HYstqHYF6AtsaFWmP6X/f/dtCinSe+yNAgACBCgICiwqIdkHgRYHcPevfTXlysZJb0M+vRy8W3qGGFWi98GaCyZ2r6X3AHwECfwo8WUxz25vZFEYWAQIEGgoILBri2jWBhgK5GRCfh36y6JcLoYZFtOslBFovvJkQc0Hmk+ByiSLp5HICNYIKsymWGzY6TIBADwGBRQ91xyRQR+DKLSJPQouz47SY3l5Hx14IxBDYCxOenI9HvRIuxqi3VsQWqBFU+NyLXWOtI0BgMgGBxWQF1Z3lBN4KLVwMLTe0dLiSwBsLb+ZmWbjAqlRMuxlWQFAxbOk0nACB1QUEFquPAP2fQSA3Hfyzj09+2T0LLZ7sd4Ya6AOBM4G9RTFbfP5afNM4JPC7QI2gwuebUUWAAIGOAi2+MHXsjkMTWFqgdF2LJ7+2Ci2WHmI6f1Ng77xpsa6EmVA3C+Rl0wkIKqYrqQ4RILCqgMBi1crr96wCV24RuXv+n/2K65eoWUeWfj0ReGPhzdS+3GyrFiHJExevJVBbIJ0Dn48ovbN/T/24o+Y1BAgQaCRw94KlUXPslgCBCgJXQos7FzAuiioUyS6WEnhr4c2EahbUUkNLZz8Ernz27cE9mX2oEAQIECDQSEBg0QjWbgl0Fij94nb3l6Tc/r23dB4ADh9O4HtmUquLo7NAsdUxw2Fr0DICtW79SOdG+scfAQIECAQTcFERrCCaQ6CyQOm6FndmWnjcaeVi2d3UAm8FFgnx7Ly/c65PXRidG1KgVlCRPsf8ESBAgEBgAYFF4OJoGoFKArnZENth7qw/Yfp5pSLZzfQCb61jkSCFidMPp2U7WCOoMNNo2eGj4wQIjCggsBixatpM4LpAr9DCr7nXa+UVcwrshXstP4M94nTOcbRqrwQVq1ZevwkQWF6g5Zel5XEBEAgmkFss8+5MC/fMByu05oQU2DtPWv7Sa/ZTyGGgURcFngYV27oUKTz3R4AAAQIDCggsBiyaJhN4KFCyrsXV20POZnBc3dfD7nk5gZACbz4pJAHkAkqf/yGHiUb9EngaVKTd+OwxnAgQIDCBgC8sExRRFwjcECi5ReTql72zIMR7zY0iecl0At/nSMsZFgnP4pvTDaHpOySomL7EOkiAAIFrAi4irnnZmsBMArVDC7eGzDQ69KWFwNvrWDgnW1TRPlsI1AoqPJ60RXXskwABAh0FBBYd8R2aQACB3LTx1MQrMy3O9mcBzgAF14SuAm8+KWTrqMU3u5bcwU8EtpAibZL+992/9BklqLir53UECBAILiCwCF4gzSPwkkBuXYsrU9eP9nVlHy9122EIvCrw9joW24VgOif3/pyTr5bfwX4J1JhNkXYlqDCkCBAgsICAwGKBIusigUKB3C0ipTMtzmZZlO6jsMk2IzCUQI/AIgGZZTHUMJm2sYKKaUurYwQIEGgnILBoZ2vPBEYUyIUWpb/ImmUxYvW1+Q2BtxfeTH06O69Lz+k3bBxjPoHtVo+fD2/7SDJprG6zKuaT0iMCBAgQ2BUQWBgYBAh8C+RCi9JZEkehRenrVYbAjAJvL7y5GQoRZxxNcftUazZF6qFbP+LWWcsIECDQXEBg0ZzYAQgMKZALLUp+lT3aR8lrh0TTaAIFAnvnxRufxWfr1AgRCwpnkyKBWkFF+pz4+58jpvPFHwECBAgsLPDGl6SFeXWdwPACTy9yzLIYfgjoQGWBXutYpG6YZVG5mHb33wKCCoOBAAECBJoICCyasNopgakEntz/bpbFVENBZyoI9Awszs5lsywqFHexXdQKKRKb9SkWGzy6S4AAgVIBgUWplO0IrC3wZKbF0RMK/vPXl9S1ZfV+RYEeC28m57Mn+KT/7jvBiqPxWp/TGNqCimuv3N9aUFFD0T4IECAwsYAvJxMXV9cIVBbIrWtxFEAcXSRZy6JygexuGIG9EO+tz+Oz83jFEHF7isX2779+rZ2wDab0PpX+WfnvM6DYnJ56mNHzVNDrCRAgsIjAW1+QFuHUTQLTC5z9Qnu2SJpZFtMPDR28INDrSSGpiblzOIUWs//dvQDfgou0GOTn3/b/nynYuGuUGzuCipyQ/06AAAECvwkILAwIAgSuCqRfaNOvkEe/tO39SmuWxVVl288ssHc+vDm74ewWrzfb8WaNa663UNLu73BjhJkarYzc9lEyYmxDgAABArsCAgsDgwCBOwK5e+H3fkUzy+KOtNfMKNBz4c3kudIsi1zA+vb42maipeP2CjE+w+afvwBq3erx6SmoeHt0OR4BAgQmFBBYTFhUXSLwkkDu17jvX2o9MeSlwjhMeIHegUUCmnmWRe69KeoA+Q4zUj++bzPJ3XbyHTyk/zvNiNuCqjf6ngLrXmHMG/1zDAIECBB4UUBg8SK2QxGYVOBo5kTq7vdMC7MsJh0EunVZoNeTQraGns2yGHWdgVGDisuDJ+ALzKYIWBRNIkCAwAwCAosZqqgPBPoLnD154PPixyyL/rXSghgCPRfe3ATOwsaR1rIQVPQZ01tIkY6em/nRp4WOSoAAAQLDCwgshi+hDhAII3A2xfzzEaZ7F0kecRqmjBryksB3eNfjHJhhlkXuccsvlXOZw5hJsUypdZQAAQIxBAQWMeqgFQRmESiZaXEUbIw6DX2W2unHuwK9nxRSMssi+neEp2FFyQyBVKfPdSHeXg/i3VG5fzQhRYQqaAMBAgQWFYj+ZWTRsug2gaEFzi4itl+RzbIYusQaX0EgwsKbqRtn52vk20LuhhXbwpa1F4XcQo3vcKPF0zcqDL/sLoQUWSIbECBAgMAbAgKLN5Qdg8B6ArnHnh6JRL5AWq+Ketxa4Du46zH+c+dqxO8Jd8KKnk+u+JylkWZoRAsxtvUn/vZ0j9anvP0TIECAwFWBiF9ErvbB9gQIxBS4c1HR4z7+mHpatYLAd2DRa/yP9ojTs8VCP8dN9FkC37ebpLanQCMFBz9/hQc1wo1tVknadwpuPh+XarHMFd5p9JEAAQIDCwgsBi6ephMYQCD36+1eF7wvDVBYTawisHfh3WP8n52nvUKUI+CSIDR6UHF38HzedpL6uP3f2//+Dh+EEXelvY4AAQIEwgj0+GIUpvMaQoDAawKlv4imBkW7QHoNyYGWE9i7+O71uTzCLIuSsMLivcudRjpMgAABAjML9PpiNLOpvhEg8KfA1ZkW3puMohUE9i7Ae6xjkaxHmGWRCz6FFSucNfpIgAABAksJuChYqtw6S6C7QO6CY2tgr4u27kAasJTAXmDR86L7bJZF7+8LudkVPd2WGrQ6S4AAAQIE3hTo/QXkzb46FgECMQTOLoq2FrotJEattKK9QJSFN1NPo94WUjJDS8jZfqw6AgECBAgQeF1AYPE6uQMSIPCPQO7X0oTk/clQWUEgysKbm/XRLKieIWLu/cLsihXOFH0kQIAAgSUFXBAsWXadJhBCIHcR0vMCKQSQRiwhEGmGRcRZFrnZFd4nljhNdJIAAQIEVhUQWKxaef0mEEMgF1r45TRGnbSinUCkhTdTL6Mtvuk9ot3Ys2cCBAgQIBBeQGARvkQaSGB6gdwvqEKL6YfA0h3cWzei95iPtJbF2UK9vZ2WHrg6T4AAAQIE3hAQWLyh7BgECOQEhBY5If99VoG9sd/7QvxsVsObbTO7YtZRr18ECBAgQKBQQGBRCGUzAgSaC+QeeZruVU8XS+nf/gjMIrAXWPRelyHKbSFn7wm9jWYZf/pBgAABAgRCCwgsQpdH4wgsJZD7NXXDePMX3qUKoLNdBCIGFgmi920hufcD7wNdhquDEiBAgACBdwUEFu96OxoBAscCudtCPl/pYsVImklgbybBf3aeTdR7lkUusPD9ZaYzQF8IECBAgMCBgA98Q4MAgUgCZ7/qfrdTaBGpctryRGBv3PcOLFJ/zm7JaP39we0gT0aU1xIgQIAAgUkEWn/hmIRJNwgQeEngyiyL1CShxUuFcZimAnuBRYQ1Gs7Ox9bnnqeDNB1ydk6AAAECBMYQEFiMUSetJLCKwNXAQmixysiYu597tz+0DgRKRHPnY6vvELnbQSLMPinxsw0BAgQIECDwUKDVl42HzfJyAgQWFji6LST94pwuoPb+PEFk4QEzQdejLryZaHssvpkLLHx3mWDQ6wIBAgQIECgR8KFfomQbAgTeFDj6VTeFEn//c1/9z5PGRPhV+k0rx5pD4GjMR/iM7rH45llIEuFWmTlGnV4QIECAAIEBBCJ8GRqASRMJEHhZ4Oj+9fSelfv1VWjxcrEcropAxCeFbB17e5aFwKLKkLITAgQIECAwvoDAYvwa6gGBGQWOLli2e9dz99YLLWYcFXP3aW/MRxnHb8+yOAssopjMPRr1jgABAgQIBBEQWAQphGYQIPCbwNEsis/p4EILg2YmgahPCtmMz57aUXsRTE8ImWlk6wsBAgQIEHggILB4gOelBAg0EzgLI77ft85uEfFrbLMS2XFlgb1xHGm9hrPzrHY7BRaVB5fdESBAgACBUQUEFqNWTrsJzC9wdNGy92vumxdT88vf7+H3U1zShay/MoHIC29uPXhrloXAomzM2IoAAQIECEwvILCYvsQ6SGBYgaP72I9mTQgt3i91ushO//x18sjZ1CozXfK1OQosat9ukW/J8RZvnWMCiydV8loCBAgQIDCRgMBiomLqCoHJBM4eb5ou4vb+ck8Q8Z5XZ5BsQcXZI2b3jiS4OPeP/KSQreVvzLIQWNQ5T+2FAAECBAgML+DL+/Al1AECUwucPd70qOO5xTgj/WI9YvFyoVCuT+k2kb//2Sjtx9/vApGfFLK1tPUTPJy/zgoCBAgQIEDgvwUEFgYDAQKRBXKPNxVavFu93MXkldaYbfGnVvQnhWwtPpsB8fR7RW6MCRyvnGW2JUCAAAECgws8/WIxePc1nwCB4AJ3A4u3fg0Ozle1eU9nVuw1Rmjxu8qRcbTP6pZP5smNs2gWVU8yOyNAgAABAgR+F/DBb0QQIBBZ4M46Ft/9aT2FPbJfzbad/ar+5Di1H4n5pC29XzvCwpvJKDcL4sl3C4FF71Ho+AQIECBAIJDAky8VgbqhKQQITCpQI7BINC1/EZ6U/rdu5S4inxqYafFvwVECi9w59SSEyo0131uenm1eT4AAAQIEBhLwwT9QsTSVwKICdxbe3KMSWtwfQK1mV3y26MlF7v2exXvlnnVEm1azLM5mREV0iDeCtIgAAQIECEwkILCYqJi6QmBSgaOL5TuL7wktrg+S3C/e36FDegJI+vvr14yBK0c00+LHj1EW3kx1PRsbd8MFt3BdOWNsS4AAAQIEJhcQWExeYN0jMIHA04U3vwmEFtcGRUlgcRQ0lLz2uzV3L3Sv9Sru1qMsvJkEW8yyOJvNI9CKO261jAABAgQINBEQWDRhtVMCBCoKHAUWTy5ezi60nuy3YrfD7Cp3O0hJwHA1uFi5BiOtY5EGac1ZFrkA5M6sqjAnkoYQIECAAAEC1wUEFtfNvIIAgXcFji6IalzUtghD3tVpe7TcBWQ6emkdzqb67/WiJAhp2/s+ex8tsEhKZ6HW1ZCh5r76VNBRCRAgQIAAgWoCAotqlHZEgEAjgVpPCtlrXtr3z4O1FkovxBt1O8RuS2ZGXPkcKdnfZ8dXDS1GWXhzq9VZsHWlhjVna4Q4gTSCAAECBAgQeCZw5YvmsyN5NQECBO4JtAwsthYd/aq7emiRmxVx5WJ0s74aWqxYg5EW3tzqejZWSmdZ5MaG7yz33kO9igABAgQIDCvgw3/Y0mk4gaUE3vjF2e0hfw6p3PoVd8OE3IXpd0vuHmfUk+RoLEb+zK4xy8IMi1FHrHYTIECAAIFGApG//DTqst0SIDCgwBuBRWJpuV7GaOwl61eU/nK+13ehxfGIGHEdi9Sbs1kWJbNxnr5+tHNMewkQIECAAIGMgMDCECFAYASBo1/6W7yHmWnx7xFREig89S85xuf4XGWmxVFgEb3/T2dZCCxGeDfWRgIECBAg8KLA0y+bLzbVoQgQWFjgzcDi7GL9yYyC0cqXW7+i1sXz1dBilRq8Nauo9rh8EjqcvbbWeKvdX/sjQIAAAQIEGgoILBri2jUBAtUE3g4szkKLVS6c3goszqz3BlDJrQXVBl7HHY24jkXiyt1KdBY4PQk7OpbKoQkQIECAAIFWAgKLVrL2S4BATYGjC5nWv7Yf/frf+rg17e7uK7fgZm2DXEDy2Y8VQoteY/7uePl83d1bQ8ywqKFvHwQIECBAYCIBgcVExdQVAhML9Py1edWFOHOBRYvPjyuhxewzXUYPy87Gz1HYZYbFxG/iukaAAAECBO4ItPjCeacdXkOAAIEzgd6/No9+8XhndOUCi9ozLFIb0y/zP3/9u6TNLdpQctw3thl14c3N5s6tIQKLN0aWYxAgQIAAgYEEBBYDFUtTCSws0DuwSPSrzbTIzXZoFRbkLnQ/T4PZbw0ZdeHNrUZXA4ir2y/8lqjrBAgQIEBgDQGBxRp11ksCowtECCzOQotWF+8969YrsEh9vhJazHxrSM9boWqMvVwdvwMngUUNdfsgQIAAAQITCQgsJiqmrhCYWCBKYLFdTO/dtjDbhXPPwOIsHNob5rN+lkUa93ffXnKhxed5c3Yb0mzn111PryNAgAABAksJzPolb6ki6iyBBQSiXbitsKZF78AiDetcG7ahP+utIUcX+6PN6MnVMdVvCwOP3s4EFgu80esiAQIECBD4FhBYGBMECIwgEC2w2C6uZp5pkbvIfOvzI7f45zZ+R7uILznvjgKLEQOa3HjKeQgsckL+OwECBAgQmFDgrS+cE9LpEgECLwpEDCxS92eeaZELCt76/MjdUrANwxEv4ktOodEX3tz6WFrHI5O3xltJTWxDgAABAgQIvCTgC8BL0A5DgMAjgcjBwNGjOEf+RfjI+7OIb35+lLQntW1k86MTZPSFNz/7VVrHb4sZ6/roDdGLCRAgQIDAKgJvfuFcxVQ/CRCoLxB1hsXW01nWGtj6k7uw7HEBWXJLwYyzLKKP/atne25s7e1vxtt9rrrZngABAgQILCkgsFiy7DpNYDiByDMsPi/y//r1SM5P4B4X908LnLuo7NGn0lsKerTtqffZ60cY+1f7nxtfo58/Vz1sT4AAAQIECBwICCwMDQIERhAY5VfmWWZa5Nav6PWLd8ksizSee7Wvxbk008Kbnz6pX9vtVEdus4VPLcaHfRIgQIAAgakFBBZTl1fnCEwjMNKvzKmto8+0OAssel9E5sKUNOhnuzVkloU3996Q0vmS/tLeknM5AAAgAElEQVQTd7bapX+ncbY97nSaNzIdIUCAAAECBK4JCCyuedmaAIE+AiMFFkno6Ffx3hf7JdXL3XrRuw+59m19nGmWxUwLb5aMQdsQIECAAAECBP4lILAwEAgQGEFglFtCPi1HfXpIbn2BCJ8bJbeGzDTLYsTxP8L7ijYSIECAAAECwQUifPEMTqR5BAj8EkgX4Okv/Tvd8vD3r3/ngNJ233/pYvLKdO/RZlhs/R1xpkXk20E+XdMtBNuYPBqDs8yyGHX8594b/HcCBAgQIECAwKmAwMIAIUDgSOBzQbzcheFTxXSbwfa33dP+uc+jX5h7355Q2u+99kecAZCbXRHJO9fWrTYzfM7NuvBm6fljOwIECBAgQGBRgRm+yC1aOt0m0ETg6DaGJgfL7HQLMdKF/dHTBEb5Bf1spsXV2SatalESAET7zFjl1hCBRatRb78ECBAgQIBAaIFoXz5DY2kcgYkFSi5WI3Z/lMBis4s406I0pIo0u2LzLF2Ac4bPOgtvRnwH0iYCBAgQIECgqcAMX+KaAtk5gckFRg0qPsuyrYWR1srY/veV9THeLnGU9QhKg4rNJ+rnRckYjnj7zdVxJ7C4KmZ7AgQIECBAYHiBqF9Ah4fVAQIDCJRc6A3QjWwTvwONdKHeO9jouSbH1aAiAUecXfFZ+JJbQ0abjfM9sD0pJHuq24AAAQIECBCYTUBgMVtF9YdAmcAqYUWJxrZGRvr35xNN9hb/LNlf6TZHNWgZDpRc2H+3v2V7Sq1y261wa8hRH0cPYnK19d8JECBAgACBhQUEFgsXX9eXFrgaWBzdYvH5aNPtf3//O0G3fspIy2J+ztDYjlNrocw3Qos7Myq2fo4QVmxtLRnTo98asvfI2dH71PLctW8CBAgQIEBgcAGBxeAF1HwCNwVyv7Rvsw1azTJIF9GfIcZfA4ca3zMzrt5uUjO02EzTv5+YpqCiVihzc4heflnpLIuRZyQILC4PCy8gQIAAAQIERhYQWIxcPW0ncF/gLLDo/YvtTGHGd4U+Z2ukQGGbjXI0AyUFB5/bfe5vW4uj5uyV1kHV/RFb9srZZ1lYeLNsHNiKAAECBAgQmERAYDFJIXWDwEWBkgu7SL9EH7X381aVmhfuFzmH3zw5brMqRu9MbvZQ6l+ksX3F28KbV7RsS4AAAQIECAwvILAYvoQ6QOC2QMmFXZQ1DO7cNvF5e8SGlGYrpD/hxv88KWWWoGKrcemtISN+/kV5JO7tNx0vJECAAAECBAhcERjxC9uV/tmWAIFjgdILuwihxZ3AorT23+s+fF74lu5jpO1mmk1x5D5SGHdl7Byds71v47rSB9sSIECAAAECBIoFBBbFVDYkMK3ACBd3PX9Z/lx49MlClj0H0BZSpDYcPfGlZ/tqH7s0jBvx1hALb9YeLfZHgAABAgQIhBUQWIQtjYYReFWgZE2L1KBesy1azrC4C/19y8l2u0na31u3nKTwYVt887MfaTHPq08ruesQ9XUlY3rEmQkCi6gjTrsIECBAgACB6gICi+qkdkhgWIGSC7xeoUXEwOJqoXNP9djCh8/9pv/f0QyYXuHR1X733L5k9tBosywsvNlzRDk2AQIECBAg8KqAwOJVbgcjEF6gNLR4O7joeUtIhKLNENj0cCy5NWS0WRYebdpjJDkmAQIECBAg0EVAYNGF3UEJhBZIF3k/L9zW8MYv/S7Yf/xgcO+0KZll8cYYvtf6P191FMKM1IdaFvZDgAABAgQITC4gsJi8wLpH4IHAldkW6VfqtG7C5wKVDw79x0tdrP+bZPWZJnfG1GyzLAQWd0aB1xAgQIAAAQJDCggshiybRhN4TaDkYu+zMa2Ci6ML9dGm89conPDmuuJssywsvHl9DHgFAQIECBAgMKCAwGLAomkygQ4CV2ZbbM2rOUXdwpO/F11ocf0k2LvI/97LKAtwHvXFZ/r1ceEVBAgQIECAQGABX24CF0fTCAQU6BVcmGHx52AQWlw7QUrG7igzdiy8ea32tiZAgAABAgQGFRBYDFo4zSbQUSBd+P11YVHOzxkX6YIw/XP17+gCbZQLzKv9Ld3emhalUv/ebpZZFup+re62JkCAAAECBAYVEFgMWjjNJhBA4G5wcWedC7MJjgvu4rX8ZChZk2WEEMzCm+U1tyUBAgQIECAwsIDAYuDiaTqBIAIlU+2PmprWuSiZdWGGxXmx93xGuPDuMYRLFuCMvpbFUWCh5j1GlGMSIECAAAECzQQEFs1o7ZjAcgJ3Z1wkqBRcpL+jx6JadDM/nPaMai58mm/BGFvMMsvCk0LGGG9aSYAAAQIECDwQEFg8wPNSAgR2BbbQ4edNn71ZF2ZY5DHThXgyT//+/Is+WyDfs/pbzDDLwqya+uPCHgkQIECAAIFgAgKLYAXRHAKTCTy9XSRxpH2YYVE2MI5mDwgtfvebYZaFtUvKzglbESBAgAABAgMLCCwGLp6mExhI4ElwcdZNtzz8qbNnbW2DP51Gn2UhsBjoDVBTCRAgQIAAgXsCAot7bl5FgMB9gZrhhcBivw7Ws8iPz9FnWZhNk6+xLQgQIECAAIHBBQQWgxdQ8wkMLPB0rYvUdYHF8QDYCy3cGvK71+izLCy8OfAboKYTIECAAAECeQGBRd7IFgQItBV4GlyUPhq1bS/i7X3vF3i3hvxep9FnWQgs4p13WkSAAAECBAhUFBBYVMS0KwIEHgs8CS/Sxfjf/7Tg6NGojxs34A7cGpIv2sizLDwpJF9fWxAgQIAAAQIDCwgsBi6ephOYWCD98r09pvNON90q8j9qe7/Ce+//H5+RZ1lYePPOu4PXECBAgAABAsMI+NI6TKk0lMCyAiW/gB/huF3k3zNOfn4BCXR+BykZYxHX/zhqt8/2Zd8udZwAAQIECMwl4EvNXPXUGwIzCtR4qsjqt4uYZZE/M/aMPl8Vcf0PTwrJ19UWBAgQIECAwMACAouBi6fpBBYRKPn1+wrFirML9i5sV3Q4Gycl4yzaZ+ZRYBExXLlyjtqWAAECBAgQIPAvgWhfvpSFAAEC3wJnv3yni+6/fq13cVVutQv27wtyF7W/j5gR17I4avNqY/vquW97AgQIECBAYBABgcUghdJMAgsLHAUWnxfcTxbpXOXibu/WmojrMvQc6iPOsrCORc8R49gECBAgQIBAUwGBRVNeOydA4KHA2a/eR0HD3TUvVljn4jv8McvizwGaW8siWsB1FFgIox6++Xg5AQIECBAg0F9AYNG/BlpAgMCxwFn4kLtwTK91u8jvtnsXty5sfzfKBV7RQh6BhXdQAgQIECBAYFoBgcW0pdUxAlMInF08ll5oPw0uEmTaxwx/Ft/MV7FkLYvSsZc/2vMtLLz53NAeCBAgQIAAgaACAoughdEsAgT+JXA2Pf/q+9cWOvy8YTvT7SJuC8kPgNxaFpFmWRyFepHamBe3BQECBAgQIEBgR+DqF36IBAgQeEvg7JfuJxdjT4KL1Pd0K0r6G3XWhdtC8iN4pFkWZljk62kLAgQIECBAYFABgcWghdNsAgsIPFm/ooTnyZNFtv2PGF7sXeBGusWhpHZvbDPSLIujmUjq+sZIcQwCBAgQIECgmYDAohmtHRMg8FCgdWDx2bzcQoulXdkCjDQDJP0T9c9tIWWVyT0xJEogcNTO3MK0ZQq2IkCAAAECBAh0EhBYdIJ3WAIEsgI116/IHuzXBrWCi+1429oXW3gRJcT4tnVhuz9CcuPhya1JpWOyZLuj2SBR2lfSB9sQIECAAAECBP4QEFgYFAQIRBXoEVhsFk+eLFLiuc3ESNu+ORsj3Q6SFh1N//78E1jsV22UtSzOghWf8yVnpG0IECBAgACBkAK+yIQsi0YRWF7gzdtBzrBrrHNRWsxt9sXfHy+otbDnUVCxHcpnwXGVRphlUePxv6Xj1HYECBAgQIAAgdcEfEl9jdqBCBC4IBAlsPhs8tOni1zo/u6me4FG+v+lMCK1bQtXtv/fX7/28j2b4nvnZlecV2aEWRZnbYyyzsbT8e/1BAgQIECAwIICAosFi67LBAYQ6Hk7SAnPFg6kUCAXCJTsr9c2wooy+eizLM4CCzUuq7GtCBAgQIAAgYACAouARdEkAosLnF0cRl1EcJt9MVKA4UL22okW/YkhFt68Vk9bEyBAgAABAgMICCwGKJImElhMIOLtIFdLsM3ASK9Li1xG+kuhTworojyxJJLNWVtyt4b0DtOOAovUJ5/1o4wy7SRAgAABAgR+E/AlxoAgQCCawNkv2aPfj/+5iOZbszG2YEJI8Xykn4UCae89x+dZ23q267m6PRAgQIAAAQLLCggsli29jhMIKZD7FXvm96zvJ4KkQCM9MWRbPPOzYMkpBRGf/33739tTRragwkyKekM9Nz57zrKYYWZSvUrZEwECBAgQIDCFwMxf/qcokE4QWEzARddiBR+wu7lZFr0+V8/ClJ5ByoAl1mQCBAgQIEAgikCvL1ZR+q8dBAjEEji7GLRIZKxardqayLMsoj9dZ9Uxo98ECBAgQIDATQGBxU04LyNAoImAC64mrHZaWeAsWOs5m2Hm9V8ql9DuCBAgQIAAgREEBBYjVEkbCawh4HaQNeo8Sy/PwoFes4EsvDnL6NIPAgQIECBA4F8CAgsDgQCBKAICiyiV0I4SgYhrWUSd+VHiaRsCBAgQIECAwB8CAguDggCBKAJuB4lSCe0oFYi25oqFN0srZzsCBAgQIEBgCAGBxRBl0kgCSwgcBRY91wRYAl4nbwuczQpKO/3PX4+fvX2Aiy/MLQj6dnsuNt/mBAgQIECAAIHfBQQWRgQBAhEE3A4SoQracEcg2iwLC2/eqaLXECBAgAABAiEFBBYhy6JRBJYTsFjgciWfpsPRZjVYx2KaoaUjBAgQIECAgMDCGCBAIIKA9SsiVEEb7gpEmmUhsLhbRa8jQIAAAQIEwgkILMKVRIMILCfgdpDlSj5lh6PcipGb8eFzf8rhp1MECBAgQGBOAV9c5qyrXhEYSeAssLBI4EiVXLutUWY25AIL59Ta41TvCRAgQIDAUAICi6HKpbEEphRwO8iUZV2uU7mg4M3P27Nz6r/+qUwKCf0RIECAAAECBMILvPkFKjyGBhIg8LqA20FeJ3fAhgJRZllEaUdDarsmQIAAAQIEVhAQWKxQZX0kEFdAYBG3Nlp2XSA3y+Kt2zHOAovUK5/912vrFQQIECBAgEAHAV9aOqA7JAEC/y3gdhCDYTaBsxDu//748SOFFq3/ztqQjv1WcNK6n/ZPgAABAgQITC4gsJi8wLpHILDA2a/Rb13YBebRtEEFIsyyiNCGQcun2QQIECBAgEAkAYFFpGpoC4G1BCL8Er2WuN6+JRDhVqez2UsCwbdGguMQIECAAAECjwQEFo/4vJjAY4H0S+jPf6Zo//1rTyut3u9JBo+Hjx0EFYgww0FgEXRwaBYBAgQIECBQLiCwKLeyJYHaAnu/wq7yyMEIF3S162l/BD4Fes8gsvCm8UiAAAECBAgMLyCwGL6EOjCwwN4voKtM1c4tCui9aeCBren/EugdyuXOMQtvGqgECBAgQIBAeAEXBeFLpIETCxxN2V7hQuLs199VZplMPLR17ZdAz3HeOzAxCAgQIECAAAECjwUEFo8J7YDAbYGji5nZZ1nkLqQEFreHlBcGE8iN9ZbhZO7Ys7/PBBsKmkOAAAECBAjcERBY3FHzGgL1BI5Ci5YXMvVaf29Puanq3pfuuXpVTIGesywsvBlzTGgVAQIECBAgUCjgwqAQymYEGgkcXczMPMtAYNFoMNltSIHcTIeWn8MW3gw5JDSKAAECBAgQKBVo+UWptA22I7CywNnFzKznp8eZrjzi1+z7WXDQcjZVLrBoeew1K63XBAgQIECAQFWBWS+IqiLZGYHGAivNssjNrph5ZknjYWT3gQXOgsmWa0nkzjeBReBBo2kECBAgQIDAjx8CC6OAQH+Bs4uK2c5Rv/j2H29a0EegxyyL3O0oAsI+Y8FRCRAgQIAAgUKB2S6GCrttMwLhBFZZfPPsdpBUFO9J4YamBlUSOAsmW82yyAUWrY5bicxuCBAgQIAAgdUFXBysPgL0P4rACo84zU1P92tvlNGoHa0EzgK7VrdneFJIq2raLwECBAgQINBcQGDRnNgBCBQJnP0S2upCpqhhFTfK3Q4isKiIbVchBc5Cu1bj36ymkENBowgQIECAAIESAYFFiZJtCLwjMPssi9yF0yzBzDujxVFGFOix+GYuKPQ9YMSRpM0ECBAgQGARAV9UFim0bg4hMPMjTnO3g7iXfoghqpEVBN5efDMXWAgKKxTVLggQIECAAIE2AgKLNq72SuCuwNEshNEvKnKzK1pNh79bB68j0Erg7VkWubBw9PeWVnWyXwIECBAgQCCAgMAiQBE0gcCHwIy3heSeVJC676LJabCSwJuLb+YCC2HhSiNPXwkQIECAwGACAovBCqa50wvMuPhm7oIpFdV70fRDWwc/BN6cZZELDAUWhiYBAgQIECAQVsBFQtjSaNjCArPNsnA7yMKDWdcPBd6aZZELLKwfY5ASIECAAAECYQUEFmFLo2ELC5wtkjfaOVsyu8LtIAsP9oW7fnZu1AwRBBYLDzJdJ0CAAAECowuMdvEzurf2EygReHO6eEl7nmyTm12R9u196Imw144s8MYsC4HFyCNE2wkQIECAwOICLhQWHwC6H1bg7UcftoAomV3h/vkW8vY5isBbsyzOgpGaszlGcddOAgQIECBAYBABgcUghdLM5QTOLmRGucg3u2K5YavDFwVysx9qneu5c9F3gYuFszkBAgQIECDwjoAvKe84OwqBqwK5C5no6z6YXXG14rZfVSB3rtT4nD6bsZXcaxxj1frpNwECBAgQINBQwJeUhrh2TeChwNlFRvRp3LlfdBNN9NDlYfm8nECxQOtzXWBRXAobEiBAgAABApEEBBaRqqEtBH4XGHWWRe4X49TLWlPdjRkCMwi0PtcFFjOMEn0gQIAAAQILCggsFiy6Lg8lMOKFRsnsCoHFUMNQY18QaDnLYsT3kRfIHYIAAQIECBCILiCwiF4h7VtdIDdbIdqFf669qZ7Rb2dZfczpfx+B3CyLJ+d6LrBwe1afmjsqAQIECBAgkBEQWBgiBOIL5GYsRLnYKAkrkvaTC6/41dJCAvcFcufQ3XM9F1j4LnC/Zl5JgAABAgQINBTwJaUhrl0TqCSQu9iIMmMhF6wIKyoNCLuZWqDFrSG595C7QcjUhdA5AgQIECBAoL+AwKJ/DbSAQIlALgzofcGR+2V466P3nJJq22ZlgdytIXcCylxg4bxcecTpOwECBAgQCCzgS0rg4mgagQ+B3AVH2rRXaFEaVrgVxJAmUCaQO6eunuu191fWC1sRIECAAAECBB4KCCweAno5gZcEcr+6pmbc+eW1RvNzsz+2Y3i/qaFtH6sI5ELKK6FFzX2t4q+fBAgQIECAQAABFxABiqAJBAoFchcdaTdXLmIKD3u6We6X2+3FZlfU0LaP1QTOwsArAWXuPPVdYLWRpb8ECBAgQGAQAV9SBimUZhL4ZwZFySyLBPXWeZ27CBJWGLYEngnkzrHS0CIXdr4ddD5T8WoCBAgQIEBgGYG3LmyWAdVRAo0Fchce6fClFzFPm+pWkKeCXk8gL5ALLUrChtz7hu8C+TrYggABAgQIEOgg4EtKB3SHJPBAIMosi9xF1NZFt4I8KLaXEvglkAsccqHF09crBAECBAgQIECgi4DAogu7gxJ4JFASFrScZVFy/NRBYcWjMnsxgd8EcutZpPMtnfd7f7nAwncBg40AAQIECBAIKeBLSsiyaBSBU4GesyxKj5064P3FQCZQT6AkKDyaaZG7fcu5Wq9O9kSAAAECBAhUFPAlpSKmXRF4UaDk4qXFLIvcL7UbgdkVLw4Gh1pGoOS83zv3cuet7wLLDCEdJUCAAAECYwn4kjJWvbSWwKdA7lfTtG3u3vYroiUXS2l/woorqrYlcE0gFz58hoYptEz/5G4nSe8T/ggQIECAAAEC4QQEFuFKokEEigVKAoRasyxKjrU13PtKcQltSOCWwJXzseQAztkSJdsQIECAAAECrwv4kvI6uQMSqCrwxiyLKxdH3lOqltfOCBwKlM60yBHWCjVzx/HfCRAgQIAAAQKXBVxcXCbzAgKhBErDhLu3hpTuP6G4FSTU0NCYBQSunJ9HHM7bBQaKLhIgQIAAgVEFBBajVk67CfyPQMksizuBwpWLIRc9RiSBPgJXztO9Fvoe0KdujkqAAAECBAgUCPiiUoBkEwLBBa48anQLLrbF+L67lvaV/vl5sc/eSy6C2ZxAZYE7wYWgsXIR7I4AAQIECBCoK+Aio66nvRHoJfDkfvYUXqSQ4s5fem266En/9keAQH+BFFykv7PQ0Xnbv05aQIAAAQIECBQICCwKkGxCYACBq7MsanXp7toYtY5vPwQI7AtsIWT691+/Nvn7V7goYDRqCBAgQIAAgSEEBBZDlEkjCRQJvB1aCCuKymIjAgQIECBAgAABAgTuCAgs7qh5DYG4AnfuY7/TG/e+31HzGgIECBAgQIAAAQIEigUEFsVUNiQwjEDL0MK978MMAw0lQIAAAQIECBAgMLaAwGLs+mk9gTOB2sGFWRXGGwECBAgQIECAAAECrwkILF6jdiACXQTuPqb0s7FmVXQpnYMSIECAAAECBAgQWFtAYLF2/fV+LYGSxx1uIimkSE8U2F6zlpTeEiBAgAABAgQIECDQXUBg0b0EGkCgm8DnYw8/H3PokYfdSuLABAgQIECAAAECBAhsAgILY4EAAQIECBAgQIAAAQIECBAIJyCwCFcSDSJAgAABAgQIECBAgAABAgQEFsYAAQIECBAgQIAAAQIECBAgEE5AYBGuJBpEgAABAgQIECBAgAABAgQICCyMAQIECBAgQIAAAQIECBAgQCCcgMAiXEk0iAABAgQIECBAgAABAgQIEBBYGAMECBAgQIAAAQIECBAgQIBAOAGBRbiSaBABAgQIECBAgAABAgQIECAgsDAGCBAgQIAAAQIECBAgQIAAgXACAotwJdEgAgQIECBAgAABAgQIECBAQGBhDBAgQIAAAQIECBAgQIAAAQLhBAQW4UqiQQQIECBAgAABAgQIECBAgIDAwhggQIAAAQIECBAgQIAAAQIEwgkILMKVRIMIECBAgAABAgQIECBAgAABgYUxQIAAAQIECBAgQIAAAQIECIQTEFiEK4kGESBAgAABAgQIECBAgAABAgILY4AAAQIECBAgQIAAAQIECBAIJyCwCFcSDSJAgAABAgQIECBAgAABAgQEFsYAAQIECBAgQIAAAQIECBAgEE5AYBGuJBpEgAABAgQIECBAgAABAgQICCyMAQIECBAgQIAAAQIECBAgQCCcgMAiXEk0iAABAgQIECBAgAABAgQIEBBYGAMECBAgQIAAAQIECBAgQIBAOAGBRbiSaBABAgQIECBAgAABAgQIECAgsDAGCBAgQIAAAQIECBAgQIAAgXACAotwJdEgAgQIECBAgAABAgQIECBAQGBhDBAgQIAAAQIECBAgQIAAAQLhBAQW4UqiQQQIECBAgAABAgQIECBAgIDAwhggQIAAAQIECBAgQIAAAQIEwgkILMKVRIMIECBAgAABAgQIECBAgAABgYUxQIAAAQIECBAgQIAAAQIECIQTEFiEK4kGESBAgAABAgQIECBAgAABAgILY4AAAQIECBAgQIAAAQIECBAIJyCwCFcSDSJAgAABAgQIECBAgAABAgQEFsYAAQIECBAgQIAAAQIECBAgEE5AYBGuJBpEgAABAgQIECBAgAABAgQICCyMAQIECBAgQIAAAQIECBAgQCCcgMAiXEk0iAABAgQIECBAgAABAgQIEBBYGAMECBAgQIAAAQIECBAgQIBAOAGBRbiSaBABAgQIECBAgAABAgQIECAgsDAGCBAgQIAAAQIECBAgQIAAgXACAotwJdEgAgQIECBAgAABAgQIECBAQGBhDBAgQIAAAQIECBAgQIAAAQLhBAQW4UqiQQQIECBAgAABAgQIECBAgIDAwhggQIAAAQIECBAgQIAAAQIEwgkILMKVRIMIECBAgAABAgQIECBAgAABgYUxQIAAAQIECBAgQIAAAQIECIQTEFiEK4kGESBAgAABAgQIECBAgAABAgILY4AAAQIECBAgQIAAAQIECBAIJyCwCFcSDSJAgAABAgQIECBAgAABAgQEFsYAAQIECBAgQIAAAQIECBAgEE5AYBGuJBpEgAABAgQIECBAgAABAgQICCyMAQIECBAgQIAAAQIECBAgQCCcgMAiXEk0iAABAgQIECBAgAABAgQIEBBYGAMECBAgQIAAAQIECBAgQIBAOAGBRbiSaBABAgQIECBAgAABAgQIECAgsDAGCBAgQIAAAQIECBAgQIAAgXACAotwJdEgAgQIECBAgAABAgQIECBAQGBhDBAgQIAAAQIECBAgQIAAAQLhBAQW4UqiQQQIECBAgAABAgQIECBAgIDAwhggQIAAAQIECBAgQIAAAQIEwgkILMKVRIMIECBAgAABAgQIECBAgAABgYUxQIAAAQIECBAgQIAAAQIECIQTEFiEK4kGESBAgAABAgQIECBAgAABAgILY4AAAQIECBAgQIAAAQIECBAIJyCwCFcSDSJAgAABAgQIECBAgAABAgQEFsYAAQIECBAgQIAAAQIECBAgEE5AYBGuJBpEgAABAgQIECBAgAABAgQICCyMAQIECBAgQIAAAQIECBAgQCCcgMAiXEk0iAABAgQIECBAgAABAgQIEBBYGAMECBAgQIAAAQIECBAgQIBAOAGBRbiSaBABAgQIECBAgAABAgQIECAgsDAGCBAgQIAAAQIECBAgQIAAgXACAotwJdEgAgQIECBAgAABAgQIECBAQGBhDBAgQIXVqaAAAAbSSURBVIAAAQIECBAgQIAAAQLhBAQW4UqiQQQIECBAgAABAgQIECBAgIDAwhggQIAAAQIECBAgQIAAAQIEwgkILMKVRIMIECBAgAABAgQIECBAgAABgYUxQIAAAQIECBAgQIAAAQIECIQTEFiEK4kGESBAgAABAgQIECBAgAABAgILY4AAAQIECBAgQIAAAQIECBAIJyCwCFcSDSJAgAABAgQIECBAgAABAgQEFsYAAQIECBAgQIAAAQIECBAgEE5AYBGuJBpEgAABAgQIECBAgAABAgQICCyMAQIECBAgQIAAAQIECBAgQCCcgMAiXEk0iAABAgQIECBAgAABAgQIEBBYGAMECBAgQIAAAQIECBAgQIBAOAGBRbiSaBABAgQIECBAgAABAgQIECAgsDAGCBAgQIAAAQIECBAgQIAAgXACAotwJdEgAgQIECBAgAABAgQIECBAQGBhDBAgQIAAAQIECBAgQIAAAQLhBAQW4UqiQQQIECBAgAABAgQIECBAgIDAwhggQIAAAQIECBAgQIAAAQIEwgkILMKVRIMIECBAgAABAgQIECBAgAABgYUxQIAAAQIECBAgQIAAAQIECIQTEFiEK4kGESBAgAABAgQIECBAgAABAgILY4AAAQIECBAgQIAAAQIECBAIJyCwCFcSDSJAgAABAgQIECBAgAABAgQEFsYAAQIECBAgQIAAAQIECBAgEE5AYBGuJBpEgAABAgQIECBAgAABAgQICCyMAQIECBAgQIAAAQIECBAgQCCcgMAiXEk0iAABAgQIECBAgAABAgQIEBBYGAMECBAgQIAAAQIECBAgQIBAOAGBRbiSaBABAgQIECBAgAABAgQIECAgsDAGCBAgQIAAAQIECBAgQIAAgXACAotwJdEgAgQIECBAgAABAgQIECBAQGBhDBAgQIAAAQIECBAgQIAAAQLhBAQW4UqiQQQIECBAgAABAgQIECBAgIDAwhggQIAAAQIECBAgQIAAAQIEwgkILMKVRIMIECBAgAABAgQIECBAgAABgYUxQIAAAQIECBAgQIAAAQIECIQTEFiEK4kGESBAgAABAgQIECBAgAABAgILY4AAAQIECBAgQIAAAQIECBAIJyCwCFcSDSJAgAABAgQIECBAgAABAgQEFsYAAQIECBAgQIAAAQIECBAgEE5AYBGuJBpEgAABAgQIECBAgAABAgQICCyMAQIECBAgQIAAAQIECBAgQCCcgMAiXEk0iAABAgQIECBAgAABAgQIEBBYGAMECBAgQIAAAQIECBAgQIBAOAGBRbiSaBABAgQIECBAgAABAgQIECAgsDAGCBAgQIAAAQIECBAgQIAAgXACAotwJdEgAgQIECBAgAABAgQIECBAQGBhDBAgQIAAAQIECBAgQIAAAQLhBAQW4UqiQQQIECBAgAABAgQIECBAgIDAwhggQIAAAQIECBAgQIAAAQIEwgkILMKVRIMIECBAgAABAgQIECBAgAABgYUxQIAAAQIECBAgQIAAAQIECIQTEFiEK4kGESBAgAABAgQIECBAgAABAgILY4AAAQIECBAgQIAAAQIECBAIJyCwCFcSDSJAgAABAgQIECBAgAABAgQEFsYAAQIECBAgQIAAAQIECBAgEE5AYBGuJBpEgAABAgQIECBAgAABAgQICCyMAQIECBAgQIAAAQIECBAgQCCcgMAiXEk0iAABAgQIECBAgAABAgQIEBBYGAMECBAgQIAAAQIECBAgQIBAOAGBRbiSaBABAgQIECBAgAABAgQIECAgsDAGCBAgQIAAAQIECBAgQIAAgXACAotwJdEgAgQIECBAgAABAgQIECBAQGBhDBAgQIAAAQIECBAgQIAAAQLhBAQW4UqiQQQIECBAgAABAgQIECBAgIDAwhggQIAAAQIECBAgQIAAAQIEwgkILMKVRIMIECBAgAABAgQIECBAgAABgYUxQIAAAQIECBAgQIAAAQIECIQTEFiEK4kGESBAgAABAgQIECBAgAABAgILY4AAAQIECBAgQIAAAQIECBAIJyCwCFcSDSJAgAABAgQIECBAgAABAgQEFsYAAQIECBAgQIAAAQIECBAgEE5AYBGuJBpEgAABAgQIECBAgAABAgQICCyMAQIECBAgQIAAAQIECBAgQCCcgMAiXEk0iAABAgQIECBAgAABAgQIEBBYGAMECBAgQIAAAQIECBAgQIBAOAGBRbiSaBABAgQIECBAgAABAgQIECAgsDAGCBAgQIAAAQIECBAgQIAAgXACAotwJdEgAgQIECBAgAABAgQIECBAQGBhDBAgQIAAAQIECBAgQIAAAQLhBP4/csBUQgAdQDwAAAAASUVORK5CYII=", - "termsOfCarriage": "All shipments are subject to the Hague-Visby Rules. The carrier assumes liability only for loss or damage due to its own negligence. Responsibility ceases at the time goods are delivered to the consignee or their agent. Claims must be submitted within 7 working days of delivery.", - "attachments": [ - { - "data": "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", - "filename": "blank.pdf", - "mimeType": "application/pdf" - }, - { - "data": "e30=", - "filename": "empty.json", - "mimeType": "application/json" - }, - { - "data": "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", - "filename": "sample.pdf", - "mimeType": "application/pdf" - }, - { - "data": "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", - "filename": "veryverylongfilenameoverhereveryverylongfilenameoverhere.pdf", - "mimeType": "application/pdf" - } - ] - }, - "type": ["VerifiableCredential"], - "qrCode": { - "type": "TrustVCQRCode", - "uri": "https://actions.tradetrust.io?q=%7B%22type%22%3A%22DOCUMENT%22%2C%22payload%22%3A%7B%22uri%22%3A%22https%3A%2F%2Fgallery.tradetrust.io%2Fstatic%2Fbill-of-lading-inoperative.json%22%2C%22redirect%22%3A%22https%3A%2F%2Fref.tradetrust.io%2F%22%2C%22chainId%22%3A%22101010%22%7D%7D" - }, - "credentialStatus": { - "type": "TransferableRecords", - "tokenNetwork": { - "chain": "ETH", - "chainId": 11155111 - }, - "tokenRegistry": "0x3A5f212f1D1bf90a8a0B7530698e25620DEb166B", - "tokenId": "d4418cbf05cc36ec2b446cfc7d6d4fd5c96fb247c3d89e3010113c4e4165c4e6" - }, - "issuer": "did:web:trustvc.github.io:did:1", - "issuanceDate": "2025-06-05T11:29:32.860Z", - "id": "urn:bnid:_:0198cc4e-c9bb-7eec-8c1d-2d16e12b4f20", - "proof": { - "type": "BbsBlsSignature2020", - "created": "2025-08-21T11:06:12Z", - "proofPurpose": "assertionMethod", - "proofValue": "kVNo63FXss6j7tbcLQQ1z07ldT1jVxATfcHJnOPTUgR5yGbpuXYF8lxCttGRqLmOYdU8j/3m9v0dN3yh95/KDC7t0RTVCfQLApwDr16tio0ATDDQ2Ism8JNtdgbTAtFT+PDwn/emFCmMPxZ2mjo4Uw==", - "verificationMethod": "did:web:trustvc.github.io:did:1#keys-1" - } -} diff --git a/tests/commands/token-registry/mint.test.ts b/tests/commands/token-registry/mint.test.ts index 5a52371..639f3dd 100644 --- a/tests/commands/token-registry/mint.test.ts +++ b/tests/commands/token-registry/mint.test.ts @@ -133,7 +133,6 @@ describe('token-registry/mint', () => { expect((result as any).encryptedWalletPath).toBe('./wallet.json'); expect(result.remark).toBe(mockInputs.remark); expect(result.encryptionKey).toBe(mockInputs.documentId); - expect(result.dryRun).toBe(false); expect(result.maxPriorityFeePerGasScale).toBe(1); }); @@ -458,7 +457,6 @@ describe('token-registry/mint', () => { beneficiary: '0x0987654321098765432109876543210987654321', holder: '0x1111111111111111111111111111111111111111', encryptedWalletPath: './wallet.json', - dryRun: false, maxPriorityFeePerGasScale: 1, }; @@ -511,7 +509,6 @@ describe('token-registry/mint', () => { remark: 'Important document', encryptionKey: 'secret-key-123', key: '0xprivatekey', - dryRun: false, maxPriorityFeePerGasScale: 1, }; @@ -565,7 +562,6 @@ describe('token-registry/mint', () => { beneficiary: '0x0987654321098765432109876543210987654321', holder: '0x1111111111111111111111111111111111111111', encryptedWalletPath: './wallet.json', - dryRun: false, maxPriorityFeePerGasScale: 1, }; @@ -586,7 +582,6 @@ describe('token-registry/mint', () => { beneficiary: '0x0987654321098765432109876543210987654321', holder: '0x1111111111111111111111111111111111111111', encryptedWalletPath: './wallet.json', - dryRun: false, maxPriorityFeePerGasScale: 1, }; @@ -605,7 +600,6 @@ describe('token-registry/mint', () => { beneficiary: '0x0987654321098765432109876543210987654321', holder: '0x1111111111111111111111111111111111111111', encryptedWalletPath: './wallet.json', - dryRun: false, maxPriorityFeePerGasScale: 1, }; @@ -657,7 +651,6 @@ describe('token-registry/mint', () => { holder: '0x1111111111111111111111111111111111111111', encryptedWalletPath: './wallet.json', documentId: 'urn:uuid:019b9ce6-5048-7669-b1bf-e15d1f085692', - dryRun: false, maxPriorityFeePerGasScale: 1, };