Interface IInstantDistributionAgreementV1

interface IInstantDistributionAgreementV1 {
    callStatic: {
        agreementType(overrides?): Promise<string>;
        approveSubscription(token, publisher, indexId, ctx, overrides?): Promise<string>;
        calculateDistribution(token, publisher, indexId, amount, overrides?): Promise<[BigNumber, BigNumber] & {
            actualAmount: BigNumber;
            newIndexValue: BigNumber;
        }>;
        claim(token, publisher, indexId, subscriber, ctx, overrides?): Promise<string>;
        createIndex(token, indexId, ctx, overrides?): Promise<string>;
        deleteSubscription(token, publisher, indexId, subscriber, ctx, overrides?): Promise<string>;
        distribute(token, indexId, amount, ctx, overrides?): Promise<string>;
        getIndex(token, publisher, indexId, overrides?): Promise<[boolean, BigNumber, BigNumber, BigNumber] & {
            exist: boolean;
            indexValue: BigNumber;
            totalUnitsApproved: BigNumber;
            totalUnitsPending: BigNumber;
        }>;
        getSubscription(token, publisher, indexId, subscriber, overrides?): Promise<[boolean, boolean, BigNumber, BigNumber] & {
            approved: boolean;
            exist: boolean;
            pendingDistribution: BigNumber;
            units: BigNumber;
        }>;
        getSubscriptionByID(token, agreementId, overrides?): Promise<[string, number, boolean, BigNumber, BigNumber] & {
            approved: boolean;
            indexId: number;
            pendingDistribution: BigNumber;
            publisher: string;
            units: BigNumber;
        }>;
        listSubscriptions(token, subscriber, overrides?): Promise<[string[], number[], BigNumber[]] & {
            indexIds: number[];
            publishers: string[];
            unitsList: BigNumber[];
        }>;
        realtimeBalanceOf(token, account, time, overrides?): Promise<[BigNumber, BigNumber, BigNumber] & {
            deposit: BigNumber;
            dynamicBalance: BigNumber;
            owedDeposit: BigNumber;
        }>;
        revokeSubscription(token, publisher, indexId, ctx, overrides?): Promise<string>;
        updateIndex(token, indexId, indexValue, ctx, overrides?): Promise<string>;
        updateSubscription(token, indexId, subscriber, units, ctx, overrides?): Promise<string>;
    };
    estimateGas: {
        agreementType(overrides?): Promise<BigNumber>;
        approveSubscription(token, publisher, indexId, ctx, overrides?): Promise<BigNumber>;
        calculateDistribution(token, publisher, indexId, amount, overrides?): Promise<BigNumber>;
        claim(token, publisher, indexId, subscriber, ctx, overrides?): Promise<BigNumber>;
        createIndex(token, indexId, ctx, overrides?): Promise<BigNumber>;
        deleteSubscription(token, publisher, indexId, subscriber, ctx, overrides?): Promise<BigNumber>;
        distribute(token, indexId, amount, ctx, overrides?): Promise<BigNumber>;
        getIndex(token, publisher, indexId, overrides?): Promise<BigNumber>;
        getSubscription(token, publisher, indexId, subscriber, overrides?): Promise<BigNumber>;
        getSubscriptionByID(token, agreementId, overrides?): Promise<BigNumber>;
        listSubscriptions(token, subscriber, overrides?): Promise<BigNumber>;
        realtimeBalanceOf(token, account, time, overrides?): Promise<BigNumber>;
        revokeSubscription(token, publisher, indexId, ctx, overrides?): Promise<BigNumber>;
        updateIndex(token, indexId, indexValue, ctx, overrides?): Promise<BigNumber>;
        updateSubscription(token, indexId, subscriber, units, ctx, overrides?): Promise<BigNumber>;
    };
    filters: {
        IndexCreated(token?, publisher?, indexId?, userData?): IndexCreatedEventFilter;
        IndexCreated(address,address,uint32,bytes)(token?, publisher?, indexId?, userData?): IndexCreatedEventFilter;
        IndexDistributionClaimed(token?, publisher?, indexId?, subscriber?, amount?): IndexDistributionClaimedEventFilter;
        IndexDistributionClaimed(address,address,uint32,address,uint256)(token?, publisher?, indexId?, subscriber?, amount?): IndexDistributionClaimedEventFilter;
        IndexSubscribed(token?, publisher?, indexId?, subscriber?, userData?): IndexSubscribedEventFilter;
        IndexSubscribed(address,address,uint32,address,bytes)(token?, publisher?, indexId?, subscriber?, userData?): IndexSubscribedEventFilter;
        IndexUnitsUpdated(token?, publisher?, indexId?, subscriber?, units?, userData?): IndexUnitsUpdatedEventFilter;
        IndexUnitsUpdated(address,address,uint32,address,uint128,bytes)(token?, publisher?, indexId?, subscriber?, units?, userData?): IndexUnitsUpdatedEventFilter;
        IndexUnsubscribed(token?, publisher?, indexId?, subscriber?, userData?): IndexUnsubscribedEventFilter;
        IndexUnsubscribed(address,address,uint32,address,bytes)(token?, publisher?, indexId?, subscriber?, userData?): IndexUnsubscribedEventFilter;
        IndexUpdated(token?, publisher?, indexId?, oldIndexValue?, newIndexValue?, totalUnitsPending?, totalUnitsApproved?, userData?): IndexUpdatedEventFilter;
        IndexUpdated(address,address,uint32,uint128,uint128,uint128,uint128,bytes)(token?, publisher?, indexId?, oldIndexValue?, newIndexValue?, totalUnitsPending?, totalUnitsApproved?, userData?): IndexUpdatedEventFilter;
        SubscriptionApproved(token?, subscriber?, publisher?, indexId?, userData?): SubscriptionApprovedEventFilter;
        SubscriptionApproved(address,address,address,uint32,bytes)(token?, subscriber?, publisher?, indexId?, userData?): SubscriptionApprovedEventFilter;
        SubscriptionDistributionClaimed(token?, subscriber?, publisher?, indexId?, amount?): SubscriptionDistributionClaimedEventFilter;
        SubscriptionDistributionClaimed(address,address,address,uint32,uint256)(token?, subscriber?, publisher?, indexId?, amount?): SubscriptionDistributionClaimedEventFilter;
        SubscriptionRevoked(token?, subscriber?, publisher?, indexId?, userData?): SubscriptionRevokedEventFilter;
        SubscriptionRevoked(address,address,address,uint32,bytes)(token?, subscriber?, publisher?, indexId?, userData?): SubscriptionRevokedEventFilter;
        SubscriptionUnitsUpdated(token?, subscriber?, publisher?, indexId?, units?, userData?): SubscriptionUnitsUpdatedEventFilter;
        SubscriptionUnitsUpdated(address,address,address,uint32,uint128,bytes)(token?, subscriber?, publisher?, indexId?, units?, userData?): SubscriptionUnitsUpdatedEventFilter;
    };
    functions: {
        agreementType(overrides?): Promise<[string]>;
        approveSubscription(token, publisher, indexId, ctx, overrides?): Promise<ContractTransaction>;
        calculateDistribution(token, publisher, indexId, amount, overrides?): Promise<[BigNumber, BigNumber] & {
            actualAmount: BigNumber;
            newIndexValue: BigNumber;
        }>;
        claim(token, publisher, indexId, subscriber, ctx, overrides?): Promise<ContractTransaction>;
        createIndex(token, indexId, ctx, overrides?): Promise<ContractTransaction>;
        deleteSubscription(token, publisher, indexId, subscriber, ctx, overrides?): Promise<ContractTransaction>;
        distribute(token, indexId, amount, ctx, overrides?): Promise<ContractTransaction>;
        getIndex(token, publisher, indexId, overrides?): Promise<[boolean, BigNumber, BigNumber, BigNumber] & {
            exist: boolean;
            indexValue: BigNumber;
            totalUnitsApproved: BigNumber;
            totalUnitsPending: BigNumber;
        }>;
        getSubscription(token, publisher, indexId, subscriber, overrides?): Promise<[boolean, boolean, BigNumber, BigNumber] & {
            approved: boolean;
            exist: boolean;
            pendingDistribution: BigNumber;
            units: BigNumber;
        }>;
        getSubscriptionByID(token, agreementId, overrides?): Promise<[string, number, boolean, BigNumber, BigNumber] & {
            approved: boolean;
            indexId: number;
            pendingDistribution: BigNumber;
            publisher: string;
            units: BigNumber;
        }>;
        listSubscriptions(token, subscriber, overrides?): Promise<[string[], number[], BigNumber[]] & {
            indexIds: number[];
            publishers: string[];
            unitsList: BigNumber[];
        }>;
        realtimeBalanceOf(token, account, time, overrides?): Promise<[BigNumber, BigNumber, BigNumber] & {
            deposit: BigNumber;
            dynamicBalance: BigNumber;
            owedDeposit: BigNumber;
        }>;
        revokeSubscription(token, publisher, indexId, ctx, overrides?): Promise<ContractTransaction>;
        updateIndex(token, indexId, indexValue, ctx, overrides?): Promise<ContractTransaction>;
        updateSubscription(token, indexId, subscriber, units, ctx, overrides?): Promise<ContractTransaction>;
    };
    interface: IInstantDistributionAgreementV1Interface;
    off: OnEvent<IInstantDistributionAgreementV1>;
    on: OnEvent<IInstantDistributionAgreementV1>;
    once: OnEvent<IInstantDistributionAgreementV1>;
    populateTransaction: {
        agreementType(overrides?): Promise<PopulatedTransaction>;
        approveSubscription(token, publisher, indexId, ctx, overrides?): Promise<PopulatedTransaction>;
        calculateDistribution(token, publisher, indexId, amount, overrides?): Promise<PopulatedTransaction>;
        claim(token, publisher, indexId, subscriber, ctx, overrides?): Promise<PopulatedTransaction>;
        createIndex(token, indexId, ctx, overrides?): Promise<PopulatedTransaction>;
        deleteSubscription(token, publisher, indexId, subscriber, ctx, overrides?): Promise<PopulatedTransaction>;
        distribute(token, indexId, amount, ctx, overrides?): Promise<PopulatedTransaction>;
        getIndex(token, publisher, indexId, overrides?): Promise<PopulatedTransaction>;
        getSubscription(token, publisher, indexId, subscriber, overrides?): Promise<PopulatedTransaction>;
        getSubscriptionByID(token, agreementId, overrides?): Promise<PopulatedTransaction>;
        listSubscriptions(token, subscriber, overrides?): Promise<PopulatedTransaction>;
        realtimeBalanceOf(token, account, time, overrides?): Promise<PopulatedTransaction>;
        revokeSubscription(token, publisher, indexId, ctx, overrides?): Promise<PopulatedTransaction>;
        updateIndex(token, indexId, indexValue, ctx, overrides?): Promise<PopulatedTransaction>;
        updateSubscription(token, indexId, subscriber, units, ctx, overrides?): Promise<PopulatedTransaction>;
    };
    removeListener: OnEvent<IInstantDistributionAgreementV1>;
    agreementType(overrides?): Promise<string>;
    approveSubscription(token, publisher, indexId, ctx, overrides?): Promise<ContractTransaction>;
    attach(addressOrName): this;
    calculateDistribution(token, publisher, indexId, amount, overrides?): Promise<[BigNumber, BigNumber] & {
        actualAmount: BigNumber;
        newIndexValue: BigNumber;
    }>;
    claim(token, publisher, indexId, subscriber, ctx, overrides?): Promise<ContractTransaction>;
    connect(signerOrProvider): this;
    createIndex(token, indexId, ctx, overrides?): Promise<ContractTransaction>;
    deleteSubscription(token, publisher, indexId, subscriber, ctx, overrides?): Promise<ContractTransaction>;
    deployed(): Promise<IInstantDistributionAgreementV1>;
    distribute(token, indexId, amount, ctx, overrides?): Promise<ContractTransaction>;
    getIndex(token, publisher, indexId, overrides?): Promise<[boolean, BigNumber, BigNumber, BigNumber] & {
        exist: boolean;
        indexValue: BigNumber;
        totalUnitsApproved: BigNumber;
        totalUnitsPending: BigNumber;
    }>;
    getSubscription(token, publisher, indexId, subscriber, overrides?): Promise<[boolean, boolean, BigNumber, BigNumber] & {
        approved: boolean;
        exist: boolean;
        pendingDistribution: BigNumber;
        units: BigNumber;
    }>;
    getSubscriptionByID(token, agreementId, overrides?): Promise<[string, number, boolean, BigNumber, BigNumber] & {
        approved: boolean;
        indexId: number;
        pendingDistribution: BigNumber;
        publisher: string;
        units: BigNumber;
    }>;
    listSubscriptions(token, subscriber, overrides?): Promise<[string[], number[], BigNumber[]] & {
        indexIds: number[];
        publishers: string[];
        unitsList: BigNumber[];
    }>;
    listeners<TEvent>(eventFilter?): TypedListener<TEvent>[];
    listeners(eventName?): Listener[];
    queryFilter<TEvent>(event, fromBlockOrBlockhash?, toBlock?): Promise<TEvent[]>;
    realtimeBalanceOf(token, account, time, overrides?): Promise<[BigNumber, BigNumber, BigNumber] & {
        deposit: BigNumber;
        dynamicBalance: BigNumber;
        owedDeposit: BigNumber;
    }>;
    removeAllListeners<TEvent>(eventFilter): this;
    removeAllListeners(eventName?): this;
    revokeSubscription(token, publisher, indexId, ctx, overrides?): Promise<ContractTransaction>;
    updateIndex(token, indexId, indexValue, ctx, overrides?): Promise<ContractTransaction>;
    updateSubscription(token, indexId, subscriber, units, ctx, overrides?): Promise<ContractTransaction>;
}

