Organigram JS

Organigram JS est le client JavaScript/TypeScript du Protocole Organigram, une suite de smart contracts pour faire fonctionner des organisations sur les blockchains compatibles Ethereum. Il déploie, lit et opère ces contrats depuis n'importe quel environnement JavaScript, navigateur ou Node.js, et c'est la bibliothèque utilisée en interne par Organigram.ai et par @organigram/react.

Installation

viem est une dépendance pair : Organigram JS ne détient jamais de clés lui-même, il utilise les clients viem que vous lui fournissez.

Comment ça marche

Une organisation est modélisée comme un organigramme : des organes reliés par des procédures, détenant éventuellement des actifs. Chacun d'eux est un smart contract, et chacun a dans cette bibliothèque une classe qui charge son état on-chain, y écrit et le sérialise en JSON.

Le client

OrganigramClient.load() se connecte au contrat OrganigramClient déployé sur la chaîne de votre client public viem, et lit les types de procédures qui y sont enregistrés. Le client public sert à toutes les lectures ; le client de portefeuille, s'il est fourni, signe les transactions. Sans client de portefeuille, la bibliothèque est en lecture seule.

Le client garde en mémoire les organes, procédures et actifs chargés : loadOrgan(), loadProcedure() et loadAsset() renvoient l'objet en cache, sauf si vous passez { fresh: true }.

Organes et permissions

Un organe stocke trois choses :

• entrées : chacune est une adresse Ethereum (un membre), une référence de contenu (un document), ou les deux ;
• permissions : les adresses autorisées à agir sur l'organe, sous forme de champ de bits issu de PERMISSIONS (ADD_ENTRIES, WITHDRAW_ETHER, ADD_PERMISSIONS…). getPermissionsSet() retraduit une valeur en noms ;
• actifs : de l'ether et des jetons ERC-20, que seules les adresses ayant la permission correspondante peuvent retirer.

Dans une organisation gouvernée, les permissions sont accordées aux procédures plutôt qu'aux personnes, afin que tout changement passe par une décision.

Propositions et décisions

Une procédure définit trois rôles, chacun tenu par les membres d'un organe (ou, pour un vote ERC-20, par les détenteurs du jeton) : les proposants qui peuvent soumettre des propositions, les modérateurs qui peuvent les filtrer lorsque la modération est activée, et les décideurs qui les adoptent ou les rejettent. Une proposition est une liste d'opérations, des appels aux organes que la procédure a la permission d'effectuer, accompagnée d'une référence à ses métadonnées off-chain.

1. propose() soumet la proposition.
2. Avec modération, un modérateur l'accepte avec presentProposal() ou la rejette avec blockProposal().
3. Les décideurs tranchent : nominate() ou reject() pour une nomination, vote() puis count() une fois le vote terminé pour les procédures de vote.
4. L'adoption exécute les opérations sur les organes cibles. applyProposal() relance les opérations qui n'ont pas encore été traitées.

Chaque écriture existe aussi en variante …BySig : l'utilisateur signe un message EIP-712 et n'importe quel relais le soumet, si bien que les utilisateurs n'ont pas besoin de gas.

Déployer un organigramme

organigram.deploy() déploie organes, actifs et procédures en une seule transaction, puis les recharge depuis la chaîne. En interne, elle appelle client.deployOrganigram(), que vous pouvez appeler directement si vous n'avez besoin que des nouvelles adresses. Les contrats sont déployés comme des clones à des adresses prédites à partir d'un sel, ce qui permet à un brouillon de référencer des contrats qui n'existent pas encore, par exemple une procédure décidant d'un organe déployé dans le même lot. templates fournit des organigrammes prêts à l'emploi (sas, sarl, nonProfit, openSource…), et isTemplateSupportedOnChain() indique si une chaîne dispose des contrats dont un modèle a besoin.

Stockage off-chain

Les contrats ne stockent que des références. Les métadonnées et les documents vivent off-chain et sont référencés par des références CID de la forme og://workspace/<workspace>/<key>, construites avec formatCidRef() et lues avec parseCidRef(). Les propositions doivent porter une telle référence.

Les fonctions de chiffrement (generateUserEncryptionKeyPair, wrapGroupKeyForRecipient, encryptBytes…) implémentent le chiffrement de bout en bout des documents utilisé par Organigram.ai : les clés de contenu chiffrent les documents, les clés de groupe enveloppent les clés de contenu, et la paire de clés de chaque membre désenveloppe les clés de groupe. Elles s'exécutent sur la Web Crypto API de l'appareil de l'utilisateur. Gardez-y les clés privées : ne les envoyez jamais à un serveur, ne les journalisez jamais, et ne les exportez que vers un stockage que vous chiffrez vous-même.

Utilisation

Se connecter au protocole avec un portefeuille de navigateur :

Déployer une organisation à partir d'un modèle :

Proposer d'ajouter un membre à un organe, puis adopter la proposition via une procédure de nomination :

La procédure doit détenir la permission ADD_ENTRIES sur l'organe, et le compte connecté doit faire partie de ses proposants et de ses décideurs.

Contribuer

Nous recherchons des développeurs et testeurs TypeScript pour garder ce projet sûr et à jour. Ouvrez des tickets sur GitHub, forkez le dépôt et envoyez des pull requests.

Client

Tout commence par un OrganigramClient, connecté au protocole sur une chaîne via deux clients viem : un client public pour lire, et un client de portefeuille pour signer. Sans client de portefeuille, la bibliothèque est en lecture seule. Le client déploie des contrats, les charge et garde en cache ce qu'il a chargé, jusqu'à ce que vous demandiez une lecture fresh . Chaque écriture accepte des TransactionOptions, pour suivre une transaction dès son envoi.

OrganigramClient

Definition

constructor(input: {

publicClient: PublicClient;

address?: string;

chainId?: string;

procedureTypes?: ProcedureType[];

contract?: OrganigramContract;

walletClient?: WalletClient;

});

OrganigramClient.deployAsset

Déployer un seul clone d'actif ERC-20.

Signature

deployAsset(input: {

name: string;

symbol: string;

initialSupply?: number;

salt?: string;

options?: TransactionOptions;

}): Promise<string>;

Paramètres

Nom	Type	Description
input	{ name: string; symbol: string; initialSupply?: number; salt?: string; options?: TransactionOptions; }	Nom et symbole du jeton, offre en jetons entiers avant conversion en wei, sel de clone déterministe facultatif et options de transaction.

Retourne

Type	Description
Promise<string>	L'adresse du contrat d'actif déployé.

OrganigramClient.deployAssets

Déployer plusieurs actifs en une seule transaction de lot.

