@wireio/stake 0.0.1

package/src/assets/solana/types/validator_registry.ts

@@ -0,0 +1,424 @@
+/**
+ * Program IDL in camelCase format in order to be used in JS/TS.
+ *
+ * Note that this is only a type helper and is not the actual IDL. The original
+ * IDL can be found at `target/idl/validator_registry.json`.
+ */
+export type ValidatorRegistry = {
+  "address": "DqaNZkyhg6ASSkut8tyQGjwMtv35Yj5rA9JZvzmzZb3e",
+  "metadata": {
+    "name": "validatorRegistry",
+    "version": "0.1.0",
+    "spec": "0.1.0",
+    "description": "Created with Anchor"
+  },
+  "instructions": [
+    {
+      "name": "addValidator",
+      "discriminator": [
+        250,
+        113,
+        53,
+        54,
+        141,
+        117,
+        215,
+        185
+      ],
+      "accounts": [
+        {
+          "name": "authority",
+          "signer": true
+        },
+        {
+          "name": "validatorRegistry",
+          "writable": true
+        }
+      ],
+      "args": [
+        {
+          "name": "voteAccount",
+          "type": "pubkey"
+        },
+        {
+          "name": "name",
+          "type": "string"
+        },
+        {
+          "name": "performanceScore",
+          "type": "u32"
+        }
+      ]
+    },
+    {
+      "name": "getValidators",
+      "discriminator": [
+        74,
+        81,
+        116,
+        129,
+        224,
+        19,
+        17,
+        238
+      ],
+      "accounts": [
+        {
+          "name": "validatorRegistry"
+        }
+      ],
+      "args": []
+    },
+    {
+      "name": "initialize",
+      "discriminator": [
+        175,
+        175,
+        109,
+        31,
+        13,
+        152,
+        155,
+        237
+      ],
+      "accounts": [
+        {
+          "name": "payer",
+          "writable": true,
+          "signer": true
+        },
+        {
+          "name": "validatorRegistry",
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  118,
+                  97,
+                  108,
+                  105,
+                  100,
+                  97,
+                  116,
+                  111,
+                  114,
+                  95,
+                  114,
+                  101,
+                  103,
+                  105,
+                  115,
+                  116,
+                  114,
+                  121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          "name": "systemProgram",
+          "address": "11111111111111111111111111111111"
+        }
+      ],
+      "args": [
+        {
+          "name": "authority",
+          "type": "pubkey"
+        }
+      ]
+    },
+    {
+      "name": "syncValidatorsFromChain",
+      "discriminator": [
+        247,
+        11,
+        19,
+        18,
+        37,
+        20,
+        245,
+        232
+      ],
+      "accounts": [
+        {
+          "name": "authority",
+          "signer": true
+        },
+        {
+          "name": "validatorRegistry",
+          "writable": true
+        },
+        {
+          "name": "stakeControllerProgram"
+        }
+      ],
+      "args": [
+        {
+          "name": "voteAccounts",
+          "type": {
+            "vec": "pubkey"
+          }
+        },
+        {
+          "name": "validatorMetrics",
+          "type": {
+            "vec": {
+              "defined": {
+                "name": "validatorMetrics"
+              }
+            }
+          }
+        }
+      ]
+    },
+    {
+      "name": "updatePerformance",
+      "discriminator": [
+        11,
+        251,
+        66,
+        148,
+        20,
+        86,
+        149,
+        20
+      ],
+      "accounts": [
+        {
+          "name": "authority",
+          "signer": true
+        },
+        {
+          "name": "validatorRegistry",
+          "writable": true
+        }
+      ],
+      "args": [
+        {
+          "name": "voteAccount",
+          "type": "pubkey"
+        },
+        {
+          "name": "performanceScore",
+          "type": "u32"
+        },
+        {
+          "name": "activeStake",
+          "type": "u64"
+        },
+        {
+          "name": "commission",
+          "type": "u64"
+        }
+      ]
+    }
+  ],
+  "accounts": [
+    {
+      "name": "validatorRegistry",
+      "discriminator": [
+        168,
+        113,
+        195,
+        186,
+        62,
+        121,
+        163,
+        230
+      ]
+    }
+  ],
+  "events": [
+    {
+      "name": "validatorsSyncedEvent",
+      "discriminator": [
+        119,
+        121,
+        49,
+        120,
+        230,
+        132,
+        109,
+        214
+      ]
+    }
+  ],
+  "errors": [
+    {
+      "code": 6000,
+      "name": "unauthorized",
+      "msg": "Unauthorized access"
+    },
+    {
+      "code": 6001,
+      "name": "maxValidatorsReached",
+      "msg": "Maximum validators reached"
+    },
+    {
+      "code": 6002,
+      "name": "validatorAlreadyExists",
+      "msg": "Validator already exists"
+    },
+    {
+      "code": 6003,
+      "name": "validatorNotFound",
+      "msg": "Validator not found"
+    },
+    {
+      "code": 6004,
+      "name": "invalidStakeUpdateType",
+      "msg": "Invalid stake update type"
+    },
+    {
+      "code": 6005,
+      "name": "invalidVoteAccount",
+      "msg": "Invalid vote account provided"
+    },
+    {
+      "code": 6006,
+      "name": "invalidInputLength",
+      "msg": "Invalid input length - all vectors must have same length"
+    },
+    {
+      "code": 6007,
+      "name": "invalidStakeAccount",
+      "msg": "Invalid Stake Account"
+    }
+  ],
+  "types": [
+    {
+      "name": "validatorInfo",
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "voteAccount",
+            "type": "pubkey"
+          },
+          {
+            "name": "name",
+            "type": {
+              "array": [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            "name": "performanceScore",
+            "type": "u32"
+          },
+          {
+            "name": "activeStake",
+            "type": "u64"
+          },
+          {
+            "name": "activatingStake",
+            "type": "u64"
+          },
+          {
+            "name": "deactivatingStake",
+            "type": "u64"
+          },
+          {
+            "name": "commission",
+            "type": "u64"
+          },
+          {
+            "name": "lastUpdatedEpoch",
+            "type": "u64"
+          },
+          {
+            "name": "initialStake",
+            "type": "u64"
+          },
+          {
+            "name": "previousEpochActiveStake",
+            "type": "u64"
+          },
+          {
+            "name": "previousEpochSnapshot",
+            "type": "u64"
+          }
+        ]
+      }
+    },
+    {
+      "name": "validatorMetrics",
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "commission",
+            "type": "u8"
+          },
+          {
+            "name": "skipRateBps",
+            "type": "u32"
+          },
+          {
+            "name": "isDelinquent",
+            "type": "bool"
+          },
+          {
+            "name": "activatedStake",
+            "type": "u64"
+          }
+        ]
+      }
+    },
+    {
+      "name": "validatorRegistry",
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "authority",
+            "type": "pubkey"
+          },
+          {
+            "name": "validators",
+            "type": {
+              "vec": {
+                "defined": {
+                  "name": "validatorInfo"
+                }
+              }
+            }
+          },
+          {
+            "name": "lastUpdateEpoch",
+            "type": "u64"
+          },
+          {
+            "name": "bump",
+            "type": "u8"
+          }
+        ]
+      }
+    },
+    {
+      "name": "validatorsSyncedEvent",
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "updatedCount",
+            "type": "u32"
+          },
+          {
+            "name": "notFoundCount",
+            "type": "u32"
+          },
+          {
+            "name": "epoch",
+            "type": "u64"
+          }
+        ]
+      }
+    }
+  ]
+};