Hierarchy

  • BaseContract
    • IInstantDistributionAgreementV1

Properties

callStatic estimateGas filters functions interface off on once populateTransaction removeListener

Methods

agreementType approveSubscription attach calculateDistribution claim connect createIndex deleteSubscription deployed distribute getIndex getSubscription getSubscriptionByID listSubscriptions listeners queryFilter realtimeBalanceOf removeAllListeners revokeSubscription updateIndex updateSubscription

Properties

callStatic

callStatic: {
    agreementType(overrides?): Promise<string>;
    approveSubscription(token, publisher, indexId, ctx, overrides?): Promise<string>;
    calculateDistribution(token, publisher, indexId, amount, overrides?): Promise<[BigNumber, BigNumber] & {
        actualAmount: BigNumber;
        newIndexValue: BigNumber;
    }>;
    claim(token, publisher, indexId, subscriber, ctx, overrides?): Promise<string>;
    createIndex(token, indexId, ctx, overrides?): Promise<string>;
    deleteSubscription(token, publisher, indexId, subscriber, ctx, overrides?): Promise<string>;
    distribute(token, indexId, amount, ctx, overrides?): Promise<string>;
    getIndex(token, publisher, indexId, overrides?): Promise<[boolean, BigNumber, BigNumber, BigNumber] & {
        exist: boolean;
        indexValue: BigNumber;
        totalUnitsApproved: BigNumber;
        totalUnitsPending: BigNumber;
    }>;
    getSubscription(token, publisher, indexId, subscriber, overrides?): Promise<[boolean, boolean, BigNumber, BigNumber] & {
        approved: boolean;
        exist: boolean;
        pendingDistribution: BigNumber;
        units: BigNumber;
    }>;
    getSubscriptionByID(token, agreementId, overrides?): Promise<[string, number, boolean, BigNumber, BigNumber] & {
        approved: boolean;
        indexId: number;
        pendingDistribution: BigNumber;
        publisher: string;
        units: BigNumber;
    }>;
    listSubscriptions(token, subscriber, overrides?): Promise<[string[], number[], BigNumber[]] & {
        indexIds: number[];
        publishers: string[];
        unitsList: BigNumber[];
    }>;
    realtimeBalanceOf(token, account, time, overrides?): Promise<[BigNumber, BigNumber, BigNumber] & {
        deposit: BigNumber;
        dynamicBalance: BigNumber;
        owedDeposit: BigNumber;
    }>;
    revokeSubscription(token, publisher, indexId, ctx, overrides?): Promise<string>;
    updateIndex(token, indexId, indexValue, ctx, overrides?): Promise<string>;
    updateSubscription(token, indexId, subscriber, units, ctx, overrides?): Promise<string>;
}

