-
-
-
- Where is oSnap?
-- oSnap is currently disabled because your space's voting settings - disallow the basic voting type which is a requirement for oSnap to - work properly. -
-- Have your admin visit your - settings page under Voting -> - Type, and make sure either "Any" or "Basic Voting" is selected. This - will allow you to create oSnap proposals. -
-
-
- - -
- oSnap Proposal
-- Are you planning for this proposal to initiate a transaction that your - organizations Safe will execute if approved? (Remember, oSnap enables - trustless and permissionless execution) -
-- - -
-
-
+
+
diff --git a/src/plugins/oSnap/components/HandleOutcome/HandleOutcome.vue b/src/plugins/oSnap/components/HandleOutcome/HandleOutcome.vue
new file mode 100644
index 00000000000..eab799b7bce
--- /dev/null
+++ b/src/plugins/oSnap/components/HandleOutcome/HandleOutcome.vue
@@ -0,0 +1,402 @@
+
+
+
+
+ {{ label }}
+
+
diff --git a/src/plugins/oSnap/components/Input/Amount.vue b/src/plugins/oSnap/components/Input/Amount.vue
new file mode 100644
index 00000000000..0a841a5c1a6
--- /dev/null
+++ b/src/plugins/oSnap/components/Input/Amount.vue
@@ -0,0 +1,47 @@
+
+
+
+
+ {{ label }}
+
+
diff --git a/src/plugins/oSnap/components/Input/MethodParameter.vue b/src/plugins/oSnap/components/Input/MethodParameter.vue
new file mode 100644
index 00000000000..fe8a25ba727
--- /dev/null
+++ b/src/plugins/oSnap/components/Input/MethodParameter.vue
@@ -0,0 +1,141 @@
+
+
+
+
+ {{ label }}
+
+
+
+
+
+ {{ label }}
+
+
+ {{ label }}
+
+
+ {{ label }}
+
+
+ {{ label }}
+
+
diff --git a/src/plugins/oSnap/components/Input/ReadOnly.vue b/src/plugins/oSnap/components/Input/ReadOnly.vue
new file mode 100644
index 00000000000..8ddb45a5d12
--- /dev/null
+++ b/src/plugins/oSnap/components/Input/ReadOnly.vue
@@ -0,0 +1,9 @@
+
+
+
+
+
+
diff --git a/src/plugins/oSnap/components/TransactionBuilder/ContractInteraction.vue b/src/plugins/oSnap/components/TransactionBuilder/ContractInteraction.vue
new file mode 100644
index 00000000000..4f3b5b2ca91
--- /dev/null
+++ b/src/plugins/oSnap/components/TransactionBuilder/ContractInteraction.vue
@@ -0,0 +1,154 @@
+
+
+
+
+
+
+
diff --git a/src/plugins/oSnap/components/TransactionBuilder/ModalTransactionType.vue b/src/plugins/oSnap/components/TransactionBuilder/ModalTransactionType.vue
new file mode 100644
index 00000000000..527628dd07c
--- /dev/null
+++ b/src/plugins/oSnap/components/TransactionBuilder/ModalTransactionType.vue
@@ -0,0 +1,44 @@
+
+
+
+
+
+
+
diff --git a/src/plugins/oSnap/components/TransactionBuilder/RawTransaction.vue b/src/plugins/oSnap/components/TransactionBuilder/RawTransaction.vue
new file mode 100644
index 00000000000..0ca452a6d83
--- /dev/null
+++ b/src/plugins/oSnap/components/TransactionBuilder/RawTransaction.vue
@@ -0,0 +1,77 @@
+
+
+
+
+
+
+
+
+
+
+ This token isn't known to us. Please make sure it is the correct address
+ before proceeding.
+
+ {{ $t('learnMore') }}
+
+
+
+
diff --git a/src/plugins/oSnap/components/TransactionBuilder/TokensModalItem.vue b/src/plugins/oSnap/components/TransactionBuilder/TokensModalItem.vue
new file mode 100644
index 00000000000..af3166ebddd
--- /dev/null
+++ b/src/plugins/oSnap/components/TransactionBuilder/TokensModalItem.vue
@@ -0,0 +1,76 @@
+
+
+
+
+
diff --git a/src/plugins/oSnap/components/TransactionBuilder/Transaction.vue b/src/plugins/oSnap/components/TransactionBuilder/Transaction.vue
new file mode 100644
index 00000000000..e5e7c0a5523
--- /dev/null
+++ b/src/plugins/oSnap/components/TransactionBuilder/Transaction.vue
@@ -0,0 +1,94 @@
+
+
+
+
+ Add transaction +
+
+
diff --git a/src/plugins/oSnap/components/TransactionBuilder/TransferFunds.vue b/src/plugins/oSnap/components/TransactionBuilder/TransferFunds.vue
new file mode 100644
index 00000000000..f0492076631
--- /dev/null
+++ b/src/plugins/oSnap/components/TransactionBuilder/TransferFunds.vue
@@ -0,0 +1,124 @@
+
+
+
+
+
+
+
+
+
diff --git a/src/plugins/oSnap/components/TransactionBuilder/TransferNFT.vue b/src/plugins/oSnap/components/TransactionBuilder/TransferNFT.vue
new file mode 100644
index 00000000000..f54b022c937
--- /dev/null
+++ b/src/plugins/oSnap/components/TransactionBuilder/TransferNFT.vue
@@ -0,0 +1,100 @@
+
+
+
+
+ {{ $t('safeSnap.asset') }}
+
+ ![]()
+
+
+
+
+
+ {
+ const apiUrl = EXPLORER_API_URLS[network as keyof typeof EXPLORER_API_URLS];
+
+ if (!apiUrl) {
+ return '';
+ }
+
+ const isEthereumAddress = mustBeEthereumAddress(contractAddress);
+ const isEthereumContractAddress = await mustBeEthereumContractAddress(
+ network,
+ contractAddress
+ );
+
+ if (!isEthereumAddress || !isEthereumContractAddress) {
+ return '';
+ }
+
+ try {
+ const { result, status } = await fetchContractABI(apiUrl, contractAddress);
+
+ if (status === '0') {
+ return '';
+ }
+
+ return result;
+ } catch (e) {
+ console.error('Failed to retrieve ABI', e);
+ return '';
+ }
+}
+
+/**
+ * Checks if a method is a write function.
+ *
+ * Only write functions can be executed by the Optimistic Governor.
+ */
+export function isWriteFunction(method: FunctionFragment) {
+ if (!method.stateMutability) return true;
+ return !['view', 'pure'].includes(method.stateMutability);
+}
+
+/**
+ * Returns the write functions of a contract ABI.
+ */
+export function getABIWriteFunctions(abi: string) {
+ const abiInterface = new Interface(abi);
+ return (
+ abiInterface.fragments
+ // Return only contract's functions
+ .filter(FunctionFragment.isFunctionFragment)
+ .map(FunctionFragment.fromObject)
+ // Return only write functions
+ .filter(isWriteFunction)
+ // Sort by name
+ .sort((a, b) => (a.name.toLowerCase() > b.name.toLowerCase() ? 1 : -1))
+ );
+}
+
+/**
+ * Handles the extraction of the method's arguments from the `values` array.
+ *
+ * If the parameter is an array or tuple, we parse the value as JSON.
+ */
+function extractMethodArgs(values: string[]) {
+ return (param: ParamType, index: number) => {
+ const value = values[index];
+ if (isArrayParameter(param.baseType)) {
+ return JSON.parse(value);
+ }
+ return value;
+ };
+}
+
+/**
+ * Encodes the method and parameters of a contract interaction.
+ */
+export function encodeMethodAndParams(
+ abi: string,
+ method: FunctionFragment,
+ values: string[]
+) {
+ const contractInterface = new Interface(abi);
+ const parameterValues = method.inputs.map(extractMethodArgs(values));
+ return contractInterface.encodeFunctionData(method, parameterValues);
+}
+
+/**
+ * Returns the transaction data for an ERC20 transfer.
+ */
+export function getERC20TokenTransferTransactionData(
+ recipientAddress: string,
+ amount: BigNumberish
+): string {
+ const contractInterface = new Interface(ERC20_ABI);
+ return contractInterface.encodeFunctionData('transfer', [
+ recipientAddress,
+ amount
+ ]);
+}
+
+/**
+ * Returns the transaction data for an ERC721 transfer.
+ */
+export function getERC721TokenTransferTransactionData(
+ fromAddress: string,
+ recipientAddress: string,
+ id: BigNumberish
+): string {
+ const contractInterface = new Interface(ERC721_ABI);
+ return contractInterface.encodeFunctionData('safeTransferFrom', [
+ fromAddress,
+ recipientAddress,
+ id
+ ]);
+}
diff --git a/src/plugins/oSnap/utils/coins.ts b/src/plugins/oSnap/utils/coins.ts
new file mode 100644
index 00000000000..19d6c583a03
--- /dev/null
+++ b/src/plugins/oSnap/utils/coins.ts
@@ -0,0 +1,61 @@
+import { Network } from '../types';
+
+export const ETHEREUM_COIN = {
+ name: 'Ether',
+ decimals: 18,
+ symbol: 'ETH',
+ logoUri:
+ 'https://safe-transaction-assets.safe.global/chains/1/currency_logo.png',
+ address: 'main'
+} as const;
+
+export const MATIC_COIN = {
+ name: 'MATIC',
+ decimals: 18,
+ symbol: 'MATIC',
+ address: 'main',
+ logoUri:
+ 'https://safe-transaction-assets.safe.global/chains/137/currency_logo.png'
+} as const;
+
+const EWC_COIN = {
+ name: 'Energy Web Token',
+ symbol: 'EWT',
+ address: 'main',
+ decimals: 18,
+ logoUri:
+ 'https://safe-transaction-assets.safe.global/chains/246/currency_logo.png'
+} as const;
+
+const XDAI_COIN = {
+ name: 'XDAI',
+ symbol: 'XDAI',
+ address: 'main',
+ decimals: 18,
+ logoUri:
+ 'https://safe-transaction-assets.safe.global/chains/100/currency_logo.png'
+} as const;
+const BNB_COIN = {
+ name: 'BNB',
+ symbol: 'BNB',
+ address: 'main',
+ decimals: 18,
+ logoUri:
+ 'https://safe-transaction-assets.safe.global/chains/56/currency_logo.png'
+} as const;
+
+export function getNativeAsset(network: Network) {
+ switch (parseInt(network)) {
+ case 137:
+ case 80001:
+ return MATIC_COIN;
+ case 100:
+ return XDAI_COIN;
+ case 246:
+ return EWC_COIN;
+ case 56:
+ return BNB_COIN;
+ }
+
+ return ETHEREUM_COIN;
+}
diff --git a/src/plugins/oSnap/utils/events.ts b/src/plugins/oSnap/utils/events.ts
new file mode 100644
index 00000000000..4a195b63be2
--- /dev/null
+++ b/src/plugins/oSnap/utils/events.ts
@@ -0,0 +1,171 @@
+import { Contract, Event, EventFilter } from '@ethersproject/contracts';
+import bb from 'bluebird';
+
+// This state is meant for adjusting a start/end block when querying events. Some apis will fail if the range
+// is too big, so the following functions will adjust range dynamically.
+export type RangeState = {
+ startBlock: number;
+ endBlock: number;
+ maxRange: number;
+ currentRange: number;
+ currentStart: number; // This is the start value you want for your query.
+ currentEnd: number; // this is the end value you want for your query.
+ done: boolean; // Signals we successfully queried the entire range.
+ multiplier?: number; // Multiplier increases or decreases range by this value, depending on success or failure
+};
+
+/**
+ * rangeStart. This starts a new range query and sets defaults for state. Use this as the first call before starting your queries
+ *
+ * @param {Pick} state
+ * @returns {RangeState}
+ */
+export function rangeStart(
+ state: Pick & {
+ maxRange?: number;
+ }
+): RangeState {
+ const { startBlock, endBlock, multiplier = 2 } = state;
+ if (state.maxRange && state.maxRange > 0) {
+ const range = endBlock - startBlock;
+ if (!(range >= 0)) {
+ throw new Error('End block must be higher than start block');
+ }
+ const currentRange = Math.min(state.maxRange, range);
+ const currentStart = endBlock - currentRange;
+ const currentEnd = endBlock;
+ return {
+ done: false,
+ startBlock,
+ endBlock,
+ maxRange: state.maxRange,
+ currentRange,
+ currentStart,
+ currentEnd,
+ multiplier
+ };
+ } else {
+ // the largest range we can have, since this is the users query for start and end
+ const maxRange = endBlock - startBlock;
+ if (!(maxRange > 0)) {
+ throw new Error('End block must be higher than start block');
+ }
+ const currentStart = startBlock;
+ const currentEnd = endBlock;
+ const currentRange = maxRange;
+
+ return {
+ done: false,
+ startBlock,
+ endBlock,
+ maxRange,
+ currentRange,
+ currentStart,
+ currentEnd,
+ multiplier
+ };
+ }
+}
+/**
+ * rangeSuccessDescending. We have 2 ways of querying events, from oldest to newest, or newest to oldest. Typically we want them in order, from
+ * oldest to newest, but for this particular case we want them newest to oldest, ie descending ( larger timestamp to smaller timestamp).
+ * This function will increase the range between start/end block and return a new start/end to use since by calling this you are signalling
+ * that the last range ended in a successful query.
+ *
+ * @param {RangeState} state
+ * @returns {RangeState}
+ */
+export function rangeSuccessDescending(state: RangeState): RangeState {
+ const {
+ startBlock,
+ currentStart,
+ maxRange,
+ currentRange,
+ multiplier = 2
+ } = state;
+ // we are done if we succeeded querying where the currentStart matches are initial start block
+ const done = currentStart <= startBlock;
+ // increase range up to max range for every successful query
+ const nextRange = Math.min(Math.ceil(currentRange * multiplier), maxRange);
+ // move our end point to the previously successful start, ie moving from newest to oldest
+ const nextEnd = currentStart;
+ // move our start block to the next range down
+ const nextStart = Math.max(nextEnd - nextRange, startBlock);
+ return {
+ ...state,
+ currentStart: nextStart,
+ currentEnd: nextEnd,
+ currentRange: nextRange,
+ done
+ };
+}
+/**
+ * rangeFailureDescending. Like the previous function, this will decrease the range between start/end for your query, because you are signalling
+ * that the last query failed. It will also keep the end of your range the same, while moving the start range up. This is why
+ * its considered descending, it will attempt to move from end to start, rather than start to end.
+ *
+ * @param {RangeState} state
+ * @returns {RangeState}
+ */
+export function rangeFailureDescending(state: RangeState): RangeState {
+ const { startBlock, currentEnd, currentRange, multiplier = 2 } = state;
+ const nextRange = Math.floor(currentRange / multiplier);
+ // this will eventually throw an error if you keep calling this function, which protects us against re-querying a broken api in a loop
+ if (currentRange <= 0) throw new Error('Current range must be above 0');
+ if (!(nextRange > 0)) throw new Error('Range must be above 0');
+ // we stay at the same end block
+ const nextEnd = currentEnd;
+ // move our start block closer to the end block, shrinking the range
+ const nextStart = Math.max(nextEnd - nextRange, startBlock);
+ return {
+ ...state,
+ currentStart: nextStart,
+ currentEnd: nextEnd,
+ currentRange: nextRange
+ };
+}
+
+// The main interface to wrap the above pure functions up. requires you to pass in a generic function
+// which returns the events based on a start/end block query.
+export async function pageEvents(
+ startBlock: number,
+ endBlock: number,
+ maxRange: number,
+ //start and end block range to query
+ fetchEvents: (query: { start: number; end: number }) => Promise,
+ concurrency: number = 5
+): Promise {
+ let state = rangeStart({ startBlock, endBlock, maxRange });
+ const ranges: { start: number; end: number; index: number }[] = [];
+ let index = 0;
+ do {
+ ranges.push({
+ start: state.currentStart,
+ end: state.currentEnd,
+ index: index++
+ });
+ state = rangeSuccessDescending(state);
+ } while (!state.done);
+
+ return (await bb.map(ranges, fetchEvents, { concurrency })).flat();
+}
+
+export async function getPagedEvents(params: {
+ contract: Contract;
+ eventFilter: EventFilter;
+ startBlock: number;
+ latestBlock: number;
+ maxRange: number;
+}) {
+ const { contract, eventFilter, startBlock, latestBlock, maxRange } = params;
+ const eventPager = ({ start, end }: { start: number; end: number }) => {
+ return contract.queryFilter(eventFilter, start, end);
+ };
+ const pagedEvents = await pageEvents(
+ startBlock,
+ latestBlock,
+ maxRange,
+ eventPager
+ );
+ return pagedEvents as EventType[];
+}
diff --git a/src/plugins/oSnap/utils/getters.ts b/src/plugins/oSnap/utils/getters.ts
new file mode 100644
index 00000000000..cbbfe337cdb
--- /dev/null
+++ b/src/plugins/oSnap/utils/getters.ts
@@ -0,0 +1,755 @@
+import { TreasuryWallet } from '@/helpers/interfaces';
+import { defaultAbiCoder } from '@ethersproject/abi';
+import { BigNumber } from '@ethersproject/bignumber';
+import { Contract } from '@ethersproject/contracts';
+import { keccak256 } from '@ethersproject/keccak256';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { pack } from '@ethersproject/solidity';
+import { toUtf8Bytes } from '@ethersproject/strings';
+import { multicall } from '@snapshot-labs/snapshot.js/src/utils';
+import getProvider from '@snapshot-labs/snapshot.js/src/utils/provider';
+import memoize from 'lodash/memoize';
+import {
+ ERC20_ABI,
+ GNOSIS_SAFE_TRANSACTION_API_URLS,
+ OPTIMISTIC_GOVERNOR_ABI,
+ OPTIMISTIC_ORACLE_V3_ABI,
+ contractData,
+ safePrefixes,
+ solidityZeroHexString
+} from '../constants';
+import {
+ AssertionGql,
+ AssertionMadeEvent,
+ BalanceResponse,
+ CollateralDetails,
+ NFT,
+ Network,
+ OGModuleDetails,
+ OGProposalState,
+ OptimisticGovernorTransaction,
+ ProposalExecutedEvent,
+ SafeNetworkPrefix,
+ TransactionsProposedEvent
+} from '../types';
+import { getPagedEvents } from './events';
+
+/**
+ * Calls the Gnosis Safe Transaction API
+ *
+ * Ideal usage is to specify the shape of the response with the generic type parameter, assuming that the shape of the response is known.
+ */
+async function callGnosisSafeTransactionApi(
+ network: Network,
+ url: string
+) {
+ const apiUrl = GNOSIS_SAFE_TRANSACTION_API_URLS[network];
+ const response = await fetch(apiUrl + url);
+ return response.json() as TResult;
+}
+
+/**
+ * Fetches the balances of the tokens owned by a given Safe.
+ */
+export const getGnosisSafeBalances = memoize(
+ (network: Network, safeAddress: string) => {
+ const endpointPath = `/v1/safes/${safeAddress}/balances/`;
+ return callGnosisSafeTransactionApi[]>(
+ network,
+ endpointPath
+ );
+ },
+ (safeAddress, network) => `${safeAddress}_${network}`
+);
+
+/**
+ * Fetches the collectibles owned by a given Safe.
+ */
+export const getGnosisSafeCollectibles = memoize(
+ (network: Network, safeAddress: string) => {
+ const endpointPath = `/v2/safes/${safeAddress}/collectibles/`;
+ // the endpoint returns the data in this form, most likely to allow you to page the data.
+ type Result = {
+ count: number;
+ next: unknown;
+ previous: unknown;
+ results: NFT[];
+ };
+ return callGnosisSafeTransactionApi(network, endpointPath);
+ },
+ (safeAddress, network) => `${safeAddress}_${network}`
+);
+
+/**
+ * Fetches the block number of a given contract's deployment.
+ */
+function getDeployBlock(params: { network: Network; name: string }): number {
+ const results = contractData.filter(
+ contract =>
+ contract.network === params.network && contract.name === params.name
+ );
+ if (results.length === 1) return results[0].deployBlock ?? 0;
+ return 0;
+}
+
+/**
+ * Fetches the subgraph url for a given contract on a given network.
+ */
+function getContractSubgraph(params: { network: Network; name: string }) {
+ const results = contractData.filter(
+ contract =>
+ contract.network === params.network && contract.name === params.name
+ );
+ if (results.length > 1)
+ throw new Error(
+ `Too many results finding ${params.name} subgraph on network ${params.network}`
+ );
+ if (results.length < 1)
+ throw new Error(
+ `No results finding ${params.name} subgraph on network ${params.network}`
+ );
+ if (!results[0].subgraph)
+ throw new Error(
+ `No subgraph url defined for ${params.name} on network ${params.network}`
+ );
+ return results[0].subgraph;
+}
+
+/**
+ * A helper that wraps the getContractSubgraph function to return the subgraph url for the OptimisticGovernor contract on a given network.
+ */
+function getOptimisticGovernorSubgraph(network: Network): string {
+ return getContractSubgraph({ network, name: 'OptimisticGovernor' });
+}
+
+/**
+ * A helper that wraps the getContractSubgraph function to return the subgraph url for the OptimisticOracleV3 contract on a given network.
+ */
+function getOracleV3Subgraph(network: Network): string {
+ return getContractSubgraph({ network, name: 'OptimisticOracleV3' });
+}
+
+/**
+ * Executes a graphql query.
+ *
+ * Ideal usage is to specify the shape of the response with the generic type parameter, assuming that the shape of the response is known.
+ */
+export const queryGql = async (url: string, query: string) => {
+ try {
+ const response = await fetch(url, {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ Accept: 'application/json'
+ },
+ body: JSON.stringify({ query: query })
+ });
+ if (!response.ok) {
+ const errorData = await response.json();
+ throw new Error(
+ `Network Error: ${response.status}, message: ${errorData.message}`
+ );
+ }
+ const data = await response.json();
+ // Throw an error if there are errors in the GraphQL response
+ if (data.errors) {
+ throw new Error(
+ `GraphQL Error: ${data.errors.map(error => error.message).join(', ')}`
+ );
+ }
+ return data.data as Result;
+ } catch (error) {
+ throw new Error(
+ `Network error: ${error instanceof Error ? error.message : error}`
+ );
+ }
+};
+
+/**
+ * Returns the address of the Optimistic Governor contract deployment associated with a given treasury (Safe) from the graph.
+ */
+export const getModuleAddressForTreasury = async (
+ network: Network,
+ treasuryAddress: string
+) => {
+ const subgraph = getOptimisticGovernorSubgraph(network);
+ const query = `
+ query getModuleAddressForTreasury {
+ safe(id: "${treasuryAddress.toLowerCase()}") {
+ optimisticGovernor {
+ id
+ }
+ }
+ }
+ `;
+
+ type Result = {
+ safe: { optimisticGovernor: { id: string } };
+ };
+
+ const result = await queryGql(subgraph, query);
+ return result?.safe?.optimisticGovernor?.id ?? '';
+};
+
+/**
+ * Checks if a given treasury (Safe) has enabled oSnap.
+ */
+export const getIsOsnapEnabled = async (
+ network: Network,
+ safeAddress: string
+) => {
+ const subgraph = getOptimisticGovernorSubgraph(network);
+ const query = `
+ query isOSnapEnabled {
+ safe(id:"${safeAddress.toLowerCase()}"){
+ isOptimisticGovernorEnabled
+ }
+ }
+ `;
+ type Result = {
+ safe: { isOptimisticGovernorEnabled: boolean };
+ };
+ const result = await queryGql(subgraph, query);
+ return result?.safe?.isOptimisticGovernorEnabled ?? false;
+};
+
+/**
+ * Takes an array of treasuries and checks if any of them have oSnap enabled.
+ */
+export const getSpaceHasOsnapEnabledTreasury = async (
+ treasuries: TreasuryWallet[]
+) => {
+ const isOsnapEnabledOnTreasuriesResult = await Promise.all(
+ treasuries.map(treasury =>
+ getIsOsnapEnabled(treasury.network as Network, treasury.address)
+ )
+ );
+ return isOsnapEnabledOnTreasuriesResult.some(
+ isOsnapEnabled => isOsnapEnabled
+ );
+};
+
+/**
+ * Creates the url for the Safe app to configure oSnap.
+ *
+ * The data that the Safe app needs is encoded as URL search params.
+ */
+export function makeConfigureOsnapUrl(params: {
+ safeAddress: string;
+ network: Network;
+ spaceName: string;
+ spaceUrl: string;
+ baseUrl?: string;
+ appUrl?: string;
+}) {
+ const {
+ safeAddress,
+ network,
+ spaceName,
+ spaceUrl,
+ baseUrl = 'https://app.safe.global/apps/open',
+ appUrl = 'https://osnap.uma.xyz/'
+ } = params;
+ const safeAddressPrefix = getSafeNetworkPrefix(network);
+ const appUrlSearchParams = new URLSearchParams();
+ appUrlSearchParams.set('spaceName', spaceName);
+ appUrlSearchParams.set('spaceUrl', spaceUrl);
+ const appUrlSearch = appUrlSearchParams.toString();
+ const safeAppSearchParams = new URLSearchParams();
+ safeAppSearchParams.set('safe', `${safeAddressPrefix}:${safeAddress}`);
+ safeAppSearchParams.set('appUrl', `${appUrl}?${appUrlSearch}`);
+ const safeAppSearch = safeAppSearchParams.toString();
+ const url = `${baseUrl}?${safeAppSearch}`;
+ return url;
+}
+
+/**
+ * Fetches the details of a given assertion from the Optimistic Oracle V3 subgraph.
+ */
+async function getAssertionGql(params: {
+ network: Network;
+ assertionId: string;
+}) {
+ const { assertionId, network } = params;
+ const oracleUrl = getOracleV3Subgraph(network);
+ const request = `
+ {
+ assertion(id:"${assertionId}"){
+ assertionId
+ expirationTime
+ assertionHash
+ disputeHash
+ settlementHash
+ assertionLogIndex
+ settlementResolution
+ }
+ }
+ `;
+ type Result = {
+ assertion: AssertionGql | undefined;
+ };
+ const result = await queryGql(oracleUrl, request);
+ return result?.assertion;
+}
+/**
+ * Fetches the details of a given proposal from the Optimistic Governor subgraph.
+ *
+ * The subgraph uses the `assertionId` that comes from assertion events as the primary key for proposals.
+ * However, this `assertionId` will be deleted if the proposal is disputed, so we can't use it to query the subgraph.
+ * Instead, we use the `proposalHash` and `explanation` to query the subgraph.
+ * The `explanation` contains the ipfs url of the proposal, which is the only way to distinguish between proposals with the same `proposalHash`.
+ * This means we must use a `where` clause to filter the results, which is not ideal.
+ */
+async function getOgProposalGql(params: {
+ network: Network;
+ explanation: string;
+ moduleAddress: string;
+ proposalHash: string;
+}) {
+ const { network, explanation, moduleAddress, proposalHash } = params;
+ const encodedExplanation = pack(
+ ['bytes'],
+ [toUtf8Bytes(explanation.replace(/^0x/, ''))]
+ );
+ const subgraph = getOptimisticGovernorSubgraph(network);
+ const request = `
+{
+ proposals(where:{proposalHash:"${proposalHash}",explanation:"${encodedExplanation}",optimisticGovernor:"${moduleAddress.toLowerCase()}"}){
+ id
+ executed
+ deleted
+ assertionId
+ }
+}
+`;
+ type Result = {
+ proposals: {
+ id: string;
+ executed: boolean;
+ assertionId: string;
+ deleted: boolean;
+ }[];
+ };
+ const result = await queryGql(subgraph, request);
+ // we can only use the gql `where` clause when querying a list, but we know that there will only be one result.
+ return result?.proposals[0];
+}
+
+/**
+ * Fetches the details of a Optimistic Governor module's collateral token.
+ *
+ * Returns the address, symbol, and decimals of the collateral token, along with the token contract for further querying.
+ */
+export async function getCollateralDetailsForProposal(
+ provider: StaticJsonRpcProvider,
+ moduleAddress: string
+): Promise {
+ const moduleContract = new Contract(
+ moduleAddress,
+ OPTIMISTIC_GOVERNOR_ABI,
+ provider
+ );
+
+ const erc20Contract = new Contract(
+ await moduleContract.collateral(),
+ ERC20_ABI,
+ provider
+ );
+
+ const address = erc20Contract.address;
+ const symbol: string = await erc20Contract.symbol();
+ const decimals: BigNumber = await erc20Contract.decimals();
+
+ return { erc20Contract, address, symbol, decimals };
+}
+
+/**
+ * Fetches the allowance of a given collateral token for a given user.
+ */
+export async function getUserCollateralAllowance(
+ erc20Contract: Contract,
+ userAddress: string,
+ moduleAddress: string
+) {
+ return erc20Contract.allowance(userAddress, moduleAddress);
+}
+
+/**
+ * Fetches the balance of a given collateral token for a given user.
+ */
+export async function getUserCollateralBalance(
+ erc20Contract: Contract,
+ userAddress: string
+) {
+ return erc20Contract.balanceOf(userAddress);
+}
+
+/**
+ * Fetches the details of a given Optimistic Governor module from the chain.
+ *
+ * Performs a multicall to fetch the oracle address, rules, minimum bond, and challenge period.
+ */
+export async function getOGModuleDetails(params: {
+ provider: StaticJsonRpcProvider;
+ network: Network;
+ moduleAddress: string;
+ transactions: OptimisticGovernorTransaction[];
+}): Promise {
+ const { provider, network, moduleAddress } = params;
+ const moduleDetails: [
+ [oracleAddress: string],
+ [rules: string],
+ [minimumBond: BigNumber],
+ [challengePeriod: BigNumber]
+ ] = await multicall(network, provider, OPTIMISTIC_GOVERNOR_ABI as any, [
+ [moduleAddress, 'optimisticOracleV3'],
+ [moduleAddress, 'rules'],
+ [moduleAddress, 'bondAmount'],
+ [moduleAddress, 'liveness']
+ ]);
+
+ const oracleAddress = moduleDetails[0][0];
+ const rules = moduleDetails[1][0];
+ const minimumBond = moduleDetails[2][0];
+ const challengePeriod = moduleDetails[3][0];
+
+ return {
+ moduleAddress,
+ oracleAddress,
+ rules,
+ minimumBond,
+ challengePeriod
+ };
+}
+
+/**
+ * Fetches the state of an Optimistic Governor proposal from the chain.
+ *
+ * This is a fallback function that should only be used if the subgraph is not available, because it is very slow.
+ *
+ * The contract is designed in such a way that it deletes the `assertionId` from the proposal if the proposal is disputed, _or_ if the transactions are executed successfully. This means we can't tell the difference between a proposal that has not yet been proposed, has been disputed, or that has been executed by querying the chain.
+ *
+ * Instead, we must query the chain for the proposal events, and then query the chain for the execution events, and then compare the two to determine the state of the proposal. This is very slow.
+ */
+export async function getOgProposalStateFromChain(params: {
+ moduleDetails: OGModuleDetails;
+ network: Network;
+ proposalHash: string;
+ explanation: string;
+}): Promise {
+ const { network, moduleDetails, explanation, proposalHash } = params;
+ const { moduleAddress, oracleAddress } = moduleDetails;
+
+ const provider = getProvider(network);
+ const latestBlock = (await provider.getBlock('latest')).number;
+ const oGstartBlock = getDeployBlock({ network, name: 'OptimisticGovernor' });
+ const oOStartBlock = getDeployBlock({ network, name: 'OptimisticOracleV3' });
+ const maxRange = 3000;
+
+ const moduleContract = new Contract(
+ moduleAddress,
+ OPTIMISTIC_GOVERNOR_ABI,
+ provider
+ );
+ const oracleContract = new Contract(
+ oracleAddress,
+ OPTIMISTIC_ORACLE_V3_ABI,
+ provider
+ );
+
+ const assertionId: string = await moduleContract.assertionIds(proposalHash);
+ const hasAssertionId = assertionIdIsNotZero(assertionId);
+
+ if (hasAssertionId) {
+ const assertionMadeEventForCurrentAssertionIdFilter =
+ oracleContract.filters.AssertionMade(assertionId);
+
+ const assertionMadeEvents = await getPagedEvents({
+ contract: oracleContract,
+ eventFilter: assertionMadeEventForCurrentAssertionIdFilter,
+ startBlock: oOStartBlock,
+ latestBlock,
+ maxRange
+ });
+
+ // assertion ids are unique, so this will have only one result
+ // we need to get an event instead of getting the `Assertion` struct from the chain because the oracle dapp needs the assertion transaction hash and the log index to link to the oracle dapp.
+ const assertionMadeEvent = assertionMadeEvents[0];
+
+ const expirationTime = assertionMadeEvent.args?.expirationTime.toNumber();
+ const isInChallengePeriod = expirationTime * 1000 > Date.now();
+ const assertionHash = assertionMadeEvent.transactionHash;
+ const assertionLogIndex = assertionMadeEvent.logIndex.toString();
+
+ if (isInChallengePeriod) {
+ return {
+ status: 'in-oo-challenge-period',
+ assertionHash,
+ assertionLogIndex,
+ expirationTime
+ };
+ }
+
+ return {
+ status: 'can-request-tx-execution',
+ assertionHash,
+ assertionLogIndex
+ };
+ }
+
+ const transactionsProposedEventFilter =
+ moduleContract.filters.TransactionsProposed();
+
+ const transactionsProposedEvents =
+ await getPagedEvents({
+ contract: moduleContract,
+ eventFilter: transactionsProposedEventFilter,
+ startBlock: oGstartBlock,
+ latestBlock,
+ maxRange
+ });
+
+ const transactionsProposedEventsThatMatch = transactionsProposedEvents.filter(
+ event =>
+ event.args?.proposalHash === proposalHash &&
+ event.args?.explanation === explanation
+ );
+
+ const hasTransactionProposedEvents =
+ transactionsProposedEventsThatMatch.length > 0;
+
+ // we can return early and skip querying for execution events if there are no proposal events
+ if (!hasTransactionProposedEvents) {
+ return {
+ status: 'can-propose-to-og',
+ isDisputed: false
+ };
+ }
+
+ // the proposal hash is not indexed on the transactions proposed event unfortunately, but it is on the proposal executed event.
+ // so at least we can use it for this one to narrow down the results.
+ const proposalExecutedEventFilter =
+ moduleContract.filters.ProposalExecuted(proposalHash);
+
+ const proposalExecutedEvents = await getPagedEvents({
+ contract: moduleContract,
+ eventFilter: proposalExecutedEventFilter,
+ startBlock: oGstartBlock,
+ latestBlock,
+ maxRange
+ });
+
+ // we know that the transactions have been executed if there is an execution event with an assertion id that matches an assertion id for a proposal event
+ let proposalExecuted = false;
+ for (const proposalExecutedEvent of proposalExecutedEvents) {
+ for (const transactionsProposedEvent of transactionsProposedEventsThatMatch) {
+ if (
+ proposalExecutedEvent.args?.assertionId ===
+ transactionsProposedEvent.args?.assertionId
+ ) {
+ proposalExecuted = true;
+ break;
+ }
+ }
+ }
+
+ if (proposalExecuted) {
+ const assertionMadeEventForExecutedAssertionIdFilter =
+ oracleContract.filters.AssertionMade(assertionId);
+
+ const assertionMadeEvents = await getPagedEvents({
+ contract: oracleContract,
+ eventFilter: assertionMadeEventForExecutedAssertionIdFilter,
+ startBlock: oOStartBlock,
+ latestBlock,
+ maxRange
+ });
+
+ // assertion ids are unique, so this will have only one result
+ const assertionMadeEvent = assertionMadeEvents[0];
+
+ return {
+ status: 'transactions-executed',
+ assertionHash: assertionMadeEvent.transactionHash,
+ assertionLogIndex: assertionMadeEvent.logIndex.toString()
+ };
+ }
+
+ return {
+ status: 'can-propose-to-og',
+ isDisputed: false
+ };
+}
+
+/**
+ * Fetches the state of an Optimistic Governor proposal from the subgraph.
+ *
+ * This is the preferred method of fetching the state of a proposal, because it is much faster than querying the chain.
+ */
+export async function getOGProposalStateGql(params: {
+ network: Network;
+ moduleAddress: string;
+ proposalHash: string;
+ explanation: string;
+}): Promise {
+ const { network } = params;
+ const oGproposal = await getOgProposalGql(params);
+
+ if (!oGproposal) {
+ return { status: 'can-propose-to-og', isDisputed: false };
+ }
+
+ const { executed, assertionId, deleted } = oGproposal;
+
+ const hasAssertionId = assertionIdIsNotZero(assertionId);
+
+ // the subgraph records `ProposalDeleted` events, which are fired when a proposal is disputed.
+ if (!hasAssertionId && deleted) {
+ return { status: 'can-propose-to-og', isDisputed: true };
+ }
+
+ if (!hasAssertionId) {
+ return { status: 'can-propose-to-og', isDisputed: false };
+ }
+
+ const assertion = await getAssertionGql({ network, assertionId });
+
+ if (!assertion) {
+ return { status: 'can-propose-to-og', isDisputed: false };
+ }
+
+ const {
+ assertionHash,
+ settlementHash,
+ assertionLogIndex,
+ settlementResolution
+ } = assertion;
+
+ // if the assertion is settled and the graph says the transactions have been executed, then we know the assertion passed and we can return early
+ if (executed && settlementHash) {
+ return {
+ status: 'transactions-executed',
+ assertionHash,
+ assertionLogIndex
+ };
+ }
+
+ // if the settlement hash exists and the settlement resolution is true, then we know that the assertion passed.
+ // we already checked if the transactions were executed, so we know that the assertion passed but the transactions were not executed yet.
+ if (settlementHash && settlementResolution) {
+ return {
+ status: 'can-request-tx-execution',
+ assertionHash,
+ assertionLogIndex
+ };
+ }
+
+ const expirationTime = Number(assertion.expirationTime);
+ const isExpired = Math.floor(Date.now() / 1000) >= expirationTime;
+
+ // from the above checks, we know that the transactions have not been executed, the assertion has not been disputed, and the assertion has not been settled.
+ // if the assertion challenge period has not yet expired, then we know we are still in the challenge period.
+ if (!isExpired) {
+ return {
+ status: 'in-oo-challenge-period',
+ assertionHash,
+ assertionLogIndex,
+ expirationTime
+ };
+ }
+
+ // if all the above fails, fall back to the no assertion state
+ // this should not be possible though
+ return { status: 'can-propose-to-og', isDisputed: false };
+}
+
+/**
+ * Querying for an assertion ID that does not map to a proposal hash will return '0x0000000000000000000000000000000000000000000000000000000000000000'
+ */
+function assertionIdIsNotZero(assertionId: string) {
+ return assertionId !== solidityZeroHexString;
+}
+
+/**
+ * Fetches the state of an Optimistic Governor proposal.
+ *
+ * This function will attempt to fetch the state of a proposal from the subgraph, and if that fails, it will fall back to querying the chain.
+ */
+export async function getOGProposalState(params: {
+ moduleDetails: OGModuleDetails;
+ network: Network;
+ explanation: string;
+ transactions: OptimisticGovernorTransaction[];
+}): Promise {
+ const { network, moduleDetails, explanation, transactions } = params;
+ const { moduleAddress } = moduleDetails;
+ const proposalHash = getProposalHashFromTransactions(transactions);
+ try {
+ return await getOGProposalStateGql({
+ network,
+ moduleAddress,
+ explanation,
+ proposalHash
+ });
+ } catch (error) {
+ console.warn(
+ 'Error fetching OG proposal state from subgraph, falling back to chain',
+ error
+ );
+ return getOgProposalStateFromChain({
+ network,
+ moduleDetails,
+ explanation,
+ proposalHash
+ });
+ }
+}
+
+/**
+ * The `proposalHash` as represented in the Optimistic Governor contract is the keccak256 hash of the transactions that make up the proposal.
+ */
+export function getProposalHashFromTransactions(
+ transactions: OptimisticGovernorTransaction[]
+) {
+ return keccak256(
+ defaultAbiCoder.encode(
+ ['(address to, uint8 operation, uint256 value, bytes data)[]'],
+ [transactions]
+ )
+ );
+}
+
+/**
+ * Returns the EIP-3770 prefix for a given network.
+ *
+ * @see SafeNetworkPrefix
+ */
+export function getSafeNetworkPrefix(network: Network): SafeNetworkPrefix {
+ return safePrefixes[network];
+}
+
+/**
+ * Returns the url for a given Safe app on a given network.
+ */
+export function getSafeAppLink(
+ network: Network,
+ safeAddress: string,
+ appUrl = 'https://gnosis-safe.io/app/'
+) {
+ const prefix = getSafeNetworkPrefix(network);
+ return `${appUrl}${prefix}:${safeAddress}`;
+}
+
+/**
+ * Returns the url for an Optimistic Governor proposal's assertion on the Optimistic Oracle dapp.
+ */
+export function getOracleUiLink(
+ chain: string,
+ txHash: string,
+ logIndex: number
+) {
+ if (Number(chain) !== 5 && Number(chain) !== 80001) {
+ return `https://oracle.uma.xyz?transactionHash=${txHash}&eventIndex=${logIndex}`;
+ }
+ return `https://testnet.oracle.uma.xyz?transactionHash=${txHash}&eventIndex=${logIndex}`;
+}
diff --git a/src/plugins/oSnap/utils/index.ts b/src/plugins/oSnap/utils/index.ts
new file mode 100644
index 00000000000..b903e6f3aea
--- /dev/null
+++ b/src/plugins/oSnap/utils/index.ts
@@ -0,0 +1,7 @@
+export * from './abi';
+export * from './coins';
+export * from './events';
+export * from './getters';
+export * from './proposal';
+export * from './transactions';
+export * from './validators';
diff --git a/src/plugins/oSnap/utils/proposal.ts b/src/plugins/oSnap/utils/proposal.ts
new file mode 100644
index 00000000000..e0815faa6d9
--- /dev/null
+++ b/src/plugins/oSnap/utils/proposal.ts
@@ -0,0 +1,75 @@
+import { BigNumber } from '@ethersproject/bignumber';
+import { toUtf8Bytes } from '@ethersproject/strings';
+import { sendTransaction } from '@snapshot-labs/snapshot.js/src/utils';
+import { ERC20_ABI, OPTIMISTIC_GOVERNOR_ABI } from '../constants';
+import { OptimisticGovernorTransaction } from '../types';
+
+/**
+ * The user must approve the spend of the collateral token before they can submit a proposal.
+ *
+ * If the proposal is disputed and fails a vote, the user will lose their bond.
+ */
+export async function* approveBond(
+ web3: any,
+ moduleAddress: string,
+ collateralAddress: string,
+ minimumBond: BigNumber
+) {
+ const approveTx = await sendTransaction(
+ web3,
+ collateralAddress,
+ ERC20_ABI as any,
+ 'approve',
+ [moduleAddress, minimumBond],
+ {}
+ );
+ yield approveTx;
+ const approvalReceipt = await approveTx.wait();
+ console.log('[DAO module] token transfer approved:', approvalReceipt);
+ yield;
+}
+
+/**
+ * Submits a proposal to the Optimistic Governor.
+ */
+export async function* submitProposal(
+ web3: any,
+ moduleAddress: string,
+ explanation: string,
+ transactions: OptimisticGovernorTransaction[]
+) {
+ const explanationBytes = toUtf8Bytes(explanation);
+ const tx = await sendTransaction(
+ web3,
+ moduleAddress,
+ OPTIMISTIC_GOVERNOR_ABI as any,
+ 'proposeTransactions',
+ [transactions, explanationBytes]
+ // [[["0xB8034521BB1a343D556e5005680B3F17FFc74BeD", 0, "0", "0x"]], '0x']
+ );
+ yield tx;
+ const receipt = await tx.wait();
+ console.log('[DAO module] submitted proposal:', receipt);
+}
+
+/**
+ * Executes a proposal on the Optimistic Governor.
+ *
+ * This can only be done after the dispute window has ended.
+ */
+export async function* executeProposal(
+ web3: any,
+ moduleAddress: string,
+ transactions: OptimisticGovernorTransaction[]
+) {
+ const tx = await sendTransaction(
+ web3,
+ moduleAddress,
+ OPTIMISTIC_GOVERNOR_ABI as any,
+ 'executeProposal',
+ [transactions]
+ );
+ yield tx;
+ const receipt = await tx.wait();
+ console.log('[DAO module] executed proposal:', receipt);
+}
diff --git a/src/plugins/oSnap/utils/transactions.ts b/src/plugins/oSnap/utils/transactions.ts
new file mode 100644
index 00000000000..00eaec9eea7
--- /dev/null
+++ b/src/plugins/oSnap/utils/transactions.ts
@@ -0,0 +1,157 @@
+import { FunctionFragment } from '@ethersproject/abi';
+import { BigNumber } from '@ethersproject/bignumber';
+import {
+ ContractInteractionTransaction,
+ NFT,
+ OptimisticGovernorTransaction,
+ RawTransaction,
+ Token,
+ TransferFundsTransaction,
+ TransferNftTransaction
+} from '../types';
+import { encodeMethodAndParams } from './abi';
+
+/**
+ * Creates a formatted transaction for the Optimistic Governor to execute
+ *
+ * note: the value for `operation` is always zero because we do not support delegatecall.
+ *
+ * @see OptimisticGovernorTransaction
+ */
+export function createFormattedOptimisticGovernorTransaction({
+ to,
+ value,
+ data
+}: {
+ to: string;
+ value: string;
+ data: string;
+}): OptimisticGovernorTransaction {
+ return [to, 0, value, data];
+}
+
+/**
+ * Creates a raw transaction for the Optimistic Governor to execute
+ *
+ * @see RawTransaction
+ */
+export function createRawTransaction(params: {
+ to: string;
+ value: string;
+ data: string;
+}): RawTransaction {
+ const type = 'raw';
+ const formatted = createFormattedOptimisticGovernorTransaction(params);
+ return {
+ ...params,
+ type,
+ formatted
+ };
+}
+
+/**
+ * Creates a transaction to transfer an NFT
+ *
+ * @see TransferNftTransaction
+ */
+export function createTransferNftTransaction(params: {
+ recipient: string;
+ collectable: NFT;
+ data: string;
+}): TransferNftTransaction {
+ const type = 'transferNFT';
+ const to = params.collectable.address;
+ const value = '0';
+ const data = params.data;
+ const formatted = createFormattedOptimisticGovernorTransaction({
+ to,
+ value,
+ data
+ });
+
+ return {
+ ...params,
+ type,
+ to,
+ value,
+ data,
+ formatted
+ };
+}
+
+/**
+ * Creates a transaction to transfer funds
+ *
+ * @see TransferFundsTransaction
+ */
+export function createTransferFundsTransaction(params: {
+ recipient: string;
+ amount: string;
+ token: Token;
+ data: string;
+}): TransferFundsTransaction {
+ const type = 'transferFunds';
+ const isNativeToken = params.token.address === 'main';
+ const data = isNativeToken ? '0x' : params.data;
+ const to = isNativeToken ? params.recipient : params.token.address;
+ const amount = parseAmount(params.amount);
+ const value = isNativeToken ? amount : '0';
+ const formatted = createFormattedOptimisticGovernorTransaction({
+ to,
+ value,
+ data
+ });
+ return {
+ ...params,
+ type,
+ data,
+ to,
+ value,
+ amount,
+ formatted
+ };
+}
+
+/**
+ * Creates a transaction to interact with a contract.
+ *
+ * the `method` is executed with the given `parameters`.
+ *
+ * @see ContractInteractionTransaction
+ */
+export function createContractInteractionTransaction(params: {
+ to: string;
+ value: string;
+ abi: string;
+ method: FunctionFragment;
+ parameters: string[];
+}): ContractInteractionTransaction {
+ const type = 'contractInteraction';
+ const data = encodeMethodAndParams(
+ params.abi,
+ params.method,
+ params.parameters
+ );
+ const formatted = createFormattedOptimisticGovernorTransaction({
+ ...params,
+ data
+ });
+ return {
+ ...params,
+ data,
+ type,
+ formatted
+ };
+}
+
+export function parseAmount(input: string) {
+ return BigNumber.from(input).toString();
+}
+
+export function parseValueInput(input: string) {
+ try {
+ return parseAmount(input);
+ } catch (e) {
+ return input;
+ }
+}
diff --git a/src/plugins/oSnap/utils/validators.ts b/src/plugins/oSnap/utils/validators.ts
new file mode 100644
index 00000000000..5c1ecacc5e1
--- /dev/null
+++ b/src/plugins/oSnap/utils/validators.ts
@@ -0,0 +1,70 @@
+import { isAddress } from '@ethersproject/address';
+import {
+ JsonRpcProvider,
+ StaticJsonRpcProvider
+} from '@ethersproject/providers';
+import memoize from 'lodash/memoize';
+import { Contract } from '@ethersproject/contracts';
+import { isBigNumberish } from '@ethersproject/bignumber/lib/bignumber';
+import { isHexString } from '@ethersproject/bytes';
+import getProvider from '@snapshot-labs/snapshot.js/src/utils/provider';
+import { OPTIMISTIC_GOVERNOR_ABI } from '../constants';
+import { BaseTransaction } from '../types';
+
+/**
+ * Validates that the given `address` is a valid Ethereum address
+ */
+export const mustBeEthereumAddress = memoize((address: string) => {
+ const startsWith0x = address?.startsWith('0x');
+ const isValidAddress = isAddress(address);
+ return startsWith0x && isValidAddress;
+});
+
+/**
+ * Validates that the given `address` is a valid Ethereum contract address
+ */
+export const mustBeEthereumContractAddress = memoize(
+ async (network: string, address: string) => {
+ const provider = getProvider(network) as JsonRpcProvider;
+ const contractCode = await provider.getCode(address);
+
+ return (
+ contractCode && contractCode.replace(/^0x/, '').replace(/0/g, '') !== ''
+ );
+ },
+ (url, contractAddress) => `${url}_${contractAddress}`
+);
+
+/**
+ * Validates a transaction.
+ */
+export function validateTransaction(transaction: BaseTransaction) {
+ const addressEmptyOrValidate =
+ transaction.to === '' || isAddress(transaction.to);
+ return (
+ isBigNumberish(transaction.value) &&
+ addressEmptyOrValidate &&
+ (!transaction.data || isHexString(transaction.data))
+ );
+}
+
+/**
+ * Validates a module address.
+ */
+export async function validateModuleAddress(
+ network: string,
+ moduleAddress: string
+): Promise {
+ if (!isAddress(moduleAddress)) return false;
+ const provider: StaticJsonRpcProvider = getProvider(network);
+ const moduleContract = new Contract(
+ moduleAddress,
+ OPTIMISTIC_GOVERNOR_ABI,
+ provider
+ );
+
+ return moduleContract
+ .rules()
+ .then(() => true)
+ .catch(() => false);
+}
diff --git a/src/views/SpaceCreate.vue b/src/views/SpaceCreate.vue
index 00c1d6f3f00..e5dea1b6b7f 100644
--- a/src/views/SpaceCreate.vue
+++ b/src/views/SpaceCreate.vue
@@ -1,10 +1,10 @@
-
diff --git a/src/composables/useTxStatus.ts b/src/composables/useTxStatus.ts
index 687a66d6cef..ed70db88333 100644
--- a/src/composables/useTxStatus.ts
+++ b/src/composables/useTxStatus.ts
@@ -15,14 +15,14 @@ export function useTxStatus() {
return pendingTransactions.value.filter(tx => tx.hash);
});
- const createPendingTransaction = () => {
+ const createPendingTransaction = (hash?: string) => {
const createdAt = Date.now();
const id = createdAt.toString();
const tx = {
id,
network: web3.value.network.key,
createdAt,
- hash: null
+ hash: hash ?? null
};
pendingTransactions.value.push(tx);
return id;
diff --git a/src/plugins/oSnap/Create.vue b/src/plugins/oSnap/Create.vue
new file mode 100644
index 00000000000..e040cd1f528
--- /dev/null
+++ b/src/plugins/oSnap/Create.vue
@@ -0,0 +1,300 @@
+
+
+
+
+
-
+
+
+
+
-
-
-
-
-
- {{ $t('snapshot') }}
-
-
-
-
+
+ {{ $t('snapshot') }}
+
+
+
+
+
+
+
+
+
+
-
+
>
+
+
-
-
-
-
-
-
-
-
-
-
-
-
- {{ `${element.text.length}/32` }}
-
-
-
-
-
-
+
+
+
+
+
+
+ {{ `${element.text.length}/32` }}
+
+
+
+
+
+
+
+
+
+
+
-
-
+
+
+
+ Warning: Legacy plugin detected
++ Using the oSnap plugin while the SafeSnap plugin is still installed on + your place will cause unexpected behavior. +
++ Please remove the SafeSnap plugin before using the oSnap plugin. +
+
+
+ Loading oSnap Safes
+
+
+ Loading oSnap Safes
+
+
+
+
+
diff --git a/src/plugins/oSnap/Proposal.vue b/src/plugins/oSnap/Proposal.vue
new file mode 100644
index 00000000000..7af5b1561f4
--- /dev/null
+++ b/src/plugins/oSnap/Proposal.vue
@@ -0,0 +1,134 @@
+
+
+
+
+ Warning: no treasuries
++ You have installed the oSnap plugin, but you don't have any + treasuries. +
++ Please add a Safe as a treasury and enable oSnap on it to use the + oSnap plugin. +
+ + +Warning: no oSnap safes found
++ You have installed the oSnap plugin, but you don't have any oSnap + safes. +
++ Please add a Safe as a treasury and enable oSnap on it to use the + oSnap plugin. +
+ + +Add oSnap transactions
+Pick a safe
+
+
+
+
+
+
+
+
+ oSnap Transactions
+
+
+
+
+
+ {{ key }}
+ {{ value }}
+
+
+
+ Transaction #{{ index + 1 }} — {{ type }}
+ +There are no transactions associated with this proposal.
+ + diff --git a/src/plugins/oSnap/README.md b/src/plugins/oSnap/README.md new file mode 100644 index 00000000000..d9065ad4246 --- /dev/null +++ b/src/plugins/oSnap/README.md @@ -0,0 +1,17 @@ +# oSnap Snapshot Plugin + +This is a Snapshot plugin that facilitates using the Optimistic Governor to execute a set of transactions. + +See https://docs.snapshot.org/user-guides/plugins for general info about Snapshot plugin development. + +## Terms + +There are some terms that can be confusing in this plugin, because they are used to mean different things in different contexts. + +* Proposal — in the context of a normal Snapshot vote, regardless of plugins, "Proposal" refers to the set of questions that gets submitted to Snapshot and presented to voters. In the context of the Optimistic Governor, "Proposal" refers to the set of transactions that are submitted to the Optimistic Governor contract to be executed. This can be confusing because a Snapshot "Proposal" that uses the oSnap plugin will itself have an Optimistic Governor "Proposal" for the transactions that it aims to execute. As far as possible we have prefixed Optimistic Governor proposals with "OG" in the code to avoid confusion. + +* Assertion — Optimistic Oracle V3 calls a piece of information that is asserted as true an "assertion". In the context of the Optimistic Governor, an assertion is made on the Optimistic Oracle which states that the specified set of transactions is valid and should be executed. Some key information about the Optimistic Governor proposal can only be found in the context of assertions, such as the assertion transaction hash and log index which are used to generate links to the Optimistic Oracle UI. + +* SafeSnap and oSnap — oSnap was originally part of the SafeSnap plugin, hence the similar names. SafeSnap uses the Reality oracle, while oSnap provides the option to use the Optimistic Oracle instead. Eventually it was decided that oSnap deserves to be its own plugin, and so it was split off from SafeSnap. However, for legacy support reasons, the oSnap functionality in the SafeSnap plugin is still available. + +* Votes — both Snapshot and the Optimistic Oracle use votes for their function. The _Snapshot_ vote takes place first in the context of oSnap. When creating a Snapshot Proposal with oSnap, the Snapshot vote takes place first. Only if the Snapshot vote passes can transactions be proposed to the Optimistic Governor. In fact, if the assertion for an Optimistic Governor proposal is disputed, the Optimistic Governor proposal is immediately deleted by the contract. This means that the Optimistic Oracle vote that proceeds from the dispute has no bearing on the Optimistic Governor proposal. The Optimistic Oracle vote is only used to determine whether the disputer or the proposer loses their bond. \ No newline at end of file diff --git a/src/plugins/oSnap/components/ExternalLink.vue b/src/plugins/oSnap/components/ExternalLink.vue new file mode 100644 index 00000000000..b8dc65c96a2 --- /dev/null +++ b/src/plugins/oSnap/components/ExternalLink.vue @@ -0,0 +1,35 @@ + + + + +
+ Connect your wallet to see execution details
+
+
+ Switch your wallet to {{ networkName }} to request execution
+
+
+
+
+
+
+
+
+
+
diff --git a/src/plugins/oSnap/components/HandleOutcome/steps/CanProposeToOG.vue b/src/plugins/oSnap/components/HandleOutcome/steps/CanProposeToOG.vue
new file mode 100644
index 00000000000..0db73643aa5
--- /dev/null
+++ b/src/plugins/oSnap/components/HandleOutcome/steps/CanProposeToOG.vue
@@ -0,0 +1,79 @@
+
+
+
+ Request transaction execution
+
+
+
+
+
+ Required bond:
+
+ {{ formatUnits(minimumBond, decimals) }} {{ symbol }}
+
+
+
+ Challenge period:
+
+ {{ formatDuration(challengePeriod) }}
+
+
+
+
+ Quorum did not reach space requirement
+
+
+ Your balance is less than the required bond
+
+
+
+
+ Approve bond
+
+
+
+ + On-chain proposals require a bond from the proposer. This will approve + tokens from your wallet to be posted as a bond. If you make an invalid + proposal, it will be disputed and you will lose your bond. If the proposal + is valid, your bond will be returned when the transactions are executed. +
+
+
+ Make assertion on Oracle
+
+
+
diff --git a/src/plugins/oSnap/components/HandleOutcome/steps/CanRequestTxExecution.vue b/src/plugins/oSnap/components/HandleOutcome/steps/CanRequestTxExecution.vue
new file mode 100644
index 00000000000..7b5e7ea0406
--- /dev/null
+++ b/src/plugins/oSnap/components/HandleOutcome/steps/CanRequestTxExecution.vue
@@ -0,0 +1,22 @@
+
+
+
+ + Warning: This proposal was disputed on-chain. Exercise caution when + proposing, because your proposal may be disputed too. +
+
+
+ Execute {{ transactionCount }} transaction{{
+ transactionCount > 1 ? 's' : ''
+ }}
+
+
+
diff --git a/src/plugins/oSnap/components/HandleOutcome/steps/InOOChallengePeriod.vue b/src/plugins/oSnap/components/HandleOutcome/steps/InOOChallengePeriod.vue
new file mode 100644
index 00000000000..7c8346775e2
--- /dev/null
+++ b/src/plugins/oSnap/components/HandleOutcome/steps/InOOChallengePeriod.vue
@@ -0,0 +1,34 @@
+
+
+
+
+ Transactions can be executed at
+ {{ expirationDateLocaleString }}
+
+
+
+
diff --git a/src/plugins/oSnap/components/HandleOutcome/steps/RejectedBySnapshotVote.vue b/src/plugins/oSnap/components/HandleOutcome/steps/RejectedBySnapshotVote.vue
new file mode 100644
index 00000000000..ec01047eafb
--- /dev/null
+++ b/src/plugins/oSnap/components/HandleOutcome/steps/RejectedBySnapshotVote.vue
@@ -0,0 +1,10 @@
+
+
+
+ + This will execute the transactions from this proposal and return the + asserter's bond. +
+
+
+
diff --git a/src/plugins/oSnap/components/HandleOutcome/steps/TallyingSnapshotVotes.vue b/src/plugins/oSnap/components/HandleOutcome/steps/TallyingSnapshotVotes.vue
new file mode 100644
index 00000000000..f4d5909be2c
--- /dev/null
+++ b/src/plugins/oSnap/components/HandleOutcome/steps/TallyingSnapshotVotes.vue
@@ -0,0 +1,7 @@
+
+
+
+ + Transactions cannot be executed because the Snapshot vote resolved as + "against". +
+
+
+
diff --git a/src/plugins/oSnap/components/HandleOutcome/steps/TransactionsExecuted.vue b/src/plugins/oSnap/components/HandleOutcome/steps/TransactionsExecuted.vue
new file mode 100644
index 00000000000..79d764302ff
--- /dev/null
+++ b/src/plugins/oSnap/components/HandleOutcome/steps/TransactionsExecuted.vue
@@ -0,0 +1,7 @@
+
+
+
+ Waiting for Snapshot vote counting to conclude.
+
+
+
diff --git a/src/plugins/oSnap/components/Input/Address.vue b/src/plugins/oSnap/components/Input/Address.vue
new file mode 100644
index 00000000000..99189b069a6
--- /dev/null
+++ b/src/plugins/oSnap/components/Input/Address.vue
@@ -0,0 +1,50 @@
+
+
+
+ All transactions have been executed
+
+
+
diff --git a/src/plugins/oSnap/components/Input/SelectSafe.vue b/src/plugins/oSnap/components/Input/SelectSafe.vue
new file mode 100644
index 00000000000..5717db43d23
--- /dev/null
+++ b/src/plugins/oSnap/components/Input/SelectSafe.vue
@@ -0,0 +1,36 @@
+
+
+
+
+
+
+
+
diff --git a/src/plugins/oSnap/components/Input/TransactionType.vue b/src/plugins/oSnap/components/Input/TransactionType.vue
new file mode 100644
index 00000000000..7cadab8c09d
--- /dev/null
+++ b/src/plugins/oSnap/components/Input/TransactionType.vue
@@ -0,0 +1,63 @@
+
+
+
+
+
+
+
+
diff --git a/src/plugins/oSnap/components/SafeLinkWithAvatar.vue b/src/plugins/oSnap/components/SafeLinkWithAvatar.vue
new file mode 100644
index 00000000000..d10b16086ba
--- /dev/null
+++ b/src/plugins/oSnap/components/SafeLinkWithAvatar.vue
@@ -0,0 +1,28 @@
+
+
+
+
+
+ {{ $t('safeSnap.value') }}
+
+
+
+ ABI
+
+
+
+
diff --git a/src/plugins/oSnap/components/TransactionBuilder/ModalSafe.vue b/src/plugins/oSnap/components/TransactionBuilder/ModalSafe.vue
new file mode 100644
index 00000000000..3b0ac9e1950
--- /dev/null
+++ b/src/plugins/oSnap/components/TransactionBuilder/ModalSafe.vue
@@ -0,0 +1,43 @@
+
+
+
+
+
+ function
+
+
+
+
+
+
+
+
+ Select Safe
+ +
+
+
+ Select transaction type
+ +
+
+
+
+
+ {{ $t('safeSnap.value') }}
+
+
+
+ {{ $t('safeSnap.data') }}
+
+
+
diff --git a/src/plugins/oSnap/components/TransactionBuilder/TokensModal.vue b/src/plugins/oSnap/components/TransactionBuilder/TokensModal.vue
new file mode 100644
index 00000000000..52375acc4e6
--- /dev/null
+++ b/src/plugins/oSnap/components/TransactionBuilder/TokensModal.vue
@@ -0,0 +1,150 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Assets
++ Filters +
+
+
+
+
+
+
+
+
+
+
+
+ {{ $t('noResultsFound') }}
+
+
+
+
diff --git a/src/plugins/oSnap/components/TransactionBuilder/TransactionBuilder.vue b/src/plugins/oSnap/components/TransactionBuilder/TransactionBuilder.vue
new file mode 100644
index 00000000000..622d55df811
--- /dev/null
+++ b/src/plugins/oSnap/components/TransactionBuilder/TransactionBuilder.vue
@@ -0,0 +1,83 @@
+
+
+
+
+
+ + Transaction {{ transactionIndex + 1 }} +
+ +
+ Safe app link
+ {{ shorten(safeAddress) }}
+
+ Module address{{ + shorten(moduleAddress) + }} +
++ Number of transactions{{ transactions.length }} +
+
+
+
+
+ {{ $t('safeSnap.asset') }}
+
+
+
+
+