package/src/assets/solana/types/yield_oracle.ts

@@ -0,0 +1,38 @@
+/**
+ * Program IDL in camelCase format in order to be used in JS/TS.
+ *
+ * Note that this is only a type helper and is not the actual IDL. The original
+ * IDL can be found at `target/idl/yield_oracle.json`.
+ */
+export type YieldOracle = {
+  "address": "ABMUzgJCoJ17WPYvxZg4Biuo5oCaEbuD4svUVGFBTWCz",
+  "metadata": {
+    "name": "yieldOracle",
+    "version": "0.1.0",
+    "spec": "0.1.0",
+    "description": "Created with Anchor"
+  },
+  "instructions": [
+    {
+      "name": "calculateYieldPerSol",
+      "discriminator": [
+        51,
+        25,
+        150,
+        38,
+        173,
+        32,
+        27,
+        202
+      ],
+      "accounts": [
+        {
+          "name": "systemProgram",
+          "address": "11111111111111111111111111111111"
+        }
+      ],
+      "args": [],
+      "returns": "u64"
+    }
+  ]
+};

package/src/index.ts

@@ -0,0 +1,21 @@
+// Export all utilities from the utils module
+export * from './utils';
+
+// Staker utilities
+export * from './staker/staker';
+export * from './staker/types';
+
+// NETWORKS
+
+// Ethereum
+export * from './networks/ethereum/ethereum';
+export * from './networks/ethereum/contract';
+export * as ETH from './networks/ethereum/types';
+
+export * from './networks/solana/solana';
+export * from './networks/solana/constants';
+export * from './networks/solana/utils';
+
+export * from './networks/solana/clients/deposit.client';
+export * from './networks/solana/clients/distribution.client';
+export * from './networks/solana/clients/leaderboard.client';