Type declaration

  • agreementType:function
    • agreementType(overrides?): Promise<string>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<string>

  • approveSubscription:function
    • approveSubscription(token, publisher, indexId, ctx, overrides?): Promise<string>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • ctx: BytesLike
      • Optional overrides: CallOverrides

      Returns Promise<string>

  • calculateDistribution:function
    • calculateDistribution(token, publisher, indexId, amount, overrides?): Promise<[BigNumber, BigNumber] & {
          actualAmount: BigNumber;
          newIndexValue: BigNumber;
      }>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • amount: BigNumberish
      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber, BigNumber] & {
          actualAmount: BigNumber;
          newIndexValue: BigNumber;
      }>

  • claim:function
    • claim(token, publisher, indexId, subscriber, ctx, overrides?): Promise<string>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • subscriber: string
      • ctx: BytesLike
      • Optional overrides: CallOverrides

      Returns Promise<string>

  • createIndex:function
    • createIndex(token, indexId, ctx, overrides?): Promise<string>

    • Parameters

      • token: string
      • indexId: BigNumberish
      • ctx: BytesLike
      • Optional overrides: CallOverrides

      Returns Promise<string>

  • deleteSubscription:function
    • deleteSubscription(token, publisher, indexId, subscriber, ctx, overrides?): Promise<string>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • subscriber: string
      • ctx: BytesLike
      • Optional overrides: CallOverrides

      Returns Promise<string>

  • distribute:function
    • distribute(token, indexId, amount, ctx, overrides?): Promise<string>

    • Parameters

      • token: string
      • indexId: BigNumberish
      • amount: BigNumberish
      • ctx: BytesLike
      • Optional overrides: CallOverrides

      Returns Promise<string>

  • getIndex:function
    • getIndex(token, publisher, indexId, overrides?): Promise<[boolean, BigNumber, BigNumber, BigNumber] & {
          exist: boolean;
          indexValue: BigNumber;
          totalUnitsApproved: BigNumber;
          totalUnitsPending: BigNumber;
      }>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • Optional overrides: CallOverrides

      Returns Promise<[boolean, BigNumber, BigNumber, BigNumber] & {
          exist: boolean;
          indexValue: BigNumber;
          totalUnitsApproved: BigNumber;
          totalUnitsPending: BigNumber;
      }>

  • getSubscription:function
    • getSubscription(token, publisher, indexId, subscriber, overrides?): Promise<[boolean, boolean, BigNumber, BigNumber] & {
          approved: boolean;
          exist: boolean;
          pendingDistribution: BigNumber;
          units: BigNumber;
      }>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • subscriber: string
      • Optional overrides: CallOverrides

      Returns Promise<[boolean, boolean, BigNumber, BigNumber] & {
          approved: boolean;
          exist: boolean;
          pendingDistribution: BigNumber;
          units: BigNumber;
      }>

  • getSubscriptionByID:function
    • getSubscriptionByID(token, agreementId, overrides?): Promise<[string, number, boolean, BigNumber, BigNumber] & {
          approved: boolean;
          indexId: number;
          pendingDistribution: BigNumber;
          publisher: string;
          units: BigNumber;
      }>

    • Parameters

      • token: string
      • agreementId: BytesLike
      • Optional overrides: CallOverrides

      Returns Promise<[string, number, boolean, BigNumber, BigNumber] & {
          approved: boolean;
          indexId: number;
          pendingDistribution: BigNumber;
          publisher: string;
          units: BigNumber;
      }>

  • listSubscriptions:function
    • listSubscriptions(token, subscriber, overrides?): Promise<[string[], number[], BigNumber[]] & {
          indexIds: number[];
          publishers: string[];
          unitsList: BigNumber[];
      }>

    • Parameters

      • token: string
      • subscriber: string
      • Optional overrides: CallOverrides

      Returns Promise<[string[], number[], BigNumber[]] & {
          indexIds: number[];
          publishers: string[];
          unitsList: BigNumber[];
      }>

  • realtimeBalanceOf:function
    • realtimeBalanceOf(token, account, time, overrides?): Promise<[BigNumber, BigNumber, BigNumber] & {
          deposit: BigNumber;
          dynamicBalance: BigNumber;
          owedDeposit: BigNumber;
      }>

    • Parameters

      • token: string
      • account: string
      • time: BigNumberish
      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber, BigNumber, BigNumber] & {
          deposit: BigNumber;
          dynamicBalance: BigNumber;
          owedDeposit: BigNumber;
      }>

  • revokeSubscription:function
    • revokeSubscription(token, publisher, indexId, ctx, overrides?): Promise<string>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • ctx: BytesLike
      • Optional overrides: CallOverrides

      Returns Promise<string>

  • updateIndex:function
    • updateIndex(token, indexId, indexValue, ctx, overrides?): Promise<string>

    • Parameters

      • token: string
      • indexId: BigNumberish
      • indexValue: BigNumberish
      • ctx: BytesLike
      • Optional overrides: CallOverrides

      Returns Promise<string>

  • updateSubscription:function
    • updateSubscription(token, indexId, subscriber, units, ctx, overrides?): Promise<string>

    • Parameters

      • token: string
      • indexId: BigNumberish
      • subscriber: string
      • units: BigNumberish
      • ctx: BytesLike
      • Optional overrides: CallOverrides

      Returns Promise<string>

estimateGas

