@openzeppelin/contracts-ui-builder-adapter-solana
Version:
Solana Adapter for Contracts UI Builder
430 lines (410 loc) • 13.8 kB
JavaScript
var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
// src/adapter.ts
import { isSolanaNetworkConfig } from "@openzeppelin/contracts-ui-builder-types";
import { logger as logger12 } from "@openzeppelin/contracts-ui-builder-utils";
// src/configuration/execution.ts
async function getSolanaSupportedExecutionMethods() {
return [{ type: "eoa", name: "EOA", description: "Placeholder" }];
}
async function validateSolanaExecutionConfig(_config) {
return true;
}
// src/configuration/explorer.ts
import { logger } from "@openzeppelin/contracts-ui-builder-utils";
function getSolanaExplorerAddressUrl(address, networkConfig) {
if (!networkConfig.explorerUrl) {
return null;
}
const baseUrl = networkConfig.explorerUrl.replace(/\/+$/, "");
return `${baseUrl}/address/${address}`;
}
function getSolanaExplorerTxUrl(txHash, networkConfig) {
if (!networkConfig.explorerUrl) {
return null;
}
const baseUrl = networkConfig.explorerUrl.replace(/\/+$/, "");
return `${baseUrl}/tx/${txHash}`;
}
// src/configuration/rpc.ts
import { logger as logger2 } from "@openzeppelin/contracts-ui-builder-utils";
function validateSolanaRpcEndpoint(_rpcConfig) {
logger2.info("validateSolanaRpcEndpoint", "Solana RPC validation not yet implemented");
return true;
}
async function testSolanaRpcConnection(_rpcConfig) {
logger2.info("testSolanaRpcConnection", "TODO: Implement RPC connection testing");
return { success: true };
}
// src/mapping/constants.ts
var SOLANA_TYPE_TO_FIELD_TYPE = {
string: "text",
u64: "number",
publicKey: "blockchain-address"
// Add more Solana types
};
// src/mapping/type-mapper.ts
import { logger as logger3 } from "@openzeppelin/contracts-ui-builder-utils";
function mapSolanaParamTypeToFieldType(parameterType) {
logger3.warn("adapter-solana", "mapSolanaParamTypeToFieldType not implemented");
return SOLANA_TYPE_TO_FIELD_TYPE[parameterType] || "text";
}
function getSolanaCompatibleFieldTypes(parameterType) {
logger3.warn("adapter-solana", "getSolanaCompatibleFieldTypes not implemented");
if (parameterType === "publicKey") return ["blockchain-address", "text"];
if (parameterType.startsWith("u") || parameterType.startsWith("i")) return ["number", "text"];
return ["text", "textarea"];
}
// src/mapping/field-generator.ts
import { startCase } from "lodash";
import { getDefaultValueForType, logger as logger4 } from "@openzeppelin/contracts-ui-builder-utils";
function getDefaultValidationForType(_parameterType) {
return { required: true };
}
function generateSolanaDefaultField(parameter) {
logger4.warn("adapter-solana", "generateSolanaDefaultField not implemented");
const fieldType = mapSolanaParamTypeToFieldType(parameter.type);
return {
id: `field-${Math.random().toString(36).substring(2, 9)}`,
name: parameter.name || parameter.type,
label: startCase(parameter.displayName || parameter.name || parameter.type),
type: fieldType,
placeholder: `Enter ${parameter.displayName || parameter.name || parameter.type}`,
defaultValue: getDefaultValueForType(fieldType),
validation: getDefaultValidationForType(parameter.type),
width: "full"
};
}
// src/query/view-checker.ts
import { logger as logger5 } from "@openzeppelin/contracts-ui-builder-utils";
function isSolanaViewFunction(_functionDetails) {
logger5.warn("adapter-solana", "isSolanaViewFunction not implemented");
return false;
}
// src/query/handler.ts
import { logger as logger6 } from "@openzeppelin/contracts-ui-builder-utils";
async function querySolanaViewFunction(_contractAddress, _functionId, networkConfig, _params, _contractSchema, _walletImplementation, _loadContractFn) {
if (networkConfig.ecosystem !== "solana") {
throw new Error("Invalid network configuration for Solana query.");
}
const solanaConfig = networkConfig;
logger6.warn(
"querySolanaViewFunction",
`Not fully implemented for network: ${solanaConfig.name} (RPC: ${solanaConfig.rpcEndpoint})`
);
return void 0;
}
// src/transaction/formatter.ts
import { logger as logger7 } from "@openzeppelin/contracts-ui-builder-utils";
function formatSolanaTransactionData(_contractSchema, _functionId, _submittedInputs, _fields) {
logger7.warn("adapter-solana", "formatSolanaTransactionData not implemented");
return {};
}
// src/transaction/sender.ts
import { logger as logger8 } from "@openzeppelin/contracts-ui-builder-utils";
var SYSTEM_LOG_TAG = "adapter-solana";
async function signAndBroadcastSolanaTransaction(_transactionData, executionConfig) {
logger8.warn(SYSTEM_LOG_TAG, "signAndBroadcastSolanaTransaction not implemented");
logger8.info(
SYSTEM_LOG_TAG,
"Solana signAndBroadcast called with executionConfig:",
executionConfig
);
return { txHash: "solana_placeholder_tx" };
}
async function waitForSolanaTransactionConfirmation(_txHash) {
logger8.warn("adapter-solana", "waitForSolanaTransactionConfirmation not implemented");
return { status: "success" };
}
// src/transform/input-parser.ts
import { logger as logger9 } from "@openzeppelin/contracts-ui-builder-utils";
// src/transform/output-formatter.ts
import { logger as logger10 } from "@openzeppelin/contracts-ui-builder-utils";
function formatSolanaFunctionResult(decodedValue, _functionDetails) {
logger10.warn("adapter-solana", "formatSolanaFunctionResult not implemented");
if (decodedValue === null || decodedValue === void 0) return "(null)";
return String(decodedValue);
}
// src/utils/validation.ts
import { logger as logger11 } from "@openzeppelin/contracts-ui-builder-utils";
function isValidSolanaAddress(address) {
logger11.warn("adapter-solana", "isValidSolanaAddress not implemented robustly");
return /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(address);
}
// src/wallet/connection.ts
function solanaSupportsWalletConnection() {
return false;
}
async function getSolanaAvailableConnectors() {
return [];
}
async function connectSolanaWallet(_connectorId) {
return { connected: false, error: "Not implemented" };
}
async function disconnectSolanaWallet() {
return { disconnected: true };
}
function getSolanaWalletConnectionStatus() {
return { isConnected: false };
}
function onSolanaWalletConnectionChange(_callback) {
return () => {
};
}
// src/adapter.ts
var SolanaAdapter = class {
// private walletImplementation: SolanaWalletImplementation; // Example
constructor(networkConfig) {
__publicField(this, "networkConfig");
__publicField(this, "initialAppServiceKitName");
if (!isSolanaNetworkConfig(networkConfig)) {
throw new Error("SolanaAdapter requires a valid Solana network configuration.");
}
this.networkConfig = networkConfig;
this.initialAppServiceKitName = "custom";
logger12.info(
"SolanaAdapter",
`Adapter initialized for network: ${networkConfig.name} (ID: ${networkConfig.id})`
);
}
async loadContract(artifacts) {
if (typeof artifacts.contractAddress !== "string") {
throw new Error("A program ID must be provided.");
}
return {
name: "SolanaProgram",
address: artifacts.contractAddress,
ecosystem: "solana",
functions: [],
events: []
};
}
getWritableFunctions(contractSchema) {
return contractSchema.functions.filter((fn) => fn.modifiesState);
}
mapParameterTypeToFieldType(parameterType) {
return mapSolanaParamTypeToFieldType(parameterType);
}
getCompatibleFieldTypes(parameterType) {
return getSolanaCompatibleFieldTypes(parameterType);
}
generateDefaultField(parameter) {
return generateSolanaDefaultField(parameter);
}
formatTransactionData(contractSchema, functionId, submittedInputs, fields) {
return formatSolanaTransactionData(contractSchema, functionId, submittedInputs, fields);
}
async signAndBroadcast(transactionData, executionConfig) {
return signAndBroadcastSolanaTransaction(transactionData, executionConfig);
}
isValidAddress(address) {
return isValidSolanaAddress(address);
}
async getSupportedExecutionMethods() {
return getSolanaSupportedExecutionMethods();
}
async validateExecutionConfig(config) {
return validateSolanaExecutionConfig(config);
}
isViewFunction(functionDetails) {
return isSolanaViewFunction(functionDetails);
}
async queryViewFunction(contractAddress, functionId, params = [], contractSchema) {
return querySolanaViewFunction(
contractAddress,
functionId,
this.networkConfig,
params,
contractSchema,
null,
// walletContext is not needed for view functions
(source) => this.loadContract({ contractAddress: source })
);
}
formatFunctionResult(decodedValue, functionDetails) {
return formatSolanaFunctionResult(decodedValue, functionDetails);
}
supportsWalletConnection() {
return solanaSupportsWalletConnection();
}
async getAvailableConnectors() {
return getSolanaAvailableConnectors(
/* this.walletImplementation */
);
}
async connectWallet(connectorId) {
return connectSolanaWallet(
connectorId
/*, undefined */
);
}
async disconnectWallet() {
return disconnectSolanaWallet(
/* undefined */
);
}
getWalletConnectionStatus() {
return getSolanaWalletConnectionStatus(
/* undefined */
);
}
onWalletConnectionChange(callback) {
if (onSolanaWalletConnectionChange) {
return onSolanaWalletConnectionChange(
/* this.walletImplementation, */
callback
);
}
return () => {
};
}
getExplorerUrl(address) {
return getSolanaExplorerAddressUrl(address, this.networkConfig);
}
getExplorerTxUrl(txHash) {
if (getSolanaExplorerTxUrl) {
return getSolanaExplorerTxUrl(txHash, this.networkConfig);
}
return null;
}
async waitForTransactionConfirmation(txHash) {
if (waitForSolanaTransactionConfirmation) {
return waitForSolanaTransactionConfirmation(
txHash
/*, this.walletImplementation */
);
}
return { status: "success" };
}
async getAvailableUiKits() {
return [
{
id: "custom",
name: "OpenZeppelin Custom",
configFields: []
}
];
}
getContractDefinitionInputs() {
return [
{
id: "contractAddress",
name: "contractAddress",
label: "Program ID",
type: "blockchain-address",
validation: { required: true },
placeholder: "Enter Solana program ID"
}
];
}
async getRelayers(_serviceUrl, _accessToken) {
logger12.warn("SolanaAdapter", "getRelayers is not implemented for the Solana adapter yet.");
return Promise.resolve([]);
}
async getRelayer(_serviceUrl, _accessToken, _relayerId) {
logger12.warn("SolanaAdapter", "getRelayer is not implemented for the Solana adapter yet.");
return Promise.resolve({});
}
/**
* @inheritdoc
*/
async validateRpcEndpoint(rpcConfig) {
return validateSolanaRpcEndpoint(rpcConfig);
}
/**
* @inheritdoc
*/
async testRpcConnection(rpcConfig) {
return testSolanaRpcConnection(rpcConfig);
}
};
// src/networks/mainnet.ts
var solanaMainnetBeta = {
id: "solana-mainnet-beta",
exportConstName: "solanaMainnetBeta",
name: "Solana",
ecosystem: "solana",
network: "solana",
type: "mainnet",
isTestnet: false,
rpcEndpoint: "https://api.mainnet-beta.solana.com",
commitment: "confirmed",
explorerUrl: "https://explorer.solana.com",
icon: "solana"
};
// src/networks/testnet.ts
var solanaDevnet = {
id: "solana-devnet",
exportConstName: "solanaDevnet",
name: "Solana Devnet",
ecosystem: "solana",
network: "solana",
type: "devnet",
// Solana uses 'devnet' commonly
isTestnet: true,
rpcEndpoint: "https://api.devnet.solana.com",
commitment: "confirmed",
explorerUrl: "https://explorer.solana.com/?cluster=devnet",
icon: "solana"
};
var solanaTestnet = {
id: "solana-testnet",
exportConstName: "solanaTestnet",
name: "Solana Testnet",
ecosystem: "solana",
network: "solana",
type: "testnet",
isTestnet: true,
rpcEndpoint: "https://api.testnet.solana.com",
commitment: "confirmed",
explorerUrl: "https://explorer.solana.com/?cluster=testnet",
icon: "solana"
};
// src/networks/index.ts
var solanaMainnetNetworks = [solanaMainnetBeta];
var solanaTestnetNetworks = [solanaDevnet, solanaTestnet];
var solanaNetworks = [
...solanaMainnetNetworks,
...solanaTestnetNetworks
];
// src/config.ts
var solanaAdapterConfig = {
/**
* Dependencies required by the Solana adapter
* These will be included in exported projects that use this adapter
*/
dependencies: {
// TODO: Review and update with real, verified dependencies and versions before production release
// Runtime dependencies
runtime: {
// Core Solana libraries
"@solana/web3.js": "^1.78.5",
"@solana/spl-token": "^0.3.8",
// Wallet adapters
"@solana/wallet-adapter-react": "^0.15.35",
"@solana/wallet-adapter-base": "^0.9.23",
// Utilities for working with Solana
bs58: "^5.0.0",
"@project-serum/anchor": "^0.26.0"
},
// Development dependencies
dev: {
// Testing utilities for Solana
"@solana/spl-token-registry": "^0.2.4574",
// CLI tools for development
"@solana/cli": "^1.1.0"
}
}
};
export {
SolanaAdapter,
solanaAdapterConfig,
solanaDevnet,
solanaMainnetBeta,
solanaMainnetNetworks,
solanaNetworks,
solanaTestnet,
solanaTestnetNetworks
};
//# sourceMappingURL=index.js.map