filecoin-pin
Version:
Bridge IPFS content to Filecoin Onchain Cloud using familiar tools
183 lines • 6.72 kB
JavaScript
import { EventEmitter } from 'node:events';
/**
* Test utilities for mocking Synapse SDK components
*
* This file provides realistic mock implementations for testing Synapse integrations.
* It simulates the key SDK behaviors including:
* - Provider discovery and selection
* - Data set creation and management
* - Upload lifecycle with proper callback ordering
* - Network identification
*/
// Mock provider info matching real PDP provider structure
export const mockProviderInfo = {
id: 1,
serviceProvider: '0x78bF4d833fC2ba1Abd42Bc772edbC788EC76A28F', // Provider's contract address
payee: '0x78bF4d833fC2ba1Abd42Bc772edbC788EC76A28F', // Payment recipient
name: 'Mock Provider',
description: 'Mock provider for testing',
active: true, // Provider is accepting new data
products: {
PDP: {
// Proof of Data Possession service
type: 'PDP',
isActive: true,
capabilities: {},
data: {
// PDP-specific configuration
serviceURL: 'http://localhost:8888/pdp', // Where to upload data
minPieceSizeInBytes: 127n, // Minimum piece size (127 bytes)
maxPieceSizeInBytes: 34359738368n, // Maximum piece size (32 GiB)
ipniPiece: false, // IPNI indexing capabilities
ipniHttp: false,
ipniBitswap: false,
storagePricePerTibPerMonth: 5000000000000000000n, // Price in attoFIL
location: 'Test Location',
bandwidth: 1000, // Mbps
throughput: 100, // MB/s
storageCapacity: 1000n, // TiB total capacity
storageAvailable: 800n, // TiB available
},
},
},
};
/**
* Mock storage context that simulates SDK's storage operations
*
* In production, StorageContext manages:
* - Communication with PDP servers
* - On-chain data set operations
* - Upload lifecycle and retries
* - Provider health monitoring
*/
export class MockStorageContext extends EventEmitter {
dataSetId = 123; // Simulated on-chain data set ID
serviceProvider = mockProviderInfo.serviceProvider;
async upload(_data, options) {
// Extract callbacks from options (handle both old and new API)
const callbacks = options?.onUploadComplete ? options : options?.callbacks || options;
// Simulate network delay for realistic testing
await new Promise((resolve) => setTimeout(resolve, 100));
// Generate mock CommP (piece commitment) with correct prefix
// Real CommP: bafkzcib... (raw multibase + CID with CommP codec)
const pieceCid = `bafkzcib${Math.random().toString(36).substring(2, 15)}`;
const pieceId = Math.floor(Math.random() * 1000); // Piece index in data set
// Simulate callback sequence matching real SDK behavior
if (callbacks?.onUploadComplete != null) {
// First: data uploaded to PDP server
callbacks.onUploadComplete(pieceCid);
}
if (callbacks?.onPieceAdded != null) {
// Second: piece registered (may require transaction)
callbacks.onPieceAdded();
}
return { pieceCid, pieceId, size: 1024 };
}
}
/**
* Mock Synapse instance simulating the main SDK class
*
* Real Synapse manages:
* - Wallet and transaction signing
* - Network configuration and RPC communication
* - Contract interactions
* - Storage context factory
*/
export class MockSynapse extends EventEmitter {
_storageContext = null;
// Storage namespace matches SDK structure
storage = {
createContext: this.createStorageContext.bind(this),
upload: (data, options) => this._storageContext?.upload(data, options),
};
/**
* Mock network identification
* Real networks: 314 (mainnet), 314159 (calibration testnet)
*/
getNetwork() {
return { chainId: 314159n, name: 'calibration' };
}
/**
* Mock provider getter - returns a mock provider with destroy method
*/
getProvider() {
return {
destroy: async () => {
// Mock provider cleanup
},
};
}
/**
* Mock signer getter
*/
getSigner() {
return {
getAddress: async () => '0x1234567890123456789012345678901234567890',
};
}
/**
* Mock client getter (returns owner wallet)
*/
getClient() {
return {
getAddress: async () => '0x1234567890123456789012345678901234567890',
};
}
/**
* Mock session key creation
*/
createSessionKey(_sessionWallet) {
const now = Math.floor(Date.now() / 1000);
const oneYear = 365 * 24 * 60 * 60; // One year from now
return {
/**
* Fetch expiries for various permission types
* Returns a map of typehash -> expiry timestamp
*
* By default, mock both CREATE_DATA_SET and ADD_PIECES with valid future expiries
* Tests can override this to simulate different scenarios:
* - CREATE_DATA_SET = 0: No permission to create datasets
* - CREATE_DATA_SET < now + 30min: Expired/expiring soon
*/
fetchExpiries: async (typehashes) => {
const expiries = {};
for (const typehash of typehashes) {
// By default, all permissions valid for one year
expiries[typehash] = BigInt(now + oneYear);
}
return expiries;
},
};
}
/**
* Mock session key setter
*/
setSession(_sessionKey) {
// No-op in mock
}
/**
* Create a storage context with lifecycle callbacks
*
* Real process:
* 1. Query on-chain registry for active providers
* 2. Select best provider based on criteria
* 3. Check for existing data set or create new one
* 4. Initialize upload session
*/
async createStorageContext(options) {
// Simulate provider discovery and selection
if (options?.callbacks?.onProviderSelected != null) {
options.callbacks.onProviderSelected(mockProviderInfo);
}
// Simulate data set creation or reuse
if (options?.callbacks?.onDataSetResolved != null) {
options.callbacks.onDataSetResolved({
dataSetId: 123,
isExisting: false, // false = new data set created
});
}
this._storageContext = new MockStorageContext();
return this._storageContext;
}
}
//# sourceMappingURL=synapse-mocks.js.map