estimateGas: {
    agreementType(overrides?): Promise<BigNumber>;
    approveSubscription(token, publisher, indexId, ctx, overrides?): Promise<BigNumber>;
    calculateDistribution(token, publisher, indexId, amount, overrides?): Promise<BigNumber>;
    claim(token, publisher, indexId, subscriber, ctx, overrides?): Promise<BigNumber>;
    createIndex(token, indexId, ctx, overrides?): Promise<BigNumber>;
    deleteSubscription(token, publisher, indexId, subscriber, ctx, overrides?): Promise<BigNumber>;
    distribute(token, indexId, amount, ctx, overrides?): Promise<BigNumber>;
    getIndex(token, publisher, indexId, overrides?): Promise<BigNumber>;
    getSubscription(token, publisher, indexId, subscriber, overrides?): Promise<BigNumber>;
    getSubscriptionByID(token, agreementId, overrides?): Promise<BigNumber>;
    listSubscriptions(token, subscriber, overrides?): Promise<BigNumber>;
    realtimeBalanceOf(token, account, time, overrides?): Promise<BigNumber>;
    revokeSubscription(token, publisher, indexId, ctx, overrides?): Promise<BigNumber>;
    updateIndex(token, indexId, indexValue, ctx, overrides?): Promise<BigNumber>;
    updateSubscription(token, indexId, subscriber, units, ctx, overrides?): Promise<BigNumber>;
}

Type declaration

  • agreementType:function
    • agreementType(overrides?): Promise<BigNumber>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • approveSubscription:function
    • approveSubscription(token, publisher, indexId, ctx, overrides?): Promise<BigNumber>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • ctx: BytesLike
      • Optional overrides: Overrides & {
            from?: string;
        }

      Returns Promise<BigNumber>

  • calculateDistribution:function
    • calculateDistribution(token, publisher, indexId, amount, overrides?): Promise<BigNumber>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • amount: BigNumberish
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • claim:function
    • claim(token, publisher, indexId, subscriber, ctx, overrides?): Promise<BigNumber>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • subscriber: string
      • ctx: BytesLike
      • Optional overrides: Overrides & {
            from?: string;
        }

      Returns Promise<BigNumber>

  • createIndex:function
    • createIndex(token, indexId, ctx, overrides?): Promise<BigNumber>

    • Parameters

      • token: string
      • indexId: BigNumberish
      • ctx: BytesLike
      • Optional overrides: Overrides & {
            from?: string;
        }

      Returns Promise<BigNumber>

  • deleteSubscription:function
    • deleteSubscription(token, publisher, indexId, subscriber, ctx, overrides?): Promise<BigNumber>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • subscriber: string
      • ctx: BytesLike
      • Optional overrides: Overrides & {
            from?: string;
        }

      Returns Promise<BigNumber>

  • distribute:function
    • distribute(token, indexId, amount, ctx, overrides?): Promise<BigNumber>

    • Parameters

      • token: string
      • indexId: BigNumberish
      • amount: BigNumberish
      • ctx: BytesLike
      • Optional overrides: Overrides & {
            from?: string;
        }

      Returns Promise<BigNumber>

  • getIndex:function
    • getIndex(token, publisher, indexId, overrides?): Promise<BigNumber>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getSubscription:function
    • getSubscription(token, publisher, indexId, subscriber, overrides?): Promise<BigNumber>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • subscriber: string
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • getSubscriptionByID:function
    • getSubscriptionByID(token, agreementId, overrides?): Promise<BigNumber>

    • Parameters

      • token: string
      • agreementId: BytesLike
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • listSubscriptions:function
    • listSubscriptions(token, subscriber, overrides?): Promise<BigNumber>

    • Parameters

      • token: string
      • subscriber: string
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • realtimeBalanceOf:function
    • realtimeBalanceOf(token, account, time, overrides?): Promise<BigNumber>

    • Parameters

      • token: string
      • account: string
      • time: BigNumberish
      • Optional overrides: CallOverrides

      Returns Promise<BigNumber>

  • revokeSubscription:function
    • revokeSubscription(token, publisher, indexId, ctx, overrides?): Promise<BigNumber>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • ctx: BytesLike
      • Optional overrides: Overrides & {
            from?: string;
        }

      Returns Promise<BigNumber>

  • updateIndex:function
    • updateIndex(token, indexId, indexValue, ctx, overrides?): Promise<BigNumber>

    • Parameters

      • token: string
      • indexId: BigNumberish
      • indexValue: BigNumberish
      • ctx: BytesLike
      • Optional overrides: Overrides & {
            from?: string;
        }

      Returns Promise<BigNumber>

  • updateSubscription:function
    • updateSubscription(token, indexId, subscriber, units, ctx, overrides?): Promise<BigNumber>

    • Parameters

      • token: string
      • indexId: BigNumberish
      • subscriber: string
      • units: BigNumberish
      • ctx: BytesLike
      • Optional overrides: Overrides & {
            from?: string;
        }

      Returns Promise<BigNumber>

filters

filters: {
    IndexCreated(token?, publisher?, indexId?, userData?): IndexCreatedEventFilter;
    IndexCreated(address,address,uint32,bytes)(token?, publisher?, indexId?, userData?): IndexCreatedEventFilter;
    IndexDistributionClaimed(token?, publisher?, indexId?, subscriber?, amount?): IndexDistributionClaimedEventFilter;
    IndexDistributionClaimed(address,address,uint32,address,uint256)(token?, publisher?, indexId?, subscriber?, amount?): IndexDistributionClaimedEventFilter;
    IndexSubscribed(token?, publisher?, indexId?, subscriber?, userData?): IndexSubscribedEventFilter;
    IndexSubscribed(address,address,uint32,address,bytes)(token?, publisher?, indexId?, subscriber?, userData?): IndexSubscribedEventFilter;
    IndexUnitsUpdated(token?, publisher?, indexId?, subscriber?, units?, userData?): IndexUnitsUpdatedEventFilter;
    IndexUnitsUpdated(address,address,uint32,address,uint128,bytes)(token?, publisher?, indexId?, subscriber?, units?, userData?): IndexUnitsUpdatedEventFilter;
    IndexUnsubscribed(token?, publisher?, indexId?, subscriber?, userData?): IndexUnsubscribedEventFilter;
    IndexUnsubscribed(address,address,uint32,address,bytes)(token?, publisher?, indexId?, subscriber?, userData?): IndexUnsubscribedEventFilter;
    IndexUpdated(token?, publisher?, indexId?, oldIndexValue?, newIndexValue?, totalUnitsPending?, totalUnitsApproved?, userData?): IndexUpdatedEventFilter;
    IndexUpdated(address,address,uint32,uint128,uint128,uint128,uint128,bytes)(token?, publisher?, indexId?, oldIndexValue?, newIndexValue?, totalUnitsPending?, totalUnitsApproved?, userData?): IndexUpdatedEventFilter;
    SubscriptionApproved(token?, subscriber?, publisher?, indexId?, userData?): SubscriptionApprovedEventFilter;
    SubscriptionApproved(address,address,address,uint32,bytes)(token?, subscriber?, publisher?, indexId?, userData?): SubscriptionApprovedEventFilter;
    SubscriptionDistributionClaimed(token?, subscriber?, publisher?, indexId?, amount?): SubscriptionDistributionClaimedEventFilter;
    SubscriptionDistributionClaimed(address,address,address,uint32,uint256)(token?, subscriber?, publisher?, indexId?, amount?): SubscriptionDistributionClaimedEventFilter;
    SubscriptionRevoked(token?, subscriber?, publisher?, indexId?, userData?): SubscriptionRevokedEventFilter;
    SubscriptionRevoked(address,address,address,uint32,bytes)(token?, subscriber?, publisher?, indexId?, userData?): SubscriptionRevokedEventFilter;
    SubscriptionUnitsUpdated(token?, subscriber?, publisher?, indexId?, units?, userData?): SubscriptionUnitsUpdatedEventFilter;
    SubscriptionUnitsUpdated(address,address,address,uint32,uint128,bytes)(token?, subscriber?, publisher?, indexId?, units?, userData?): SubscriptionUnitsUpdatedEventFilter;
}