Signature

deployAssets(assets: AssetInput[], options?: TransactionOptions): Promise<string[]>;

Paramètres

Nom	Type	Description
assets	AssetInput[]	Actifs à déployer.
options	TransactionOptions	Contrôles transactionnels optionnels.

Retourne

Type	Description
Promise<string[]>	Les adresses des actifs déployés dans l'ordre de déploiement.

OrganigramClient.deployClient

Déployer un contrat client Organigram frais avec sa bibliothèque liée.

Signature

static deployClient(input: {

publicClient: PublicClient;

walletClient: WalletClient;

}): Promise<OrganigramClient>;

Paramètres

Nom	Type	Description
input	{ publicClient: PublicClient; walletClient: WalletClient; }	Les clients sont utilisés pour diffuser les déploiements et attendre les reçus.

Retourne

Type	Description
Promise<OrganigramClient>	Une instance SDK prête à l'emploi pointant vers le nouveau client déployé.

OrganigramClient.deployOrgan

Déployer un seul clone d'organe et hydrater l'objet SDK résultant.

Lorsque aucun droit n'est fourni, le portefeuille connecté est octroyé le masque d'administrateur complet par défaut, de sorte que l'organe reste opérationnel après le déploiement.

Signature

deployOrgan(input?: DeployOrganInput): Promise<Organ>;

Paramètres

Nom	Type	Description
input	DeployOrganInput	Métadonnées de l'organe optionnelles, droits, entrées et options de transaction.

OrganigramClient.deployOrganigram

Déployer un organigramme complet, y compris ses organes, actifs et procédures.

Signature

deployOrganigram(input: DeployOrganigramInput): Promise<DeployOrganigramResult>;

Paramètres

Nom	Type	Description
input	DeployOrganigramInput	Entrée de déploiement par lots pour l'ensemble de l'organigramme.

Retourne

Type	Description
Promise<DeployOrganigramResult>	Les adresses des organes, actifs et procédures déployés, et l'entrée mise à jour avec celles-ci. Utilisez Organigram.deploy() pour obtenir un Organigram.

OrganigramClient.deployOrgans

Déployer plusieurs organes dans une seule transaction par lot.

Signature

deployOrgans(deployOrgansInput: DeployOrganInput[]): Promise<Organ[]>;

Paramètres

Nom	Type	Description
deployOrgansInput	DeployOrganInput[]	Définitions d'organes à déployer.

OrganigramClient.deployProcedure

Déployer un clone de procédure unique à partir d'un type de procédure enregistré.

Signature

deployProcedure(input: DeployProcedureInput): Promise<Procedure>;

Paramètres

Nom	Type	Description
input	DeployProcedureInput	Type de procédure, organes de rôle, métadonnées optionnelles et arguments d'initialisation.

OrganigramClient.deployProcedures

Déployer plusieurs procédures dans une seule transaction batch.

Signature

deployProcedures(deployProceduresInput: DeployProcedureInput[]): Promise<Procedure[]>;

Paramètres

Nom	Type	Description
deployProceduresInput	DeployProcedureInput[]	Définitions des procédures à déployer.

OrganigramClient.estimateDeployOrganigramGas

Estimer le gas qu'utiliserait le déploiement complet d'un organigramme, sans portefeuille.

Signature

estimateDeployOrganigramGas(input: DeployOrganigramInput, account: string): Promise<bigint>;

Paramètres

Nom	Type	Description
input	DeployOrganigramInput	Entrée de déploiement par lots pour l'ensemble de l'organigramme.
account	string	Adresse depuis laquelle le déploiement serait envoyé.

Retourne

Type	Description
Promise<bigint>	Le gas estimé, ou 0n s'il ne reste rien à déployer.

OrganigramClient.getProcedureType

Inférer le type de procédure enregistré d'une copie de procédure déployée.

Signature

getProcedureType(procedureAddress: string): Promise<ProcedureType | null>;

Paramètres

Nom	Type	Description
procedureAddress	string	Adresse de l'instance de procédure déployée.

OrganigramClient.load

Connecter l'SDK à un contrat client Organigram déjà déployé.

Signature

static load(input: {

address?: string;

publicClient: PublicClient;

walletClient?: WalletClient;

}): Promise<OrganigramClient>;

Paramètres

Nom	Type	Description
input	{ address?: string; publicClient: PublicClient; walletClient?: WalletClient; }	Surcharge d'adresse plus les clients viem utilisés pour les lectures et les écritures.

OrganigramClient.loadAsset

Charger un actif déployé et le garder dans le cache du client.

Signature

loadAsset(address: string, input?: {

fresh?: boolean;

initial?: Asset;

}): Promise<Asset>;

Paramètres

Nom	Type	Description
address	string	Adresse du contrat de l'actif.
input	{ fresh?: boolean; initial?: Asset; }	fresh lit la chaîne même si l'actif est en cache ; initial contient des métadonnées de repli fusionnées dans l'actif chargé.

OrganigramClient.loadContract

Tenter de charger un contrat déployé comme un organe ou une procédure.

Signature

loadContract(address: string, input?: {

fresh?: boolean;

}): Promise<Organ | Procedure | null>;

Paramètres

Nom	Type	Description
address	string	Adresse du contrat à inspecter.
input	{ fresh?: boolean; }	fresh lit la chaîne même si le contrat est en cache.

OrganigramClient.loadContracts

Charger une liste hétérogène d'adresses de contrats déployés dans un organigramme.

Signature

loadContracts(contractAddresses: string[]): Promise<Organigram>;

Paramètres

Nom	Type	Description
contractAddresses	string[]	Adresses à résoudre en tant qu'organes, procédures ou actifs.

OrganigramClient.loadOrgan

Charger un organe déployé et le garder dans le cache du client.

Signature

loadOrgan(address: string, input?: {

fresh?: boolean;

initial?: OrganInput;

}): Promise<Organ>;

Paramètres

Nom	Type	Description
address	string	Adresse du contrat d'organe.
input	{ fresh?: boolean; initial?: OrganInput; }	fresh lit la chaîne même si l'organe est en cache ; initial contient des métadonnées de repli fusionnées dans l'organe chargé.

OrganigramClient.loadOrganigram

Hydrater chaque objet déployé référencé par une définition d'organigramme.

Les placeholders non déployés sont conservés tels quels, tandis que les organes, procédures et actifs déployés sont rafraîchis à partir de l'état de la chaîne.

Signature

loadOrganigram(organigram: Organigram, input?: {

fresh?: boolean;

}): Promise<Organigram>;

Paramètres