package/src/networks/ethereum/contract.ts

@@ -0,0 +1,167 @@
+/**
+ * @module EthereumContractService
+ * 
+ * Provides a unified service for interacting with Ethereum smart contracts using ethers.js.
+ * 
+ * This module includes:
+ * - ABI imports for ERC20, ERC721, and ERC1155 token standards.
+ * - Address book and contract configuration types.
+ * - A service class for managing contract instances, interfaces, and utility methods for read/write access.
+ * - Utility for decoding custom errors and events using a combined interface of all known ABIs.
+ * 
+ * @remarks
+ * - Update the `ADDRESSES` and `CONTRACTS` objects to match your deployment.
+ * - The service supports both read-only and write-enabled contract handles, depending on the presence of a signer.
+ * - The `omniInterface` property allows decoding of errors and events across all included ABIs.
+ * 
+ * @example
+ * ```typescript
+ * const service = new EthereumContractService({ provider, signer });
+ * const stakeContract = service.getContract('Stake');
+ * const address = service.getAddress('Stake');
+ * ```
+ */
+
+import ERC20Artifact from '../../assets/ethereum/ABI/token/ERC20Token.sol/ERC20Token.json';
+import ERC721Artifact from '../../assets/ethereum/ABI/token/ERC721Token.sol/ERC721Token.json';
+import ERC1155Artifact from '../../assets/ethereum/ABI/token/ERC1155Token.sol/ERC1155Token.json';
+import { AddressBook, ContractName } from './types';
+import { Contract, ethers, providers, Signer } from 'ethers';
+import { JsonFragment } from '@ethersproject/abi';
+import { ErrorDescription } from '@ethersproject/abi/lib/interface';
+
+export const ERC20Abi = ERC20Artifact.abi;
+export const ERC721Abi = ERC721Artifact.abi;
+export const ERC1155Abi = ERC1155Artifact.abi;
+
+// Update this to be your staking contract address book
+export const ADDRESSES: AddressBook = {
+    Stake: '0xEeaCBa95852324eAc63fE2711aFe0283adf3bC93',
+};
+
+export type Contracts<T extends string = ContractName> = Record<T, ContractConfig>;
+
+export type ContractConfig = {
+    address: string;
+    abi: JsonFragment[];
+}
+
+export const CONTRACTS: Contracts<ContractName> = {
+    Stake: { address: ADDRESSES.Stake, abi: undefined as any }, // Replace with actual ABI artifact when available
+    // Stake: { address: ADDRESSES.Stake, abi: Stake.abi },
+}
+
+export interface ContractOptions {
+    /** RPC endpoint or injected EIP-1193 provider */
+    provider?: ethers.providers.Provider;
+    /** Only required if you need to send txns */
+    signer?: Signer;
+}
+
+
+export class EthereumContractService {
+    private provider?: providers.Provider;
+    private signer?: Signer;
+
+    public readonly contract: { [N in ContractName]: ethers.Contract } = {} as any;
+    public readonly iface: { [N in ContractName]: ethers.utils.Interface } = {} as any;
+
+    constructor(opts: ContractOptions) {
+        this.provider = opts.provider;
+        this.signer = opts.signer;
+
+        (Object.keys(CONTRACTS) as ContractName[]).forEach((name) => {
+            const { address, abi } = CONTRACTS[name];
+            this.iface[name] = new ethers.utils.Interface(abi);
+            this.contract[name] = new ethers.Contract(address, abi, this.signer ?? this.provider);
+        });
+    }
+
+    /** Get raw address for a contract */
+    public getAddress(name: ContractName): string {
+        return CONTRACTS[name].address;
+    }
+
+    /** Utility: get a read-only handle even if signer is present */
+    getReadOnly(name: ContractName): Contract {
+        const { address, abi } = CONTRACTS[name];
+        return new Contract(address, abi, this.provider);
+    }
+
+    /** Utility: get a write-enabled handle (throws if no signer) */
+    getWrite(name: ContractName): Contract {
+        if (!this.signer) throw new Error('No signer available for write calls');
+        const { address, abi } = CONTRACTS[name];
+        return new Contract(address, abi, this.signer);
+    }
+
+    /** Expose network info */
+    async getNetwork() {
+        return this.provider?.getNetwork();
+    }
+
+    /** List all known contract names */
+    public listContractNames(): ContractName[] {
+        return Object.keys(CONTRACTS) as ContractName[];
+    }
+
+    /** Get Interface instance for a contract */
+    public getInterface(name: ContractName): ethers.utils.Interface {
+        const iface = this.iface[name];
+        if (!iface) throw new Error(`Interface not initialized for ${name}`);
+        return iface;
+    }
+
+    /** Get live Contract instance */
+    public getContract(name: ContractName): ethers.Contract {
+        const ctr = this.contract[name];
+        if (!ctr) throw new Error(`Contract not initialized for ${name}`);
+        return ctr;
+    }
+
+    /** A unified Interface containing all ABIs (addresses + extra decoding-only)
+     *  to parse custom errors or events. */
+    public get omniInterface(): ethers.utils.Interface {
+        const all: any[] = [];
+
+        // Add all artifacts to the interface
+        const allArtifacts = [
+            ERC20Artifact,
+            ERC721Artifact,
+            ERC1155Artifact,
+            // Add more artifacts as needed
+        ];
+
+        // Add all ABIs to the omnibus interface
+        allArtifacts.forEach(artifact => {
+            if (artifact && artifact.abi) {
+                all.push(...artifact.abi);
+            }
+        });
+
+        // dedupe
+        const seen = new Set<string>();
+        const dedup: any[] = [];
+        for (const item of all) {
+            try {
+                const frag = ethers.utils.Fragment.from(item);
+                const key = `${frag.type}:${frag.format(ethers.utils.FormatTypes.full)}`.toLowerCase();
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    dedup.push(item);
+                }
+            } catch { }
+        }
+
+        return new ethers.utils.Interface(dedup);
+    }
+
+    /** Decode a revert or custom error payload */
+    public parseError(revertData: string): ErrorDescription {
+        try {
+            return this.omniInterface.parseError(revertData);
+        } catch {
+            throw new Error(`Unable to parse error data: ${revertData}`);
+        }
+    }
+}