Type declaration

  • IndexCreated:function
    • IndexCreated(token?, publisher?, indexId?, userData?): IndexCreatedEventFilter

    • Parameters

      • Optional token: null | string
      • Optional publisher: null | string
      • Optional indexId: null | BigNumberish
      • Optional userData: null

      Returns IndexCreatedEventFilter

  • IndexCreated(address,address,uint32,bytes):function
    • IndexCreated(address,address,uint32,bytes)(token?, publisher?, indexId?, userData?): IndexCreatedEventFilter

    • Parameters

      • Optional token: null | string
      • Optional publisher: null | string
      • Optional indexId: null | BigNumberish
      • Optional userData: null

      Returns IndexCreatedEventFilter

  • IndexDistributionClaimed:function
    • IndexDistributionClaimed(token?, publisher?, indexId?, subscriber?, amount?): IndexDistributionClaimedEventFilter

    • Parameters

      • Optional token: null | string
      • Optional publisher: null | string
      • Optional indexId: null | BigNumberish
      • Optional subscriber: null
      • Optional amount: null

      Returns IndexDistributionClaimedEventFilter

  • IndexDistributionClaimed(address,address,uint32,address,uint256):function
    • IndexDistributionClaimed(address,address,uint32,address,uint256)(token?, publisher?, indexId?, subscriber?, amount?): IndexDistributionClaimedEventFilter

    • Parameters

      • Optional token: null | string
      • Optional publisher: null | string
      • Optional indexId: null | BigNumberish
      • Optional subscriber: null
      • Optional amount: null

      Returns IndexDistributionClaimedEventFilter

  • IndexSubscribed:function
    • IndexSubscribed(token?, publisher?, indexId?, subscriber?, userData?): IndexSubscribedEventFilter

    • Parameters

      • Optional token: null | string
      • Optional publisher: null | string
      • Optional indexId: null | BigNumberish
      • Optional subscriber: null
      • Optional userData: null

      Returns IndexSubscribedEventFilter

  • IndexSubscribed(address,address,uint32,address,bytes):function
    • IndexSubscribed(address,address,uint32,address,bytes)(token?, publisher?, indexId?, subscriber?, userData?): IndexSubscribedEventFilter

    • Parameters

      • Optional token: null | string
      • Optional publisher: null | string
      • Optional indexId: null | BigNumberish
      • Optional subscriber: null
      • Optional userData: null

      Returns IndexSubscribedEventFilter

  • IndexUnitsUpdated:function
    • IndexUnitsUpdated(token?, publisher?, indexId?, subscriber?, units?, userData?): IndexUnitsUpdatedEventFilter

    • Parameters

      • Optional token: null | string
      • Optional publisher: null | string
      • Optional indexId: null | BigNumberish
      • Optional subscriber: null
      • Optional units: null
      • Optional userData: null

      Returns IndexUnitsUpdatedEventFilter

  • IndexUnitsUpdated(address,address,uint32,address,uint128,bytes):function
    • IndexUnitsUpdated(address,address,uint32,address,uint128,bytes)(token?, publisher?, indexId?, subscriber?, units?, userData?): IndexUnitsUpdatedEventFilter

    • Parameters

      • Optional token: null | string
      • Optional publisher: null | string
      • Optional indexId: null | BigNumberish
      • Optional subscriber: null
      • Optional units: null
      • Optional userData: null

      Returns IndexUnitsUpdatedEventFilter

  • IndexUnsubscribed:function
    • IndexUnsubscribed(token?, publisher?, indexId?, subscriber?, userData?): IndexUnsubscribedEventFilter

    • Parameters

      • Optional token: null | string
      • Optional publisher: null | string
      • Optional indexId: null | BigNumberish
      • Optional subscriber: null
      • Optional userData: null

      Returns IndexUnsubscribedEventFilter

  • IndexUnsubscribed(address,address,uint32,address,bytes):function
    • IndexUnsubscribed(address,address,uint32,address,bytes)(token?, publisher?, indexId?, subscriber?, userData?): IndexUnsubscribedEventFilter

    • Parameters

      • Optional token: null | string
      • Optional publisher: null | string
      • Optional indexId: null | BigNumberish
      • Optional subscriber: null
      • Optional userData: null

      Returns IndexUnsubscribedEventFilter

  • IndexUpdated:function
    • IndexUpdated(token?, publisher?, indexId?, oldIndexValue?, newIndexValue?, totalUnitsPending?, totalUnitsApproved?, userData?): IndexUpdatedEventFilter

    • Parameters

      • Optional token: null | string
      • Optional publisher: null | string
      • Optional indexId: null | BigNumberish
      • Optional oldIndexValue: null
      • Optional newIndexValue: null
      • Optional totalUnitsPending: null
      • Optional totalUnitsApproved: null
      • Optional userData: null

      Returns IndexUpdatedEventFilter

  • IndexUpdated(address,address,uint32,uint128,uint128,uint128,uint128,bytes):function
    • IndexUpdated(address,address,uint32,uint128,uint128,uint128,uint128,bytes)(token?, publisher?, indexId?, oldIndexValue?, newIndexValue?, totalUnitsPending?, totalUnitsApproved?, userData?): IndexUpdatedEventFilter

    • Parameters

      • Optional token: null | string
      • Optional publisher: null | string
      • Optional indexId: null | BigNumberish
      • Optional oldIndexValue: null
      • Optional newIndexValue: null
      • Optional totalUnitsPending: null
      • Optional totalUnitsApproved: null
      • Optional userData: null

      Returns IndexUpdatedEventFilter

  • SubscriptionApproved:function
    • SubscriptionApproved(token?, subscriber?, publisher?, indexId?, userData?): SubscriptionApprovedEventFilter

    • Parameters

      • Optional token: null | string
      • Optional subscriber: null | string
      • Optional publisher: null
      • Optional indexId: null
      • Optional userData: null

      Returns SubscriptionApprovedEventFilter

  • SubscriptionApproved(address,address,address,uint32,bytes):function
    • SubscriptionApproved(address,address,address,uint32,bytes)(token?, subscriber?, publisher?, indexId?, userData?): SubscriptionApprovedEventFilter

    • Parameters

      • Optional token: null | string
      • Optional subscriber: null | string
      • Optional publisher: null
      • Optional indexId: null
      • Optional userData: null

      Returns SubscriptionApprovedEventFilter

  • SubscriptionDistributionClaimed:function
    • SubscriptionDistributionClaimed(token?, subscriber?, publisher?, indexId?, amount?): SubscriptionDistributionClaimedEventFilter

    • Parameters

      • Optional token: null | string
      • Optional subscriber: null | string
      • Optional publisher: null
      • Optional indexId: null
      • Optional amount: null

      Returns SubscriptionDistributionClaimedEventFilter

  • SubscriptionDistributionClaimed(address,address,address,uint32,uint256):function
    • SubscriptionDistributionClaimed(address,address,address,uint32,uint256)(token?, subscriber?, publisher?, indexId?, amount?): SubscriptionDistributionClaimedEventFilter

    • Parameters

      • Optional token: null | string
      • Optional subscriber: null | string
      • Optional publisher: null
      • Optional indexId: null
      • Optional amount: null

      Returns SubscriptionDistributionClaimedEventFilter

  • SubscriptionRevoked:function
    • SubscriptionRevoked(token?, subscriber?, publisher?, indexId?, userData?): SubscriptionRevokedEventFilter

    • Parameters

      • Optional token: null | string
      • Optional subscriber: null | string
      • Optional publisher: null
      • Optional indexId: null
      • Optional userData: null

      Returns SubscriptionRevokedEventFilter

  • SubscriptionRevoked(address,address,address,uint32,bytes):function
    • SubscriptionRevoked(address,address,address,uint32,bytes)(token?, subscriber?, publisher?, indexId?, userData?): SubscriptionRevokedEventFilter

    • Parameters

      • Optional token: null | string
      • Optional subscriber: null | string
      • Optional publisher: null
      • Optional indexId: null
      • Optional userData: null

      Returns SubscriptionRevokedEventFilter

  • SubscriptionUnitsUpdated:function
    • SubscriptionUnitsUpdated(token?, subscriber?, publisher?, indexId?, units?, userData?): SubscriptionUnitsUpdatedEventFilter

    • Parameters

      • Optional token: null | string
      • Optional subscriber: null | string
      • Optional publisher: null
      • Optional indexId: null
      • Optional units: null
      • Optional userData: null

      Returns SubscriptionUnitsUpdatedEventFilter

  • SubscriptionUnitsUpdated(address,address,address,uint32,uint128,bytes):function
    • SubscriptionUnitsUpdated(address,address,address,uint32,uint128,bytes)(token?, subscriber?, publisher?, indexId?, units?, userData?): SubscriptionUnitsUpdatedEventFilter

    • Parameters

      • Optional token: null | string
      • Optional subscriber: null | string
      • Optional publisher: null
      • Optional indexId: null
      • Optional units: null
      • Optional userData: null

      Returns SubscriptionUnitsUpdatedEventFilter