Nom	Type	Description
organigram	Organigram	Définition de l'organigramme à hydrater.
input	{ fresh?: boolean; }	fresh: false réutilise les organes, procédures et actifs déjà dans le cache du client au lieu de les relire.

OrganigramClient.loadProcedure

Charger une procédure déployée et la garder dans le cache du client.

Signature

loadProcedure(address: string, input?: {

fresh?: boolean;

initial?: ProcedureInput;

}): Promise<Procedure>;

Paramètres

Nom	Type	Description
address	string	Adresse du contrat de procédure.
input	{ fresh?: boolean; initial?: ProcedureInput; }	fresh lit la chaîne même si la procédure est en cache ; initial contient des métadonnées de repli fusionnées dans la procédure chargée.

OrganigramClient.loadProcedureType

Charger les métadonnées pour une implémentation déployée d'une procédure.

Signature

static loadProcedureType(input: {

addr: string;

cid?: string;

}, publicClient: PublicClient): Promise<ProcedureType>;

Paramètres

Nom	Type	Description
input	{ addr: string; cid?: string; }	Adresse et CID optionnel utilisés pour identifier le type de procédure.
publicClient	PublicClient	Client en lecture seule utilisé pour les vérifications d'interface.

OrganigramClient.loadProcedureTypes

Lisez le registre des procédures et résolvez chaque type de procédure pris en charge.

Signature

static loadProcedureTypes(input: {

publicClient: PublicClient;

address?: string;

}): Promise<ProcedureType[]>;

Paramètres

Nom	Type	Description
input	{ publicClient: PublicClient; address?: string; }	Adresse du contrat client optionnelle et le client public utilisé pour l'interroger.

DeployOrganigramInput

TransactionOptions

TransactionOptions.onTransaction

Appelé avec la transaction dès son envoi, avant qu'elle soit minée.

Signature

onTransaction?: (tx: OrganigramTransaction, description: string) => void;

DeployOrganInput

Definition

export type DeployOrganInput = OrganInput & {

options?: TransactionOptions;

};

DeployProcedureInput

Definition

export type DeployProcedureInput = ProcedureInput & {

typeName: ProcedureTypeName;

options?: TransactionOptions;

args?: unknown[];

};

DeployOrganigramResult

Definition

export type DeployOrganigramResult = readonly [

organs: string[],

assets: string[],

procedures: string[]

] & {

organigram: DeployOrganigramInput;

};

ContractClients

Definition

export type ContractClients = {

publicClient: PublicClient;

walletClient?: WalletClient | null;

};

OrganigramContract

Definition

export type OrganigramContract = GetContractReturnType<Abi, PublicClient | {

public: PublicClient;

wallet: WalletClient;

}>;

OrganigramTransaction

Definition

export type OrganigramTransaction = {

hash: Hex;

wait: () => Promise<OrganigramTransactionReceipt>;

};

OrganigramTransactionReceipt

Definition

export type OrganigramTransactionReceipt = TransactionReceipt & {

gasPrice?: bigint | null;

};

bufferEstimatedGas

Signature

bufferEstimatedGas: (estimatedGas: bigint) => bigint

createContractWriteTransaction

Signature

createContractWriteTransaction: <TAbi extends Abi | readonly unknown[]>(input: {

address: string;

abi: TAbi;

functionName: string;

args?: unknown[];

clients: ContractClients;

nonce?: number;

value?: bigint;

}) => Promise<OrganigramTransaction>

getWalletAddress

Signature

getWalletAddress: (walletClient: WalletClient) => Promise<Address>

Organigrammes et modèles

Un Organigram rassemble les organes, procédures et actifs d'une organisation. Partez d'un modèle avec getTemplate(), ou de vos propres données, attachez un client, et déployez le tout en une transaction avec organigram.deploy(). Les contrats sont des clones à des adresses prédites à partir d'un sel, si bien qu'un brouillon peut référencer des contrats qui n'existent pas encore.

Organigram

L'organigramme lui-même n'a pas de contrat. Créez-en un à partir d'un modèle ou de données, attachez un OrganigramClient, puis appelez deploy().

Definition

constructor(input?: OrganigramInput | keyof typeof templates | string[]);

Organigram.deploy

Déployer tous les contrats de l'organigramme en une transaction, puis les relire depuis la chaîne.

Nécessite un organigramClient attaché avec un client de portefeuille.

Signature

deploy(): Promise<Organigram>;

Organigram.editDetails

Modifier le nom, la description ou la disposition du diagramme.

Signature

editDetails(input: {

name?: string;

description?: string;

edgeType?: OrganigramEdgeType;

nodePositions?: OrganigramNodePositions;

contractAddresses?: string[];

}): void;

Organigram.load

Lire depuis la chaîne chaque organe, procédure et actif déployé de l'organigramme.

Signature

load: (input?: {

walletClient?: WalletClient | null;

publicClient?: PublicClient | null;

}) => Promise<Organigram>;

Organigram.setAssets

Remplacer les actifs.

Signature

setAssets(assets: Asset[]): void;

Organigram.setOrgans

Remplacer les organes.

Signature

setOrgans(organs: Organ[]): void;

Organigram.setProcedures

Remplacer les procédures.

Signature

setProcedures(procedures: Procedure[]): void;

Organigram.toJson

Convertir l'organigramme en JSON simple.

Signature

toJson: () => OrganigramJson;

OrganigramEdgeType

Definition

export type OrganigramEdgeType = (typeof organigramEdgeTypes)[number];

OrganigramInput

Definition

export type OrganigramInput = {

id?: string | null;

slug?: string | null;

name?: string | null;

description?: string | null;

edgeType?: string | null;

nodePositions?: unknown;

chainId?: string | null;

organs: OrganInput[];

procedures: ProcedureInput[];

assets: AssetInput[];

organigramClient?: OrganigramClient | null;

walletClient?: WalletClient | null;

publicClient?: PublicClient | null;

contractAddresses?: string[] | null;

workspaceId?: string | null;

};

OrganigramJson

Definition

export type OrganigramJson = {

id: string;

slug: string;

name: string;

description: string;

edgeType: OrganigramEdgeType;

nodePositions: OrganigramNodePositions;

chainId: string;

organs: OrganJson[];

procedures: ProcedureJson[];

assets: AssetJson[];

workspaceId?: string | null;

};

OrganigramNodePosition

Definition

export type OrganigramNodePosition = {

x: number;

y: number;

};

OrganigramNodePositions

Definition

export type OrganigramNodePositions = Record<string, OrganigramNodePosition>;

ProcedureRoleTypeName

Definition

export type ProcedureRoleTypeName = 'proposers' | 'moderators' | 'deciders';