package/src/networks/ethereum/ethereum.ts

@@ -0,0 +1,64 @@
+// src/networks/ethereum/ethereum.ts
+
+import { ethers } from 'ethers';
+import { IStakingClient, StakerConfig } from '../../staker/types';
+import { PublicKey as WirePubKey } from '@wireio/core';
+import { ERC20Abi } from './contract'; // TODO replace with staking contract ABI
+import axios from 'axios';
+
+// — replace with your actual staking contract ABI & address —
+const STAKING_CONTRACT_ADDRESS = '0xYourStakingContractAddress';
+
+export class EthereumStakingClient implements IStakingClient {
+    public readonly pubKey: WirePubKey;
+    private readonly provider: ethers.providers.Web3Provider;
+    private readonly signer: ethers.Signer;
+    private readonly contract: ethers.Contract;
+
+    constructor(private config: StakerConfig) {
+        // 1) unwrap & validate Ethers provider
+        if (!ethers.providers.Web3Provider.isProvider(config.provider as any)) {
+            throw new Error('Expected a Web3Provider for Ethereum');
+        }
+        this.provider = config.provider as ethers.providers.Web3Provider;
+
+        // 2) signer
+        this.signer = this.provider.getSigner();
+        this.pubKey = config.pubKey as WirePubKey;
+
+        // 4) instantiate your contract wrapper
+        this.contract = new ethers.Contract(
+            STAKING_CONTRACT_ADDRESS,
+            ERC20Abi,
+            this.signer
+        );
+    }
+
+    /** Submit a deposit; returns the transaction hash */
+    async deposit(amount: number): Promise<string> {
+        // build & send in one go
+        const txResponse = await this.contract.deposit(
+            ethers.BigNumber.from(amount),
+            {
+                // if your contract needs ETH value:
+                // value: ethers.BigNumber.from(amount),
+            }
+        );
+
+        // wait for on-chain confirmation (optional)
+        await txResponse.wait();
+        return txResponse.hash;
+    }
+
+    /** (Optional) dry-run via eth_call */
+    async simulateDeposit(amount: number): Promise<any> {
+        return this.provider.call({
+            to: STAKING_CONTRACT_ADDRESS,
+            data: this.contract.interface.encodeFunctionData('deposit', [
+                ethers.BigNumber.from(amount)
+            ]),
+        });
+    }
+
+    // TODO: implement withdraw, claimRewards, etc.
+}