functions

functions: {
    agreementType(overrides?): Promise<[string]>;
    approveSubscription(token, publisher, indexId, ctx, overrides?): Promise<ContractTransaction>;
    calculateDistribution(token, publisher, indexId, amount, overrides?): Promise<[BigNumber, BigNumber] & {
        actualAmount: BigNumber;
        newIndexValue: BigNumber;
    }>;
    claim(token, publisher, indexId, subscriber, ctx, overrides?): Promise<ContractTransaction>;
    createIndex(token, indexId, ctx, overrides?): Promise<ContractTransaction>;
    deleteSubscription(token, publisher, indexId, subscriber, ctx, overrides?): Promise<ContractTransaction>;
    distribute(token, indexId, amount, ctx, overrides?): Promise<ContractTransaction>;
    getIndex(token, publisher, indexId, overrides?): Promise<[boolean, BigNumber, BigNumber, BigNumber] & {
        exist: boolean;
        indexValue: BigNumber;
        totalUnitsApproved: BigNumber;
        totalUnitsPending: BigNumber;
    }>;
    getSubscription(token, publisher, indexId, subscriber, overrides?): Promise<[boolean, boolean, BigNumber, BigNumber] & {
        approved: boolean;
        exist: boolean;
        pendingDistribution: BigNumber;
        units: BigNumber;
    }>;
    getSubscriptionByID(token, agreementId, overrides?): Promise<[string, number, boolean, BigNumber, BigNumber] & {
        approved: boolean;
        indexId: number;
        pendingDistribution: BigNumber;
        publisher: string;
        units: BigNumber;
    }>;
    listSubscriptions(token, subscriber, overrides?): Promise<[string[], number[], BigNumber[]] & {
        indexIds: number[];
        publishers: string[];
        unitsList: BigNumber[];
    }>;
    realtimeBalanceOf(token, account, time, overrides?): Promise<[BigNumber, BigNumber, BigNumber] & {
        deposit: BigNumber;
        dynamicBalance: BigNumber;
        owedDeposit: BigNumber;
    }>;
    revokeSubscription(token, publisher, indexId, ctx, overrides?): Promise<ContractTransaction>;
    updateIndex(token, indexId, indexValue, ctx, overrides?): Promise<ContractTransaction>;
    updateSubscription(token, indexId, subscriber, units, ctx, overrides?): Promise<ContractTransaction>;
}

Type declaration

  • agreementType:function
    • agreementType(overrides?): Promise<[string]>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<[string]>

  • approveSubscription:function
    • approveSubscription(token, publisher, indexId, ctx, overrides?): Promise<ContractTransaction>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • ctx: BytesLike
      • Optional overrides: Overrides & {
            from?: string;
        }

      Returns Promise<ContractTransaction>

  • calculateDistribution:function
    • calculateDistribution(token, publisher, indexId, amount, overrides?): Promise<[BigNumber, BigNumber] & {
          actualAmount: BigNumber;
          newIndexValue: BigNumber;
      }>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • amount: BigNumberish
      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber, BigNumber] & {
          actualAmount: BigNumber;
          newIndexValue: BigNumber;
      }>

  • claim:function
    • claim(token, publisher, indexId, subscriber, ctx, overrides?): Promise<ContractTransaction>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • subscriber: string
      • ctx: BytesLike
      • Optional overrides: Overrides & {
            from?: string;
        }

      Returns Promise<ContractTransaction>

  • createIndex:function
    • createIndex(token, indexId, ctx, overrides?): Promise<ContractTransaction>

    • Parameters

      • token: string
      • indexId: BigNumberish
      • ctx: BytesLike
      • Optional overrides: Overrides & {
            from?: string;
        }

      Returns Promise<ContractTransaction>

  • deleteSubscription:function
    • deleteSubscription(token, publisher, indexId, subscriber, ctx, overrides?): Promise<ContractTransaction>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • subscriber: string
      • ctx: BytesLike
      • Optional overrides: Overrides & {
            from?: string;
        }

      Returns Promise<ContractTransaction>

  • distribute:function
    • distribute(token, indexId, amount, ctx, overrides?): Promise<ContractTransaction>

    • Parameters

      • token: string
      • indexId: BigNumberish
      • amount: BigNumberish
      • ctx: BytesLike
      • Optional overrides: Overrides & {
            from?: string;
        }

      Returns Promise<ContractTransaction>

  • getIndex:function
    • getIndex(token, publisher, indexId, overrides?): Promise<[boolean, BigNumber, BigNumber, BigNumber] & {
          exist: boolean;
          indexValue: BigNumber;
          totalUnitsApproved: BigNumber;
          totalUnitsPending: BigNumber;
      }>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • Optional overrides: CallOverrides

      Returns Promise<[boolean, BigNumber, BigNumber, BigNumber] & {
          exist: boolean;
          indexValue: BigNumber;
          totalUnitsApproved: BigNumber;
          totalUnitsPending: BigNumber;
      }>

  • getSubscription:function
    • getSubscription(token, publisher, indexId, subscriber, overrides?): Promise<[boolean, boolean, BigNumber, BigNumber] & {
          approved: boolean;
          exist: boolean;
          pendingDistribution: BigNumber;
          units: BigNumber;
      }>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • subscriber: string
      • Optional overrides: CallOverrides

      Returns Promise<[boolean, boolean, BigNumber, BigNumber] & {
          approved: boolean;
          exist: boolean;
          pendingDistribution: BigNumber;
          units: BigNumber;
      }>

  • getSubscriptionByID:function
    • getSubscriptionByID(token, agreementId, overrides?): Promise<[string, number, boolean, BigNumber, BigNumber] & {
          approved: boolean;
          indexId: number;
          pendingDistribution: BigNumber;
          publisher: string;
          units: BigNumber;
      }>

    • Parameters

      • token: string
      • agreementId: BytesLike
      • Optional overrides: CallOverrides

      Returns Promise<[string, number, boolean, BigNumber, BigNumber] & {
          approved: boolean;
          indexId: number;
          pendingDistribution: BigNumber;
          publisher: string;
          units: BigNumber;
      }>

  • listSubscriptions:function
    • listSubscriptions(token, subscriber, overrides?): Promise<[string[], number[], BigNumber[]] & {
          indexIds: number[];
          publishers: string[];
          unitsList: BigNumber[];
      }>

    • Parameters

      • token: string
      • subscriber: string
      • Optional overrides: CallOverrides

      Returns Promise<[string[], number[], BigNumber[]] & {
          indexIds: number[];
          publishers: string[];
          unitsList: BigNumber[];
      }>

  • realtimeBalanceOf:function
    • realtimeBalanceOf(token, account, time, overrides?): Promise<[BigNumber, BigNumber, BigNumber] & {
          deposit: BigNumber;
          dynamicBalance: BigNumber;
          owedDeposit: BigNumber;
      }>

    • Parameters

      • token: string
      • account: string
      • time: BigNumberish
      • Optional overrides: CallOverrides

      Returns Promise<[BigNumber, BigNumber, BigNumber] & {
          deposit: BigNumber;
          dynamicBalance: BigNumber;
          owedDeposit: BigNumber;
      }>

  • revokeSubscription:function
    • revokeSubscription(token, publisher, indexId, ctx, overrides?): Promise<ContractTransaction>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • ctx: BytesLike
      • Optional overrides: Overrides & {
            from?: string;
        }

      Returns Promise<ContractTransaction>

  • updateIndex:function
    • updateIndex(token, indexId, indexValue, ctx, overrides?): Promise<ContractTransaction>

    • Parameters

      • token: string
      • indexId: BigNumberish
      • indexValue: BigNumberish
      • ctx: BytesLike
      • Optional overrides: Overrides & {
            from?: string;
        }

      Returns Promise<ContractTransaction>

  • updateSubscription:function
    • updateSubscription(token, indexId, subscriber, units, ctx, overrides?): Promise<ContractTransaction>

    • Parameters

      • token: string
      • indexId: BigNumberish
      • subscriber: string
      • units: BigNumberish
      • ctx: BytesLike
      • Optional overrides: Overrides & {
            from?: string;
        }

      Returns Promise<ContractTransaction>