defaultChainId

Definition

const defaultChainId: string

defaultOrganigramEdgeType

Definition

const defaultOrganigramEdgeType: OrganigramEdgeType

organigramEdgeTypes

Definition

const organigramEdgeTypes: readonly ["default", "straight", "step", "smoothstep"]

TemplateName

Definition

export type TemplateName = keyof typeof templates;

getTemplate

Signature

getTemplate: (templateName: TemplateName, chainId: string) => OrganigramInput

isTemplateSupportedOnChain

Signature

isTemplateSupportedOnChain: (templateName: TemplateName, chainId: string) => boolean

renewSaltsAndAddresses

Signature

renewSaltsAndAddresses: (organigram: OrganigramInput, chainId: string) => OrganigramInput

templates

Organes

Un organe est un groupe : un registre d'entrées, chacune un membre, un document ou les deux, une liste de permissions et un solde d'actifs. Chaque modification exige une permission issue de PERMISSIONS. Dans une organisation gouvernée, ces permissions appartiennent aux procédures plutôt qu'aux personnes, afin que tout changement passe par une décision.

Organ

Toute modification d'un organe doit venir d'une adresse détenant la permission correspondante. Dans une organisation gouvernée, cette adresse est une procédure, afin que chaque changement passe par une décision.

Definition

constructor(input: OrganInput);

Organ.addEntries

Ajouter des membres ou des documents au registre.

Signature

addEntries: (entries: OrganEntryInput[], options?: TransactionOptions) => Promise<OrganigramTransactionReceipt>;

Organ.addPermission

Accorder des permissions à une adresse.

Signature

addPermission: (permission: OrganPermission, options?: TransactionOptions) => Promise<OrganigramTransactionReceipt>;

Organ.checkAddressPermissions

Lire les drapeaux de permission qu'une adresse détient sur un organe.

Signature

static checkAddressPermissions(organAddress: string, addressToCheck: string, clients: ContractClients): Promise<number>;

Organ.getBalance

Lire le solde en ether d'un organe, en wei.

Signature

static getBalance(address: string, clients: ContractClients): Promise<bigint>;

Organ.isOrgan

Indiquer si un contrat est un organe.

Signature

static isOrgan(address: string, clients: ContractClients): Promise<boolean>;

Organ.load

Lire un organe depuis la chaîne : ses entrées, permissions et métadonnées.

Signature

static load(address: string, clients: ContractClients, initialOrgan?: OrganInput): Promise<Organ>;

Organ.loadData

Lire la référence de métadonnées et la taille des registres d'un organe.

Signature

static loadData(address: string, clients: ContractClients): Promise<OrganContractData>;

Organ.loadEntries

Lire toutes les entrées d'un organe.

Signature

static loadEntries(address: string, clients: ContractClients, data?: OrganContractData): Promise<OrganEntry[]>;

Organ.loadEntry

Lire une entrée d'un organe, par index.

Signature

static loadEntry(address: string, index: string, clients: ContractClients): Promise<OrganEntry>;

Organ.loadEntryForAccount

Trouver l'entrée d'une adresse dans un organe, si elle en est membre.

Signature

static loadEntryForAccount(address: string, account: string, clients: ContractClients): Promise<OrganEntry | undefined>;

Organ.loadPermission

Lire une permission d'un organe, par index.

Signature

static loadPermission(address: string, index: string, clients: ContractClients): Promise<OrganPermission>;

Organ.loadPermissions

Lire toutes les permissions d'un organe.

Signature

static loadPermissions(address: string, clients: ContractClients, data?: OrganContractData): Promise<OrganPermission[]>;

Organ.populateTransaction

Encoder un appel à une fonction d'organe, pour l'utiliser comme opération de proposition avec Procedure.createOperation().

Signature

static populateTransaction(address: string, walletClient: WalletClient, functionName: OrganFunctionName | string, ...args: unknown[]): Promise<{

to: string;

data: string;

functionName: string;

}>;

Organ.reload

Relire tout l'organe depuis la chaîne.

Signature

reload(): Promise<Organ>;

Organ.reloadData

Relire la référence de métadonnées depuis la chaîne.

Signature

reloadData(): Promise<Organ>;

Organ.reloadEntries

Relire les entrées depuis la chaîne.

Signature

reloadEntries(): Promise<Organ>;

Organ.reloadPermissions

Relire les permissions depuis la chaîne.

Signature

reloadPermissions(): Promise<Organ>;

Organ.removeEntries

Retirer des entrées du registre, par index.

Signature

removeEntries: (indexes: string[], options?: TransactionOptions) => Promise<OrganigramTransactionReceipt>;

Organ.removePermission

Révoquer toutes les permissions d'une adresse.

Signature

removePermission: (permission: string, options?: TransactionOptions) => Promise<OrganigramTransactionReceipt>;

Organ.replaceEntry

Remplacer une entrée du registre.

Signature

replaceEntry: (index: number, entry: OrganEntryInput, options?: TransactionOptions) => Promise<OrganigramTransactionReceipt>;

Organ.replacePermission

Transférer des permissions d'une adresse à une autre.

Signature

replacePermission: (oldPermissionAddress: string, newOrganPermission: OrganPermission, options?: TransactionOptions) => Promise<OrganigramTransactionReceipt>;

Organ.toJson

Convertir l'organe en JSON simple.

Signature

toJson: () => OrganJson;

Organ.updateCid

Remplacer la référence aux métadonnées off-chain de l'organe.

Signature

updateCid: (cid: string, options?: TransactionOptions) => Promise<OrganigramTransactionReceipt>;

Organ.withdrawERC20

Envoyer des jetons ERC-20 détenus par l'organe.

Signature

withdrawERC20: (token: string, to: string, amount: string | number | bigint, options?: TransactionOptions) => Promise<OrganigramTransactionReceipt>;

Organ.withdrawERC721

Envoyer un jeton ERC-721 détenu par l'organe.

Signature

withdrawERC721: (token: string, to: string, tokenId: string | number | bigint, options?: TransactionOptions) => Promise<OrganigramTransactionReceipt>;

Organ.withdrawEther

Envoyer de l'ether détenu par l'organe.

Signature

withdrawEther: (to: string, value: string | number | bigint, options?: TransactionOptions) => Promise<OrganigramTransactionReceipt>;

OrganEntry

OrganEntryInput

OrganInput

OrganJson

OrganPermission

OrganFunctionName

getPermissionsSet

Signature

getPermissionsSet: (permissions: number) => string[]

PERMISSIONS

Procédures et propositions

Une procédure permet aux membres de certains organes de modifier d'autres organes. Les proposants soumettent une proposition, une liste d'opérations construite avec Procedure.createOperation(). Avec modération, un modérateur la présente ou la bloque. Les décideurs l'adoptent ou la rejettent ensuite, seuls dans une NominationProcedure, par vote dans une VoteProcedure, ou par vote pondéré par un jeton dans une ERC20VoteProcedure, et l'adoption exécute les opérations. Chaque action existe aussi en variante signée : l'utilisateur signe avec une méthode sign… , et n'importe quel compte soumet la signature avec la méthode …BySig correspondante, si bien que les utilisateurs n'ont pas besoin de gas.

Procedure

Une proposition est une liste d'opérations. Les proposants la soumettent avec propose(). Avec modération, un modérateur la présente avec presentProposal() ou la bloque avec blockProposal(). Les décideurs l'adoptent ou la rejettent ensuite, selon le type de procédure, et l'adoption exécute ses opérations. Chaque action a aussi une variante signée (sign… puis …BySig), afin qu'un relais la soumette et que les utilisateurs n'aient pas besoin de gas.

Definition

constructor(input: ProcedureInput);

Procedure.applyProposal

Régler une proposition : pour un vote, compter les bulletins une fois le vote terminé, puis l'exécuter ou la clore.

Signature

applyProposal(proposalKey: string, options?: TransactionOptions): Promise<OrganigramTransactionReceipt>;

Procedure.applyProposalBySig

Régler une proposition, avec une application signée par un autre compte.

Signature

applyProposalBySig(input: SignedProposalActionInput & {

signature: string;

}, options?: TransactionOptions): Promise<OrganigramTransactionReceipt>;

Procedure.blockProposal

Bloquer une proposition en tant que modérateur, avant sa décision.

Signature

blockProposal(proposalKey: string, reason: string, options?: TransactionOptions): Promise<OrganigramTransactionReceipt>;

Procedure.blockProposalBySig

Bloquer une proposition signée par un modérateur.

Signature

blockProposalBySig(input: SignedBlockProposalInput & {

signature: string;

}, options?: TransactionOptions): Promise<OrganigramTransactionReceipt>;

Procedure.createExternalCallOperation

Construire une opération qui fait appeler par un organe un contrat extérieur à l'organisation.

Signature

static createExternalCallOperation(input: ExternalCallOperationInput): ProcedureProposalOperation;

Procedure.createOperation

Transformer un appel de contrat, comme le résultat de Organ.populateTransaction(), en opération de proposition.

Signature

static createOperation(input: {

to: string;

data: string;

value?: number | string | bigint;

index?: number | string;

}): ProcedureProposalOperation;

Procedure.getClients

Les clients viem de la procédure.

Signature

protected getClients(): ContractClients;

Procedure.getNonce

Lire le prochain nonce de signature d'un compte.

Signature

getNonce(account: string): Promise<bigint>;

Procedure.getTypedDataDomain

Domaine EIP-712 des signatures de cette procédure.

Signature

getTypedDataDomain(): {

name: string;

version: string;

chainId: bigint;

verifyingContract: `0x${string}`;

};

Procedure.isProcedure

Indiquer si un contrat est une procédure.

Signature

static isProcedure(address: string, clients: ContractClients): Promise<boolean>;

Procedure.load

Lire une procédure depuis la chaîne, avec ses propositions.

Signature

static load(address: string, clients: ContractClients, initialProcedure?: ProcedureInput): Promise<Procedure>;

Procedure.loadData

Lire les rôles, la référence de métadonnées et le nombre de propositions d'une procédure.

Signature

static loadData(address: string, clients: ContractClients): Promise<ProcedureContractData>;

Procedure.loadProposal

Lire une proposition d'une procédure.

Signature

static loadProposal(address: string, proposalKey: string, clients: ContractClients): Promise<ProcedureProposal>;

Procedure.loadProposals

Lire toutes les propositions d'une procédure.

Signature

static loadProposals(address: string, clients: ContractClients, data?: ProcedureContractData): Promise<ProcedureProposal[]>;

Procedure.parseOperation

Normaliser une opération lue depuis la chaîne.

Signature

static parseOperation(rawOperation: unknown): ProcedureProposalOperation;

Procedure.presentProposal

Présenter une proposition aux décideurs, en tant que modérateur.

Signature

presentProposal(proposalKey: string, options?: TransactionOptions): Promise<OrganigramTransactionReceipt>;

Procedure.presentProposalBySig

Présenter une proposition signée par un modérateur.

Signature

presentProposalBySig(input: SignedProposalActionInput & {

signature: string;

}, options?: TransactionOptions): Promise<OrganigramTransactionReceipt>;

Procedure.propose

Soumettre une proposition.

Signature

propose(input: {

cid: string;

operations: ProcedureProposalOperation[];

options?: TransactionOptions;

}): Promise<ProcedureProposal>;

Paramètres

Nom	Type	Description
input	{ cid: string; operations: ProcedureProposalOperation[]; options?: TransactionOptions; }	Référence aux métadonnées de la proposition, qui doit être une référence CID, et ses opérations.

Procedure.proposeBySig

Soumettre une proposition signée par un autre compte.

Signature

proposeBySig(input: SignedProposalInput & {

signature: string;

}): Promise<OrganigramTransaction>;

Procedure.reloadData

Relire les rôles et la référence de métadonnées depuis la chaîne.

Signature

reloadData(): Promise<Procedure>;

Procedure.reloadProposal

Relire une proposition depuis la chaîne.

Signature

reloadProposal(proposalKey: string): Promise<Procedure>;

Procedure.reloadProposals

Relire toutes les propositions depuis la chaîne.

Signature

reloadProposals(): Promise<Procedure>;

Procedure.signApplyProposal

Signer l'application d'une proposition, pour applyProposalBySig().

Signature

signApplyProposal(input: SignedProposalActionInput): Promise<string>;

Procedure.signBlockProposal

Signer le blocage d'une proposition, pour blockProposalBySig().

Signature

signBlockProposal(input: SignedBlockProposalInput): Promise<string>;

Procedure.signPresentProposal

Signer la présentation d'une proposition, pour presentProposalBySig().

Signature

signPresentProposal(input: SignedProposalActionInput): Promise<string>;

Procedure.signProposal

Signer une proposition, afin qu'un autre compte la soumette avec proposeBySig().

Le signataire ne paie pas de gas : n'importe quel compte peut soumettre la signature avec la méthode correspondante …BySig .

Signature

signProposal(input: SignedProposalInput): Promise<string>;

Procedure.toJson

Convertir la procédure en JSON simple.

Signature