interface

interface: IInstantDistributionAgreementV1Interface

off

off: OnEvent<IInstantDistributionAgreementV1>

on

on: OnEvent<IInstantDistributionAgreementV1>

once

once: OnEvent<IInstantDistributionAgreementV1>

populateTransaction

populateTransaction: {
    agreementType(overrides?): Promise<PopulatedTransaction>;
    approveSubscription(token, publisher, indexId, ctx, overrides?): Promise<PopulatedTransaction>;
    calculateDistribution(token, publisher, indexId, amount, overrides?): Promise<PopulatedTransaction>;
    claim(token, publisher, indexId, subscriber, ctx, overrides?): Promise<PopulatedTransaction>;
    createIndex(token, indexId, ctx, overrides?): Promise<PopulatedTransaction>;
    deleteSubscription(token, publisher, indexId, subscriber, ctx, overrides?): Promise<PopulatedTransaction>;
    distribute(token, indexId, amount, ctx, overrides?): Promise<PopulatedTransaction>;
    getIndex(token, publisher, indexId, overrides?): Promise<PopulatedTransaction>;
    getSubscription(token, publisher, indexId, subscriber, overrides?): Promise<PopulatedTransaction>;
    getSubscriptionByID(token, agreementId, overrides?): Promise<PopulatedTransaction>;
    listSubscriptions(token, subscriber, overrides?): Promise<PopulatedTransaction>;
    realtimeBalanceOf(token, account, time, overrides?): Promise<PopulatedTransaction>;
    revokeSubscription(token, publisher, indexId, ctx, overrides?): Promise<PopulatedTransaction>;
    updateIndex(token, indexId, indexValue, ctx, overrides?): Promise<PopulatedTransaction>;
    updateSubscription(token, indexId, subscriber, units, ctx, overrides?): Promise<PopulatedTransaction>;
}