toJson: () => ProcedureJson;

ExternalCallOperationInput

OperationParam

ProcedureInput

ProcedureProposal

ProcedureProposalOperation

Construisez-le avec Procedure.createOperation() plutôt qu'à la main.

ProcedureProposalOperationFunction

ProcedureType

ProcedureTypeField

ProposalMetadata

SignedBlockProposalInput

Extends SignedProposalActionInput.

SignedProposalActionInput

SignedProposalInput

AccountInOrgans

Definition

export type AccountInOrgans = {

moderators?: boolean;

proposers?: boolean;

deciders?: boolean;

};

Election

Definition

export type Election = {

proposalKey: string;

start: string;

votesCount: string;

hasVoted: boolean;

approvals?: string;

objections?: string;

eligibleVotes?: string;

approved?: boolean;

};

OperationKey

Definition

export type OperationKey = 'addEntries' | 'removeEntries' | 'replaceEntry' | 'addPermission' | 'removePermission' | 'replacePermission' | 'updateMetadata' | 'withdrawEther' | 'withdrawERC20' | 'withdrawERC721' | 'externalCall' | string;

OperationParamAction

Definition

export type OperationParamAction = 'select' | 'create' | 'update' | 'delete' | 'withdraw' | 'deposit' | 'transfer' | 'block';

OperationParamType

Definition

export type OperationParamType = 'cid' | 'entry' | 'entries' | 'address' | 'bytes' | 'addresses' | 'index' | 'indexes' | 'organ' | 'oldPermissionAddress' | 'newPermissionAddress' | 'permissionAddress' | 'permissionValue' | 'proposal' | 'proposals' | 'amount' | 'tokenId';

OperationTag

Definition

export type OperationTag = 'cid' | 'entries' | 'permissions' | 'coins' | 'collectibles' | 'erc721' | 'erc20' | 'erc1155' | 'ether' | 'add' | 'replace' | 'remove' | 'deposit' | 'withdraw' | 'transfer';

ProcedureJson

Definition

export type ProcedureJson = {

isDeployed: boolean;

address: string;

deciders: string;

typeName: ProcedureTypeName;

name: string;

description: string;

cid: string;

salt?: string | null;

chainId: string;

data: string;

metadata?: string;

proposers: string;

moderators: string;

withModeration: boolean;

proposerMode?: ERC20VoteRoleMode;

moderatorMode?: ERC20VoteRoleMode;

voterMode?: ERC20VoteRoleMode;

requireMemberMajority?: boolean;

forwarder: string;

proposals?: ProcedureProposal[];

args?: unknown[];

type: ProcedureType;

organigramId?: string | null;

};

NominationProcedure

Definition

constructor(procedureInput: ProcedureInput);

NominationProcedure.load

Lire une procédure de nomination depuis la chaîne, avec ses propositions.

Signature

static load(address: string, clients: ContractClients, initialProcedure?: ProcedureInput): Promise<NominationProcedure>;

NominationProcedure.nominate

Adopter une proposition en tant que décideur, ce qui exécute ses opérations.

Signature

nominate(proposalKey: string, options?: TransactionOptions): Promise<void>;

NominationProcedure.nominateBySig

Adopter une proposition avec une adoption signée par un décideur.

Signature

nominateBySig(input: {

proposalKey: string;

nonce: bigint;

deadline: bigint | number;

signature: string;

}): Promise<void>;

NominationProcedure.reject

Rejeter une proposition en tant que décideur.

Signature

reject(proposalKey: string, options?: TransactionOptions): Promise<void>;

NominationProcedure.signNomination

Signer l'adoption d'une proposition, pour nominateBySig().

Le signataire ne paie pas de gas : n'importe quel compte peut soumettre la signature avec la méthode correspondante …BySig .

Signature

signNomination(input: {

proposalKey: string;

nonce: bigint;

deadline: bigint | number;

}): Promise<string>;

VoteProcedure

Le vote s'ouvre lorsqu'une proposition est présentée. Une fois le vote terminé, n'importe qui appelle applyProposal() pour compter les bulletins et régler la proposition.

Definition

constructor(input: VoteProcedureInput);

VoteProcedure.count

Indiquer si une proposition est adoptée, une fois son vote terminé.

Signature

count(proposalKey: string): Promise<boolean>;

VoteProcedure.load

Lire une procédure de vote depuis la chaîne, avec ses propositions et ses scrutins.

Signature

static load(address: string, clients: ContractClients, initialProcedure?: ProcedureInput): Promise<VoteProcedure>;

VoteProcedure.loadElection

Lire l'état du vote sur une proposition.

Signature

static loadElection(address: string, proposalKey: string, clients: ContractClients, voteDuration?: bigint, contract?: OrganigramContract, blockTimestamp?: bigint): Promise<Election>;

VoteProcedure.loadElections

Lire l'état du vote sur chaque proposition.

Signature

static loadElections(address: string, clients: ContractClients, proposalsLength?: number): Promise<Election[]>;

VoteProcedure.signVote

Signer un vote, pour voteBySig().

Le signataire ne paie pas de gas : n'importe quel compte peut soumettre la signature avec la méthode correspondante …BySig .

Signature

signVote(input: {

proposalKey: string;

approval: boolean;

nonce: bigint;

deadline: bigint | number;

}): Promise<string>;

VoteProcedure.toJson

Convertir la procédure en JSON simple.

Signature

toJson: () => ProcedureJson;

VoteProcedure.vote

Voter pour ou contre une proposition, en tant que décideur.

Signature

vote(proposalKey: string, choice: 'for' | 'against', options?: TransactionOptions): Promise<void>;

VoteProcedure.voteBySig

Émettre un vote signé par un décideur.

Signature

voteBySig(input: {

proposalKey: string;

approval: boolean;

nonce: bigint;

deadline: bigint | number;

signature: string;

}): Promise<void>;

VoteProcedureInput

Definition

export type VoteProcedureInput = ProcedureInput & {

quorumSize: string;

voteDuration: string;

majoritySize: string;

elections: Election[];

};

ERC20VoteProcedure

Les bulletins pèsent les soldes détenus juste avant l'ouverture du vote, si bien que les jetons déplacés pendant le vote ne comptent pas deux fois.

Definition

constructor(input: ERC20VoteProcedureInput);

ERC20VoteProcedure.erc20Balance

Lire le solde de jetons d'un compte, ou du portefeuille connecté.

Signature

erc20Balance(account?: string): Promise<bigint>;

ERC20VoteProcedure.load

Lire une procédure de vote ERC-20 depuis la chaîne, avec ses propositions et ses scrutins.

Signature

static load(address: string, clients: ContractClients, initialProcedure?: ProcedureInput): Promise<ERC20VoteProcedure>;

ERC20VoteProcedure.toJson

Convertir la procédure en JSON simple.

Signature

toJson: () => ProcedureJson;

ERC20VoteProcedure.vote

Voter pour ou contre une proposition, avec le poids de vos jetons.

Signature

vote(proposalKey: string, choice: 'for' | 'against', options?: TransactionOptions): Promise<void>;

ERC20VoteProcedureInput

Definition

export type ERC20VoteProcedureInput = Omit<VoteProcedureInput, 'type' | 'typeName'> & {

erc20: string;

proposerMode?: ERC20VoteRoleMode;

moderatorMode?: ERC20VoteRoleMode;

voterMode?: ERC20VoteRoleMode;

requireMemberMajority?: boolean;

};

PopulateInitializeInput

ERC20VoteRoleMode

Definition

export type ERC20VoteRoleMode = 'organ' | 'token' | 'disabled';

PopulatedTransactionData

Definition

export type PopulatedTransactionData = {

data: string;

};

ProcedureTypeName

Definition

export type ProcedureTypeName = 'erc20Vote' | 'nomination' | 'vote';

getProcedureClass

Signature

getProcedureClass: (typeName: string) => Promise<typeof import("./erc20Vote").ERC20VoteProcedure | typeof import("./vote").VoteProcedure | typeof import("./nomination").NominationProcedure>

getProcedureTypes

Signature

getProcedureTypes: (chainId?: string) => Partial<Record<ProcedureTypeName, ProcedureType>>

Actifs

Les actifs sont des jetons ERC-20 détenus par des organes : des actifs simples, ou des titres de capital dont une procédure approuve les transferts.

Asset

Definition

constructor(input: AssetInput);

Asset.load

Hydrater un actif à partir de l'état de la chaîne.

Signature

static load: (address: string, clients: ContractClients, initialAsset?: AssetInput) => Promise<(Asset & {

userBalance: string;

}) | undefined>;

Asset.toJson

Convertir l'actif en une structure sécurisée pour JSON.

Signature

toJson(): AssetJson;

AssetInput

AssetJson

ERC20_INITIAL_SUPPLY

Definition

const ERC20_INITIAL_SUPPLY = 10000000

Contenu off-chain et chiffrement

Les contrats ne stockent que des références. Les métadonnées et les documents vivent off-chain, et sont référencés par des références CID de la forme og://workspace/<workspace>/<key>. Chaque version d'un fichier est décrite par un manifeste. Les fichiers chiffrés utilisent trois niveaux de clés : une clé de contenu chiffre un fichier, une clé de groupe partagée par les membres d'un groupe d'accès enveloppe les clés de contenu, et la paire de clés de chaque membre désenveloppe les clés de groupe. Ces fonctions s'exécutent sur la Web Crypto API de l'appareil de l'utilisateur : gardez-y les clés privées, ne les envoyez jamais à un serveur et ne les journalisez jamais.

EncryptedCidAccessGroup

EncryptedCidManifest

EncryptionPublicKeySiweResource

ParsedCidRef

PublicFileVersionManifest

RecipientEncryptionKey

ScopeEnvelopeCheckpoint

ScopeEnvelopeItem

ScopeEnvelopeReference

StoredUserEncryptionKeyPair

WrappedContentKey

WrappedGroupKey

AccessGroupScopeType

Definition

export type AccessGroupScopeType = 'workspace' | 'organization' | 'organ' | 'procedure' | 'certifiedProof';

EncryptedCidContentType

Definition

export type EncryptedCidContentType = 'entry' | 'proposal' | 'organMetadata' | 'procedureMetadata' | 'certifiedProof' | 'file' | string;

FileVersionManifest

Definition

export type FileVersionManifest = PublicFileVersionManifest | EncryptedCidManifest;

ScopeEnvelopeContentType

Definition

export type ScopeEnvelopeContentType = EncryptedCidContentType;

ScopeEnvelopeRetentionState

Definition

export type ScopeEnvelopeRetentionState = 'current' | 'superseded' | 'revoked' | 'archived';

ScopeEnvelopeScopeType

Definition

export type ScopeEnvelopeScopeType = 'workspace';

bytesToArrayBuffer

Signature

bytesToArrayBuffer: (value: ArrayBuffer | Uint8Array) => ArrayBuffer

bytesToText

Signature

bytesToText: (value: ArrayBuffer | Uint8Array) => string

computeScopeEnvelopeRoot

Signature

computeScopeEnvelopeRoot: (items: Record<string, ScopeEnvelopeItem>) => Promise<string>

createEncryptionKeyVersion

Signature

createEncryptionKeyVersion: (timestamp?: number) => number

createEncryptionPublicKeyMessage

Signature

createEncryptionPublicKeyMessage: (address: string, publicKey: JsonWebKey, keyVersion: number) => string

createEncryptionPublicKeySiweResource

Signature

createEncryptionPublicKeySiweResource: (address: string, publicKey: JsonWebKey, keyVersion: number) => string

createFileVersionManifest

Signature

createFileVersionManifest: (input: {

contentType: ScopeEnvelopeContentType;

scopeRef: ScopeEnvelopeReference;

logicalKey: string;

encryptedCid: string;

encryptedContentIv: string;

encryptedContentSize: number;

wrappedContentKey: WrappedContentKey;

previousManifestCid?: string | null;

retentionState?: ScopeEnvelopeRetentionState;

scopeEnvelope?: ScopeEnvelopeCheckpoint;

mime?: string;

name?: string;

signature?: string | null;

signedByAddress?: string | null;

createdAt?: Date | string;

}) => FileVersionManifest

createPublicFileVersionManifest

Signature

createPublicFileVersionManifest: (input: {

contentType: ScopeEnvelopeContentType;

scopeRef: ScopeEnvelopeReference;

logicalKey: string;

publicCid: string;

publicContentSize: number;

previousManifestCid?: string | null;

retentionState?: ScopeEnvelopeRetentionState;

scopeEnvelope?: ScopeEnvelopeCheckpoint;

mime?: string;

name?: string;

signature?: string | null;

signedByAddress?: string | null;

createdAt?: Date | string;

}) => PublicFileVersionManifest

createScopeEnvelopeCheckpoint

Signature

createScopeEnvelopeCheckpoint: (input: {

epoch: number;

membershipHash: string;

rootHash: string;

}) => ScopeEnvelopeCheckpoint

createScopeEnvelopeItem

Signature