Type declaration

  • agreementType:function
    • agreementType(overrides?): Promise<PopulatedTransaction>

    • Parameters

      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • approveSubscription:function
    • approveSubscription(token, publisher, indexId, ctx, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • ctx: BytesLike
      • Optional overrides: Overrides & {
            from?: string;
        }

      Returns Promise<PopulatedTransaction>

  • calculateDistribution:function
    • calculateDistribution(token, publisher, indexId, amount, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • amount: BigNumberish
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • claim:function
    • claim(token, publisher, indexId, subscriber, ctx, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • subscriber: string
      • ctx: BytesLike
      • Optional overrides: Overrides & {
            from?: string;
        }

      Returns Promise<PopulatedTransaction>

  • createIndex:function
    • createIndex(token, indexId, ctx, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • token: string
      • indexId: BigNumberish
      • ctx: BytesLike
      • Optional overrides: Overrides & {
            from?: string;
        }

      Returns Promise<PopulatedTransaction>

  • deleteSubscription:function
    • deleteSubscription(token, publisher, indexId, subscriber, ctx, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • subscriber: string
      • ctx: BytesLike
      • Optional overrides: Overrides & {
            from?: string;
        }

      Returns Promise<PopulatedTransaction>

  • distribute:function
    • distribute(token, indexId, amount, ctx, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • token: string
      • indexId: BigNumberish
      • amount: BigNumberish
      • ctx: BytesLike
      • Optional overrides: Overrides & {
            from?: string;
        }

      Returns Promise<PopulatedTransaction>

  • getIndex:function
    • getIndex(token, publisher, indexId, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • getSubscription:function
    • getSubscription(token, publisher, indexId, subscriber, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • subscriber: string
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • getSubscriptionByID:function
    • getSubscriptionByID(token, agreementId, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • token: string
      • agreementId: BytesLike
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • listSubscriptions:function
    • listSubscriptions(token, subscriber, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • token: string
      • subscriber: string
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • realtimeBalanceOf:function
    • realtimeBalanceOf(token, account, time, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • token: string
      • account: string
      • time: BigNumberish
      • Optional overrides: CallOverrides

      Returns Promise<PopulatedTransaction>

  • revokeSubscription:function
    • revokeSubscription(token, publisher, indexId, ctx, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • token: string
      • publisher: string
      • indexId: BigNumberish
      • ctx: BytesLike
      • Optional overrides: Overrides & {
            from?: string;
        }

      Returns Promise<PopulatedTransaction>

  • updateIndex:function
    • updateIndex(token, indexId, indexValue, ctx, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • token: string
      • indexId: BigNumberish
      • indexValue: BigNumberish
      • ctx: BytesLike
      • Optional overrides: Overrides & {
            from?: string;
        }

      Returns Promise<PopulatedTransaction>

  • updateSubscription:function
    • updateSubscription(token, indexId, subscriber, units, ctx, overrides?): Promise<PopulatedTransaction>

    • Parameters

      • token: string
      • indexId: BigNumberish
      • subscriber: string
      • units: BigNumberish
      • ctx: BytesLike
      • Optional overrides: Overrides & {
            from?: string;
        }

      Returns Promise<PopulatedTransaction>

removeListener

removeListener: OnEvent<IInstantDistributionAgreementV1>

Methods

agreementType

  • agreementType(overrides?): Promise<string>

  • Parameters

    • Optional overrides: CallOverrides

    Returns Promise<string>

approveSubscription

  • approveSubscription(token, publisher, indexId, ctx, overrides?): Promise<ContractTransaction>

  • Parameters

    • token: string
    • publisher: string
    • indexId: BigNumberish
    • ctx: BytesLike
    • Optional overrides: Overrides & {
          from?: string;
      }

    Returns Promise<ContractTransaction>

attach

  • attach(addressOrName): this

  • Parameters

    • addressOrName: string

    Returns this

calculateDistribution

  • calculateDistribution(token, publisher, indexId, amount, overrides?): Promise<[BigNumber, BigNumber] & {
        actualAmount: BigNumber;
        newIndexValue: BigNumber;
    }>

  • Parameters

    • token: string
    • publisher: string
    • indexId: BigNumberish
    • amount: BigNumberish
    • Optional overrides: CallOverrides

    Returns Promise<[BigNumber, BigNumber] & {
        actualAmount: BigNumber;
        newIndexValue: BigNumber;
    }>

claim

  • claim(token, publisher, indexId, subscriber, ctx, overrides?): Promise<ContractTransaction>

  • Parameters

    • token: string
    • publisher: string
    • indexId: BigNumberish
    • subscriber: string
    • ctx: BytesLike
    • Optional overrides: Overrides & {
          from?: string;
      }

    Returns Promise<ContractTransaction>

connect

  • connect(signerOrProvider): this

  • Parameters

    • signerOrProvider: string | Signer | Provider

    Returns this

createIndex

  • createIndex(token, indexId, ctx, overrides?): Promise<ContractTransaction>

  • Parameters

    • token: string
    • indexId: BigNumberish
    • ctx: BytesLike
    • Optional overrides: Overrides & {
          from?: string;
      }

    Returns Promise<ContractTransaction>

deleteSubscription

  • deleteSubscription(token, publisher, indexId, subscriber, ctx, overrides?): Promise<ContractTransaction>

  • Parameters

    • token: string
    • publisher: string
    • indexId: BigNumberish
    • subscriber: string
    • ctx: BytesLike
    • Optional overrides: Overrides & {
          from?: string;
      }

    Returns Promise<ContractTransaction>

deployed

distribute

  • distribute(token, indexId, amount, ctx, overrides?): Promise<ContractTransaction>

  • Parameters

    • token: string
    • indexId: BigNumberish
    • amount: BigNumberish
    • ctx: BytesLike
    • Optional overrides: Overrides & {
          from?: string;
      }

    Returns Promise<ContractTransaction>

getIndex

  • getIndex(token, publisher, indexId, overrides?): Promise<[boolean, BigNumber, BigNumber, BigNumber] & {
        exist: boolean;
        indexValue: BigNumber;
        totalUnitsApproved: BigNumber;
        totalUnitsPending: BigNumber;
    }>

  • Parameters

    • token: string
    • publisher: string
    • indexId: BigNumberish
    • Optional overrides: CallOverrides

    Returns Promise<[boolean, BigNumber, BigNumber, BigNumber] & {
        exist: boolean;
        indexValue: BigNumber;
        totalUnitsApproved: BigNumber;
        totalUnitsPending: BigNumber;
    }>

getSubscription

  • getSubscription(token, publisher, indexId, subscriber, overrides?): Promise<[boolean, boolean, BigNumber, BigNumber] & {
        approved: boolean;
        exist: boolean;
        pendingDistribution: BigNumber;
        units: BigNumber;
    }>

  • Parameters

    • token: string
    • publisher: string
    • indexId: BigNumberish
    • subscriber: string
    • Optional overrides: CallOverrides

    Returns Promise<[boolean, boolean, BigNumber, BigNumber] & {
        approved: boolean;
        exist: boolean;
        pendingDistribution: BigNumber;
        units: BigNumber;
    }>

getSubscriptionByID

  • getSubscriptionByID(token, agreementId, overrides?): Promise<[string, number, boolean, BigNumber, BigNumber] & {
        approved: boolean;
        indexId: number;
        pendingDistribution: BigNumber;
        publisher: string;
        units: BigNumber;
    }>

  • Parameters

    • token: string
    • agreementId: BytesLike
    • Optional overrides: CallOverrides

    Returns Promise<[string, number, boolean, BigNumber, BigNumber] & {
        approved: boolean;
        indexId: number;
        pendingDistribution: BigNumber;
        publisher: string;
        units: BigNumber;
    }>

listSubscriptions

  • listSubscriptions(token, subscriber, overrides?): Promise<[string[], number[], BigNumber[]] & {
        indexIds: number[];
        publishers: string[];
        unitsList: BigNumber[];
    }>

  • Parameters

    • token: string
    • subscriber: string
    • Optional overrides: CallOverrides

    Returns Promise<[string[], number[], BigNumber[]] & {
        indexIds: number[];
        publishers: string[];
        unitsList: BigNumber[];
    }>

listeners

  • listeners<TEvent>(eventFilter?): TypedListener<TEvent>[]

  • Type Parameters

    • TEvent extends TypedEvent<any, any>

    Parameters

    • Optional eventFilter: TypedEventFilter<TEvent>

    Returns TypedListener<TEvent>[]

  • listeners(eventName?): Listener[]

  • Parameters

    • Optional eventName: string

    Returns Listener[]

queryFilter

  • queryFilter<TEvent>(event, fromBlockOrBlockhash?, toBlock?): Promise<TEvent[]>

  • Type Parameters

    • TEvent extends TypedEvent<any, any>

    Parameters

    • event: TypedEventFilter<TEvent>
    • Optional fromBlockOrBlockhash: string | number
    • Optional toBlock: string | number

    Returns Promise<TEvent[]>

realtimeBalanceOf

  • realtimeBalanceOf(token, account, time, overrides?): Promise<[BigNumber, BigNumber, BigNumber] & {
        deposit: BigNumber;
        dynamicBalance: BigNumber;
        owedDeposit: BigNumber;
    }>

  • Parameters

    • token: string
    • account: string
    • time: BigNumberish
    • Optional overrides: CallOverrides

    Returns Promise<[BigNumber, BigNumber, BigNumber] & {
        deposit: BigNumber;
        dynamicBalance: BigNumber;
        owedDeposit: BigNumber;
    }>

removeAllListeners

  • removeAllListeners<TEvent>(eventFilter): this

  • Type Parameters

    • TEvent extends TypedEvent<any, any>

    Parameters

    • eventFilter: TypedEventFilter<TEvent>

    Returns this

  • removeAllListeners(eventName?): this

  • Parameters

    • Optional eventName: string

    Returns this

revokeSubscription

  • revokeSubscription(token, publisher, indexId, ctx, overrides?): Promise<ContractTransaction>

  • Parameters

    • token: string
    • publisher: string
    • indexId: BigNumberish
    • ctx: BytesLike
    • Optional overrides: Overrides & {
          from?: string;
      }

    Returns Promise<ContractTransaction>

updateIndex

  • updateIndex(token, indexId, indexValue, ctx, overrides?): Promise<ContractTransaction>

  • Parameters

    • token: string
    • indexId: BigNumberish
    • indexValue: BigNumberish
    • ctx: BytesLike
    • Optional overrides: Overrides & {
          from?: string;
      }

    Returns Promise<ContractTransaction>

updateSubscription

  • updateSubscription(token, indexId, subscriber, units, ctx, overrides?): Promise<ContractTransaction>

  • Parameters

    • token: string
    • indexId: BigNumberish
    • subscriber: string
    • units: BigNumberish
    • ctx: BytesLike
    • Optional overrides: Overrides & {
          from?: string;
      }

    Returns Promise<ContractTransaction>

Settings

Member Visibility

Theme

On This Page

Generated using TypeDoc