createScopeEnvelopeItem: (input: {

logicalKey: string;

currentManifestCid: string;

contentType: ScopeEnvelopeContentType;

version?: number;

retentionState?: ScopeEnvelopeRetentionState;

previousManifestCid?: string;

updatedAt?: Date | string;

}) => ScopeEnvelopeItem

createScopeEnvelopeSignatureMessage

Signature

createScopeEnvelopeSignatureMessage: (input: {

scopeRef: ScopeEnvelopeReference;

checkpoint: ScopeEnvelopeCheckpoint;

items: Record<string, ScopeEnvelopeItem>;

previousEnvelopeCid?: string | null;

}) => string

decryptBytes

Signature

decryptBytes: (encryptedBytes: ArrayBuffer | Uint8Array, key: CryptoKey, iv: string) => Promise<Uint8Array>

encryptBytes

Signature

encryptBytes: (bytes: ArrayBuffer | Uint8Array, key: CryptoKey) => Promise<{

encryptedBytes: Uint8Array;

iv: string;

}>

exportUserPrivateKey

Ne stockez le résultat que chiffré, par exemple dans un coffre à passkeys.

Signature

exportUserPrivateKey: (keyPair: CryptoKeyPair) => Promise<JsonWebKey>

exportUserPublicKey

Signature

exportUserPublicKey: (keyPair: CryptoKeyPair) => Promise<JsonWebKey>

formatCidRef

Signature

formatCidRef: (scopeRef: ScopeEnvelopeReference, logicalKey: string, manifestCid?: string) => string

generateContentKey

Signature

generateContentKey: () => Promise<CryptoKey>

generateGroupKey

Signature

generateGroupKey: () => Promise<CryptoKey>

generateUserEncryptionKeyPair

Gardez la clé privée sur l'appareil de l'utilisateur : ne l'envoyez jamais à un serveur et ne la journalisez jamais.

Signature

generateUserEncryptionKeyPair: () => Promise<CryptoKeyPair>

getCrypto

Signature

getCrypto: () => Crypto

getRandomIv

Signature

getRandomIv: () => Uint8Array

importExtractableUserPublicKey

Signature

importExtractableUserPublicKey: (publicKey: JsonWebKey) => Promise<CryptoKey>

importUserPrivateKey

Signature

importUserPrivateKey: (privateKey: JsonWebKey) => Promise<CryptoKey>

isCidRef

Signature

isCidRef: (value?: string | null) => boolean

isEncryptedCidManifest

Signature

isEncryptedCidManifest: (value: unknown) => value is EncryptedCidManifest

isFileVersionManifest

Signature

isFileVersionManifest: (value: unknown) => value is FileVersionManifest

isValidEncryptionKeyVersion

Signature

isValidEncryptionKeyVersion: (keyVersion: number) => boolean

normalizeEncryptionKeyVersion

Signature

normalizeEncryptionKeyVersion: (keyVersion: number) => number | null

parseCidRef

Signature

parseCidRef: (value?: string | null) => ParsedCidRef | null

parseEncryptionPublicKeySiweResource

Signature

parseEncryptionPublicKeySiweResource: (resources: string[] | undefined, address: string) => EncryptionPublicKeySiweResource | null

unwrapContentKey

Signature

unwrapContentKey: (wrappedContentKey: WrappedContentKey, groupKey: CryptoKey) => Promise<CryptoKey>

unwrapGroupKey

Signature

unwrapGroupKey: (wrappedGroupKey: WrappedGroupKey, recipientPrivateKey: CryptoKey) => Promise<CryptoKey>

wrapContentKey

Signature

wrapContentKey: (contentKey: CryptoKey, groupKey: CryptoKey) => Promise<WrappedContentKey>

wrapGroupKeyForRecipient

Signature

wrapGroupKeyForRecipient: (groupKey: CryptoKey, recipient: RecipientEncryptionKey) => Promise<WrappedGroupKey>

ENCRYPTED_CID_KIND

Definition

const ENCRYPTED_CID_KIND: "organigram.encrypted-cid.v1"

ENCRYPTION_ALGORITHM

Definition

const ENCRYPTION_ALGORITHM: "A256GCM"

ENCRYPTION_PUBLIC_KEY_SIWE_RESOURCE_KIND

Definition

const ENCRYPTION_PUBLIC_KEY_SIWE_RESOURCE_KIND: "organigram.encryption-public-key.v1"

FILE_VERSION_MANIFEST_KIND

Definition

const FILE_VERSION_MANIFEST_KIND: "organigram.file-version-manifest.v1"

GROUP_KEY_ALGORITHM

Definition

const GROUP_KEY_ALGORITHM: "ECDH-P256+A256GCM"

Réseaux et déploiements

Les contrats du protocole sont déployés une fois par chaîne. Ces fonctions indiquent quelles chaînes sont prises en charge, où se trouvent les contrats, et à quelle adresse un nouveau clone sera déployé.

getChainExplorerBaseUrl

Signature

getChainExplorerBaseUrl: (chainId: string) => string | undefined

getConfiguredChain

Signature

getConfiguredChain: (chainId: string) => Chain | undefined

getDefaultChainId

Signature

getDefaultChainId: () => string

Retourne

Type	Description
string	L'identifiant de chaîne par défaut.

getDeployment

Signature

getDeployment: (chainId: string | number | bigint | null | undefined, deploymentName: ProtocolDeploymentName) => string

getHostUrl

Signature

getHostUrl: (hostUrl?: string | undefined) => URL | null

getSupportedChainIds

Signature

getSupportedChainIds: () => string[]

isLocalHost

Signature

isLocalHost: (hostUrl?: string) => boolean

isSupportedChainId

Signature

isSupportedChainId: (chainId: string | number | bigint | null | undefined) => boolean

deployedAddresses

Definition

const deployedAddresses: ProtocolDeployments

ContractName

Definition

export type ContractName = 'Organ' | 'Asset' | 'EquityToken' | 'ERC20VoteProcedure' | 'VoteProcedure' | 'NominationProcedure' | 'OrganigramClient';

predictContractAddress

Signature

predictContractAddress: (input: {

type: Omit<ContractName, "OrganigramClient">;

chainId: string;

salt: string;

deployer?: string;

}) => string

Utilitaires

Petites fonctions utilitaires utilisées dans la bibliothèque et l'application Organigram.

capitalize

Signature

capitalize: (s: string) => string

createRandom32BytesHexId

Signature

createRandom32BytesHexId: () => `0x${string}`

handleJsonBigInt

Signature

handleJsonBigInt: (_key: string, value: unknown) => unknown

parseFiniteNumber

Signature

parseFiniteNumber: (value: number | string | null | undefined, fallback: number) => number